关于js数组的用法有很多，下面主要针对一些简单的操作，比如合并，反转，添加删除等简单的操作总结一下。
关于js数组的用法有很多，下面主要针对一些简单的操作，比如合并，反转，添加删除等简单的操作总结一下。
第一：读取数组 for循环
方法如下：
var ay=[1,"sdsd","sdsd"]
for (var i=0i<ay.lengthi++) {
console.log("index:"+i+" "+ay[i]) //index：0 1 index：1 sdsd index：2 sdsd
}
第二：合并数组 concat
方法如下：
var arr1=['w','e','s']
var arr2=['e','y','u']
var arr3=arr1.concat(arr2)
console.log(arr3) //['w','e','s''e','y','u']
第三：数组变为字符串格式 join
方法如下：
var arr1=['w','e','s']
var arr4=arr1.join()
console.log(arr4) //w,e,s
第四：删除最后一个元素,针对老数组是删除最后一个,针对新数组是返回最后一个 pop
var arr6=["d","s","t"]
var arr7=arr6.pop()
console.log(arr6) // ["d","s"]
console.log(arr7)// t
第五：添加最后一个元素，针对老数组最后一个元素后面添加一个元素，新数组返回元素个数 push
var arr8=["i","u","t"]
var arr9=arr8.push("k")
console.log(arr8)//["i","u","t","k"]
console.log(arr9)// 4
第六：shift() 和pop()一样，不同的是操作的是开头删除的元素shift（）；具体操作不在展示
第七：unshiift()和push一样，不同的是操作的是开头添加的元素unshift（）；具体操作不再展示
第八：反转数组 reverse
方法如下：
var arr1=['w','e','s']
var arr10=arr1.reverse()
console.log(arr10) //['s','e','w']
第九：数组排序 sort a-b正向 b-a 反向
正向
var arr11=[3,1,5,8,28]
var arr12=arr11.sort(function (a,b) {
return a-b
})
console.log(arr12) //[1,3,5,8,28]
反向
var arr13=arr11.sort(function (a,b) {
return b-a
})
console.log(arr13) //[28,8,5,3,1]
第十：数组截取 数组截取的方法主要有slice 和splice，另外说到截取我这里随便也把字符串截取带上，字符串截取的方法主要有substr 和substring
（1）slice 使用方法arr.slice(m,n)其中arr为数组，m，n为两个参数，意思是从已有数组中返回选定的元素，截取位置均为下标，其中m必须，为起始位置，可以为负值，n为结束位置（截取位置并不包含）。
示例如下：
①只有起起始值，并且为正，默认的从起始位置一直到整个数组结束，起始下标从0开始
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1)
console.log(arr) // [2,3,5,6,8,9] 老数组是没有变化的，下面不在列举，都是一样的
console.log(arr1) //[3,5,6,8,9] 只有起始参数，并且为正值，返回新数组从下标1开始截取
②只有起始值，并且为负，默认的是从起始位置一直到整个数组结束，此处没有起始值，数组的最后一个下标是-1，比如此例，如果从-6开始取，必定是整个数组
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1)
console.log(arr1) //[9] 只有起始参数，并且为负值，从数组尾部截取元素
③有起始值和结束值，并且为正，此处需注意下标是从小到大，比如你（3，1）肯定是取不到值的，另外截取的下标个数并不包含最后一个下标
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1,4)
console.log(arr1) //[3,5,6] 此时是从下标1开始到下标4，但是需要注意的是并不包含下标4，准确的说是1-3的下标
④有起始值和结束值，并且为负，此处需注意下秒也是从小到大，同理，比如（-1，-6）也是肯定取不到值的，另外截取的下标个数也并不包含最后一个下标
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-6,-1)
console.log(arr1) //[2,3,5,6,8]
⑤有起始值和结束值，并且正负都有
负值到0
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1,0)
//刚刚都看到了，数组下标都是从小到大的，所以说如果正负都有的情况下，理论上应该可以取值的，比如这个例子，-1为9的小标，0为2的下标，所以取值应该为 [9]，但是结果并不是这样的
console.log(arr1) //[ ] 从这里可以看出他的结果是为空的，所以从负值到0结果是取不到的
负值到正直
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1,2)
//那从负值到正值呢，同样也是取不到值的
console.log(arr1) //[ ]
正直到负值
var arr=[2,3,5,6,8,9]
var arr1=arr.slice(2,-1)
//那从正直到负值，这个理论上是取不到的，但是看下结果
console.log(arr1) //[ 5，6，8] 从结果可以看出是可以取的 原理是2的下标为5，-1的下标为9，不包含结束位置下标
总结：这个方法看着可能会麻烦些（也可能被我写的麻烦啦），比如正到负等，不知道大家都是怎么操作，我一般用这个取值都是只截取正的，所以这个实际操作还是非常简单的。
（2）splice 像数组中添加或者删除元素
arr.splice(m,n,index,index1,...,indexx)
m是起始位置，n是删除元素的个数，index是要添加的元素，在不添加元素的前提下，只有第一个参数是必须的，后面两个都不是必须的，在需要添加元素的情况下，三个元素都是必须的，此方法和slice是不一样的，这个返回的是被删除的元素
示例如下：
只删除不添加
注意看此例，是（1，2）删除两个，如果是（1，0），则表示删除零个，也就是不删除的意思，如果只有一个参数则表示从这里开始删除，比如是（1）则为[2]，当然这个也是可以取负值，但是这个和slice是不一样的，只能起始位置取负值，因为删除的个数不可能为负值，slice可以取（2，-1），这个就截然不同啦，但是刚刚也说啦，slice是不可以起始位置取负值，结束位置取正的，但是这个是可以的，比如（-1，0）则表示从-1开始删除零个，结果为[2,3,5,6,8,9]，（-6，2),结果为[5,6,8,9]，另外这个删除的第二个值如果写的过大，也只是删除从本下标到最后一个，比如（2，78）为[2,3]
var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2)
console.log(arr) // [2,6,8,9] 注意看此处才是我们要的数组，从下标1开始删除删除两个
console.log(arr1) //[3,5] 此处是我们删除掉的数组
删除加添加 具体的和上面的差不多，主要添加了添加元素的效果，这个也可以添加多个元素
var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2,"il")
console.log(arr) //[2,"li",6,8,9]
console.log(arr1) //[3,5]
总结：此方法用的时候，一般也都是只取正值
（3）substr 这个是字符串的用法 用法arr.substr(m,n) m必选也可以负值 n选填，注意看这个并不是结束为止而是截取的个数
示例如下：
只有一个参数 默认从此下标开始，取后面所有的
正值
var arr="sdhgfhf"
var arr1=arr.substr(1)
console.log(arr)// "sdhgfhf"这个是不变的，下面不再列举
console.log(arr1)// "dhgfhf" 从下标1开始取后面所有的
负值
var arr="sdhgfhf"
var arr1=arr.substr(-2)
console.log(arr1)// "hf" 从下标-2开始取后面所有的
两个参数，从第一个下标开始，截取到下标2的长度
var arr="sdhgfhf"
var arr1=arr.substr(1，3)
console.log(arr1)// "dhg" 从下标1开始取后面所有的 同理如果为负值，比如（-6，3）则为"hjf"后面的始终为长度
总结：此方法需注意不要和数组的混淆，这个是截取长度的
（4）substring 用法arr.substring(m,n) 两个参数，m必须，起始位置 ，n选填，截取下标的结束位置，此用法和上面slice有点类似，但是需要注意的是此方法是不支持负值的
示例如下：
只有一个参数
var arr="sdhgfhf"
var arr1=arr.substring(1)
console.log(arr1)//"dhgfhf"从下标1开始取后面所有的
两个参数
var arr="sdhgfhf"
var arr1=arr.substring(1,3)
console.log(arr1)// "dh"从下标1开始截取到下标3，但是不包含3
总结：此方法不支持负值，只针对下标来截取的
最后，以上主要是总结的数组的一些简单的操作方法，学无止境，继续努力。
1：首先最基本的数组方法。push,pop,shift,unshift.
2:splice()最终返回的都是当前操作的数组，具体操作后的结果要看读取原来的字符串。
3：splice(num,num,"n1","n1").如左所示，可以增加，删除，替换字符串。第一个数是开始的位置，第二个数是向后操作几个数，第三个是要换的数组。
4：slice(num1,num2)是用来从已有的数组或字符串中提取返回特定的元素的。他是不会改变原来的字符串。
5：分号使用的原则：缺少的分号会有分号自动插入机制，但是者不可靠。规则是以块结束的语句不要分号。
6：在调用数字变量的方法时，区分浮点数的点号还是调用方法的点运算符很重要。1..toString().
7:严格模式：为了让js书写变得更加好。
8：sort函数：主要用来对数组排序，默认情况下是将数组元素转变成字符串，按照那个编码比较，包括数字也是这样比的。还是只比较第一个数字。。如果想要实现自己的自定义排序，就要在sort()里面加自定义函数。
9：数组的话还得看那些forEach().Map().filter()
10:对象的比较不是值得比较，即使两个对象包含相同的属性，他们也不相同。
12:在Vue中检测数组更新，包括变异方法：pop，unshift. splice(),sort(),reverse()
非变异方法：这些方法是不会返回原数组的，而是会加载一个新的数组。
11：一些字符串方法。
var text=document.getElementById('text')
var lines=text.value.split("\n")
var result="
"
for(var i=0i
result+=lines[i]
}
result+=""
var div=document.getElementById('div')
div.innerHTML=result
// setInterval(function(){
// div.innerHTML="sdfsdfsd"
// },1000)
}
12:数组是从索引0开始的自然数到任意值的印射。这些值是成为数组的元素。
13：数组可以在作为索引到值得印射，换句话来说，数组可能不是连续的，中间可以有空缺。
14：其中没有定义的是undefined.绝大数的js引擎都会自动去重，并连续保存元素。
15:数组也可有对象，并且可以拥有对象的属性。但是并不认为那些属性是实际数组的一部分。
16：多维数组的操作：var rows=[]for(var rowCount=0rowCount<5rowCount++){rows[rowCount]=[]for(var colCount=0colCount<5colCount++){rows[rowCount][colCount]='.'}}rows[0][2]='x'rows.forEach(function(row){console.log(row.join(''))})当矩阵较小的且纬度固定，可以通过数组字面量来创建。
17：多维数组怎么创建？var infos =
[
['小A','女',21,'大一'],
['小B','男',23,'大三'],
['小C','男',24,'大四'],
['小D','女',21,'大一'],
['小E','女',22,'大四'],
['小F','男',21,'大一'],
['小G','女',22,'大二'],
['小H','女',20,'大三'],
['小I','女',20,'大一'],
['小J','男',20,'大三']
]var arr=[]
var n=0
for(var i=0i<infos.lengthi++){
if(infos[I][3]=="大一"){arr[n]=infos[i]console.log(arr[n])}
}
n++
}
18：另一种初始化的方法：var tArray = new Array()
for(var k=0k<pK++){
tArray[k]=new Array(){
for(var j=0j<pj++){
tArray[k][j]=""
}
}
}然后在下面赋值。。。
19：数组索引之外的索引被视为普通的属性值。他们不会作为数组元素呈现，也不会影响length的属性。
20：in 操作符用来查看数组中是否有这个索引的值，这有必要么？还有别的用么？
21：delete不仅可以删除对象，还可以删除数组内的元素，这个删除不会产生空缺。不会更新length.
定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。
目的：Array.of() 出现的目的是为了解决上述构造器因参数个数不同，导致的行为有差异的问题。
参数：
第一个参数(必需):要转化为真正数组的对象。
第二个参数(可选): 类似数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。
第三个参数(可选): 用来绑定this。
ps：splice方法从数组中添加/删除项目，然后返回被删除的项目
语法： array.splice(index,howmany,item1,.....,itemX)
参数:
index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX： 可选。向数组添加的新项目。
返回值: 如果有元素被删除,返回包含被删除项目的新数组。
删除元素
删除并添加
不删除只添加
ps：方法接受两个参数，一个从哪里开始，一个是到哪里结束（但是不包括这个结束的元素本身）。如果是负数，就从倒数第几个。
参数可选: 规定排序顺序的比较 函数 。
默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。
比较函数的两个参数
sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：
sort排序常见用法
数组元素为数字的升序、降序:
数组多条件排序
自定义比较函数
定义: 在当前数组内部，将指定位置的成员复制到其他位置,并返回这个数组。
语法: array.copyWithin(target, start = 0, end = this.length)
参数:
三个参数都是数值，如果不是，会自动转为数值.
target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。
浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持
从上述例子:
第一个参数是开始被替换的元素位置
要替换数据的位置范围:从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取
数组的长度不会改变
读了几个元素就从开始被替换的地方替换几个元素
参数:
第一个元素(必须): 要填充数组的值
第二个元素(可选): 填充的开始位置,默认值为0
第三个元素(可选)：填充的结束位置，默认是为this.length
使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？
join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[object Object]字符串。
如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。
该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不推荐使用。
ps：当数组和字符串操作的时候，js 会调用这个方法将数组自动转换成字符串
ps：字符串也有一个slice() 方法是用来提取字符串的，不要弄混了。
参数:
begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。
end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括最后一个元素)。
如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。
如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变
原因在定义上面说过了的：slice()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。
ES6扩展运算符...合并数组：
因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。
参数:
searchElement(必须):被查找的元素
fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。
严格相等的搜索:
数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。
注意：indexOf()不能识别NaN
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。
关于fromIndex有三个规则:
正值。如果该值大于或等于数组的长度，则整个数组会被查找。
负值。将其视为从数组末尾向前的偏移。(比如-2，从数组最后第二个元素开始往前查找)
负值。其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
参数：
searchElement(必须):被查找的元素
fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过长数组度，重置从0开始搜索。
includes方法是为了弥补indexOf方法的缺陷而出现的:
indexOf方法不能识别NaN
indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观
