关于数组的方法汇总

1，js创建数组的方法
（1）使用Array构造函数：
var arr1 = new Array(); //创建一个空数组
var arr2 = new Array(20); // 创建一个包含20项的数组
var arr3 = new Array(“lily”,“lucy”,“Tom”); // 创建一个包含3个字符串的数组
（2）使用数组字面量表示法：
var arr4 = []; //创建一个空数组
var arr5 = [20]; // 创建一个包含1项的数组
var arr6 = [“lily”,“lucy”,“Tom”]; // 创建一个包含3个字符串的数组

注意：例2是有差别的
2，数组的原型方法
不改变原数组：
（1）join()：将数组的元素组起一个字符串，该方法只接收一个参数：即分隔符。

var arr = [1,2,3];
console.log(arr.join()); // 1,2,3 默认，为分隔符
console.log(arr.join("-")); // 1-2-3
console.log(arr); // [1, 2, 3]（原数组不变）

注意：join()方法可以实现重复字符串，传入字符串以及重复的次数

function repeatString(str, n) {
return new Array(n + 1).join(str);
}
console.log(repeatString("abc", 3)); // abcabcabc
console.log(repeatString("Hi", 5)); // HiHiHiHiHi

（2）concat():将参数添加到原数组末尾，返回新数组，arr.concat()复制当前数组并返回副本。

var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);--参数可以是字符串，数字也可以是数组（各项都传入）
console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
console.log(arr); // [1, 3, 5, 7](原数组不变)
注意：如果传入二维数组
var arrCopy2 = arr.concat([9,[11,13]]);
console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]即[1, 3, 5, 7, 9, [11, 13]]
console.log(arrCopy2[5]); //[11, 13]--把这一数组项当作一项传入

（3）slice():返回从原数组中指定开始下标到结束下标之间的项组成的新数组,俩个参数时-返回起始和结束位置之间的项——但不包括结束位置的项,一个参数时-返回从该参数指定位置开始到当前数组末尾的所有项。

var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1); 1~最后
var arrCopy2 = arr.slice(1,4); 1~3
var arrCopy3 = arr.slice(1,-2);  注：终止下标为负数，当出现负数时，将负数加上数组长度的值（6）来替换该位置的数，即1~（-2+6-1）
var arrCopy4 = arr.slice(-4,-1); （-4+6）~（-1+6-1）
console.log(arr); //[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy); //[3, 5, 7, 9, 11]
console.log(arrCopy2); //[3, 5, 7]
console.log(arrCopy3); //[3, 5, 7]
console.log(arrCopy4); //[5, 7, 9]

（4）indexOf()和lastIndexOf():返回要查找的项在数组中的位置，或者在没找到的情况下返回-1,全等比较。

indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。  
lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。

var arr = [1,3,5,7,7,5,3,1]; ---0~7，length：8
console.log(arr.indexOf(5)); //2
console.log(arr.lastIndexOf(5)); //5
console.log(arr.indexOf(5,2)); //2 ---从下标2（5）开始向后查找5的下标
console.log(arr.lastIndexOf(5,4)); //2 ---从后开始的下标4（7）开始向前查找5的下标
console.log(arr.indexOf("5")); //-1 ---字符串5不存在

（5）forEach():对数组进行遍历循环，没有返回值。
参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
console.log(x + '|' + index + '|' + (a === arr));
});
// 输出为：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true
一般用法：
arr.forEach((item,index)=>{})

（6）map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组,有返回值。

实现数组中每个数求平方：
ar arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
return item*item;
});
console.log(arr2); //[1, 4, 9, 16, 25]
一般用法
arr.map((item,index)=>{ 可return })

（7）filter():过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
return index % 3 === 0 || x >= 8;--下标除以3余数是0或者item大于8的值
}); 
console.log(arr2); //[1, 4, 7, 8, 9, 10]

（8）every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
}); 
console.log(arr2); //true
var arr3 = arr.every(function(x) {
return x < 3;
}); 
console.log(arr3); // false

（9）some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;
}); 
console.log(arr2); //true
var arr3 = arr.some(function(x) {
return x < 1;
}); 
console.log(arr3); // false

注意：some和every的区别。
（10）reduce()和 reduceRight()：接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。但传给 reduce()和 reduceRight()的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。相当于这个函数的返回值作为他俩的第一个参数，实现迭代数组的所有项，然后构建一个最终返回的值。
不同的是：reduce()方法从数组的第一项开始，逐个遍历到最后。reduceRight()则从数组的最后一项开始，向前遍历到第一项。

var arr = [10,20,30,40,50];
    arr.reduce(function(prev,now,index,self){
        console.log(prev + "--" + now + "--" + index + "--" + (arr == self))
    }, 2019)
    // 打印结果为：
    // 2019--10--0--true
    // undefined--20--1--true
    // undefined--30--2--true
    // undefined--40--3--true
    // undefined--50--4--true
    // 此时回调函数没有return，所以从第二次开始，prev拿到的是undefined

var arr = [10,20,30,40,50];
    arr.reduce(function(prev,now,index,self){
        console.log(prev + "--" + now + "--" + index + "--" + (arr == self));
        return "hello";
    }, 2019)
    // 打印结果为：
    // 2019--10--0--true
    // hello--20--1--true
    // hello--30--2--true
    // hello--40--3--true
    // hello--50--4--true
    // 此时回调函数有return，所以从第二次开始，prev拿到的是回调函数return的值

 //demo1：使用reduce计算数组中所有数据的和
    var arr = [10,20,30,40,50];
    var sum = arr.reduce(function(prev,now,index,self){
        return prev + now;
    })
    console.log(sum);      //150
    // 回调函数的最后一次return的结果被返回到reduce方法的身上

    //demo2：使用reduce计算数组中所有数据的和
    var arr = [10,20,30,40,50];
    var sum = arr.reduce(function(prev,now,index,self){
        return prev + now;
    }, 8)
    console.log(sum);      //158
    // 回调函数的最后一次return的结果被返回到reduce方法的身上
    // 因为reduce有第二个参数initial，在第一次执行时被计算，所以最终结果被加上8

改变原数组：
（11）push()和pop()：操作末尾
push(): 可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。
pop()：数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项。

var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count); // 5--个数/长度
console.log(arr); // ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item); // Sean--删除的元素
console.log(arr); // ["Lily", "lucy", "Tom", "Jack"]

（12）shift() 和 unshift()：操作头部

shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。  
unshift:将参数添加到原数组开头，并返回数组的长度 。

var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count); // 5
console.log(arr); //["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item); // Jack
console.log(arr); // ["Sean", "Lily", "lucy", "Tom"]

（13）sort()：按升序排列数组项——即最小的值位于最前面，最大的值排在最后面。
注意：a:这里的排序是针对字符的排序，先使用数组的toString()方法转为字符串，再逐位比较，3是大于12的，因为首位3>1，不要与Number型的数据排序混淆

b:str2数组中增加了三个字符，可以看到，比较的时候，zoom是最大的，因为首位的英文字母通过ASCII码可以转为相应的数值，再根据数值比较。

var str1 = [12,2,43,5,2,5];
var str2 = [92,2,43,"hello",5,2,5];
console.log(str1.sort());//[12, 2, 2, 43, 5, 5]
console.log(str1);//[12, 2, 2, 43, 5, 5]--原数组改变
console.log(str2.sort());//[2, 2, 43, 5, 5, 92, "abc", "hello", "zoom"]
console.log(str2);//[2, 2, 43, 5, 5, 92, "abc", "hello", "zoom"]--原数组改变

c:sort(callback)如果需要按照数值排序，需要传参。sort(callback)，callback为回调函数，该函数应该具有两个参数，比较这两个参数，然后返回一个用于说明这两个值的相对顺序的数字（a-b）。
其返回值如下：

   若 a 小于 b，返回一个小于 0 的值。
   若 a 等于 b，则返回 0。
   若 a 大于 b，则返回一个大于 0 的值。

var str3 = [92,2,43,5,2,5]; 
function fn (a,b){
　　　　return a-b;----升序
 }
 console.log(str3.sort(fn));//[2, 2, 5, 5, 43, 92]
 console.log(str3);//[2, 2, 5, 5, 43, 92]
function fn (a,b){
　　　　return b-a;----降序
 }
 console.log(str3.sort(fn));//[92,43,5,5,2, 2]
 console.log(str3);//[92,43,5,5,2, 2]

(14)reverse()：反转数组项的顺序。

var arr = [13, 24, 51, 3];
console.log(arr.reverse()); //[3, 51, 24, 13]
console.log(arr); //[3, 51, 24, 13](原数组改变)

(15)splice():可以实现删除、插入和替换,返回一个数组，该数组中包含从原始数组中删除的项，如果没有删除任何项，则返回一个空数组。
a:删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项。
b:插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。
c:替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入4和6。

var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);--从第一位开始删除2位
console.log(arr); //[5, 7, 9, 11] --改变原数组
console.log(arrRemoved); //[1, 3]---删除的数组
var arrRemoved2 = arr.splice(2,0,4,6);--在数组的第二位插入4,6俩个元素
console.log(arr); // [5, 7, 4, 6, 9, 11]--改变原数组
console.log(arrRemoved2); // []--插入的数组
var arrRemoved3 = arr.splice(1,1,2,4);--删除数组第一位的7，替换成2,4
console.log(arr); // [5, 2, 4, 4, 6, 9, 11]--改变原数组
console.log(arrRemoved3); //[7]--替换的数组

可速记：俩个参数splice(a,b)从a位开始删除b位

    三个参数splice(a,b,c):b是0为插入，b是1为替换，a是开始位置，c代表一个或多个元素