js中数组的方法非常的多，功能也很强大。今天来总结一下js中数组的方法：
首先创建一个数组，数组中可以包含各种类型的数据：
var arr = [2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)}];
console.log(typeof arr); // object
console.log(arr.length); // 9
console.log(arr);// [2, 3, 5, "hello", true, "world", Array[3], Object, function]
一. 以下的7种方法会改变原数组：
1.unshift 在第一位添加一位或者多位数据，返回新数组的长度，会改变原数组
var arr1 = arr.unshift(9,10);
console.log(arr);// [9,10, 2, 3, 5, "hello", true, "world", Array[3], Object, function]
console.log(arr1); // 11
2.shift 删除第一位，返回删除的数据，会改变原数组
var arr2 = arr.shift();
console.log(arr);// [3, 5, "hello", true, "world", Array[3], Object, function]
console.log(arr2); // 2
3.push 在最后一位添加一位或者多位数据，返回新数组的长度，会改变原数组
var arr3 = arr.push(9,10,11);
console.log(arr);// [2, 3, 5, "hello", true, "world", Array[3], Object, function,9,10,11]
console.log(arr3); // 12
4.pop 删除最后一位，返回删除的数据，会改变原数组
var arr4 = arr.pop();
console.log(arr);// [2,3, 5, "hello", true, "world", Array[3], Object]
console.log(arr4); // function(){console.log(1)}
5.splice 在索引为n的开始（包括n）的往后将m个值替换为（k1,k2,k3...kk）删除指定位置，并替换，返回删除的数据，会改变原数组
var arr5 = arr.splice(1,3,"a","b");
console.log(arr);// [2, "a", "b", true, "world", Array[3], Object, function]
console.log(arr5); // [3, 5, "hello"]
6.sort 排序（字符规则），返回结果，会改变原数组
(1)数值排序（升序）
var arr = [1,2,5,3,6];
var arr6 = arr.sort(function(a,b){return a-b});
console.log(arr);// [1, 2, 3, 5, 6]
console.log(arr6); // [1, 2, 3, 5, 6]
(2)字符排序
var arr = ["a","hello","world","zoom","lily","boy"];
var arr6 = arr.sort();
console.log(arr);// ["a", "boy", "hello", "lily", "world", "zoom"]
console.log(arr6); // ["a", "boy", "hello", "lily", "world", "zoom"]
7.reverse 反转数组，返回结果,会改变原数组
var arr7 = arr.reverse();
console.log(arr);// [function, Object, Array[3], "world", true, "hello", 5, 3, 2]
console.log(arr7); // [function, Object, Array[3], "world", true, "hello", 5, 3, 2]
二. 以下的14种方法不会改变原数组:
var arr = [2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)}];
1.slice(n,m)
功能：截取指定位置[n,m)的数组，并返回
参数：n表式开始的索引位置，m表式结束的索引位置(不包括)
返回值：截取后的新数组
demo:
var arr1 = arr.slice(2,5);
console.log(arr);// [2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)}];
console.log(arr1); // [5,"hello",true]
2.concat(data1,data2,....)
功能：合并数组，并返回合并之后的数据
参数：所有参数可选，要合并的数据；data为数组时，将数组中的数据合并到原数组；data为具体数据时直接添加到原数组尾部；参数省略时创建原数组的副本
返回值：合并的新数组
demo:
var arr2 = arr.concat();
console.log(arr); // 原数组
console.log(arr2); // [2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)}];
console.log(arr == arr2); // false
console.log(arr.concat(12,34)); // [2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)},12,34];
console.log(arr.concat([1,2],[[56,"he"],"and",{"gender":0,"major":"electric"}])); // [2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)},1,2,[56,"he"],"and",{"gender":0,"major":"electric"}];
3.join(str)
功能：根据指定分隔符将数组中的所有元素放入一个字符串，并返回这个字符串
参数：参数可选，默认不写将数组直接去掉括号成为字符串返回，否则以传入的字符作为分隔符
返回值：拼接的字符串
demo:
var str31 = arr.join();
var str32 = arr.join("*");
console.log(arr); // 原数组
console.log(str31); // 2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)}
console.log(str32); // 2*3*5*hello*true*world*5,6,7*[object Object]*function(){console.log(1)}
4.toString()
功能：转换成字符串，类似于没有参数的join()。该方法会在数据发生隐式类型转换时被自动调用，如果手动调用，就是直接转为字符串
参数：无
返回值：字符串
demo：
var str4 = arr.toString();
console.log(arr);// 原数组
console.log(str4); // 2,3,5,"hello",true,"world",[5,6,7],{"name":"lily","age":18},function(){console.log(1)}
5.valueOf()
功能：返回数组的原始值（一般情况下其实就是数组自身），一般由js在后台调用，并不显式的出现在代码中
参数：无
返回值：原数组
demo：
var arr5 = arr.valueOf();
console.log(arr); // 原数组
console.log(arr5); // 原数组
console.log(arr === arr5); // true
6.indexOf(value, start)
功能：根据指定的数据，从左向右，查询在数组中出现的位置，如果不存在指定的数据，返回-1。该方法是查询方法，不会对数组产生改变
参数：value为要查询的数据；start为可选，表示开始查询的位置，从前往后查询；当start为负数时，还是从前往后查，返回的是正数索引；如果查询不到value的存在，则方法返回-1
返回值：查询到的索引位置，查询不到返回-1
demo：
var index61 = arr.indexOf("hello");
var index62 = arr.indexOf("hello",3);
var index63 = arr.indexOf("hello",4);
var index64 = arr.indexOf("hello",-1);
var index65 = arr.indexOf("hello",-3);
var index66 = arr.indexOf("hello",-9);
console.log(arr);// 原数组
console.log(index61); // 3
console.log(index62); // 3
console.log(index63); // -1
console.log(index64); // -1
console.log(index65); // -1
console.log(index66); // 3
7.lastIndexOf(value, start)
功能：根据指定的数据，从后往前查询，查询在数组中出现的位置，如果不存在指定的数据，返回-1。
参数：value为要查询的数据；start为可选，表示开始查询的位置，从索引位置往前查询；start可以为负数，从数组负数索引位置往前查询，返回的是正数索引；如果查询不到value的存在，则方法返回-1
demo：
var lastind71 = arr.lastIndexOf("hello");
var lastind72 = arr.lastIndexOf("hello",3);
var lastind73 = arr.lastIndexOf("hello",2);
var lastind74 = arr.lastIndexOf("hello",-1);
var lastind75 = arr.lastIndexOf("hello",-3);
var lastind76 = arr.lastIndexOf("hello",-9);
console.log(arr);// 原数组
console.log(lastind71); // 3
console.log(lastind72); // 3
console.log(lastind73); // -1
console.log(lastind74); // 3
console.log(lastind75); // 3
console.log(lastind76); // -1
8.forEach(function(value,index,self){})--forEach(callback)
功能：ES5新增方法，用来遍历数组，该方法没有返回值。forEach接收的回调函数会根据数组的每一项执行，该回调函数默认有三个参数
参数：value为遍历到的数组的数据,index为对应的索引,self为数组自身
返回值：无(undefined,因为回调函数没有return)
demo：
var a8 = arr.forEach(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self));
// 2--0--true
// 3--1--true
// 5--2--true
// hello--3--true
// true--4--true
// world--5--true
// 5,6,7--6--true
// [object Object]--7--true
// function(){console.log(1)}--8--true
});
console.log(arr);// 原数组
console.log(a8); // undefined
9.map(callback)
功能：1.同forEach功能；2.map的回调函数会将执行结果返回，最后map将所有回调函数的返回值组成新数组返回
参数：callback默认有三个参数，分别为value，index，self
返回值：新数组
demo(功能2)：
var arr9 = arr.map(function(value,index,slef){
return "hello" + value;
}) ;
console.log(arr);// 原数组
console.log(arr9);// ["hello2", "hello3", "hello5", "hellohello", "hellotrue", "helloworld", "hello5,6,7", "hello[object Object]", "hellofunction(){console.log(1)}"]
10.filter
功能：1.同forEach功能；2.filter的回调函数需要返回布尔值，当为true时，将本次数组的数据返回给filter，最后filter将所有回调函数的返回值组成新数组返回（此功能可理解为“过滤”）。
参数：callback默认有三个参数，分别为value，index，self
返回值：过滤的符合条件的数据组成的数组
demo(功能2)：
var arr10 = arr.filter(function(value,index,self){
return typeof value == "string"; // 注意string要小写
});
console.log(arr);// 原数组
console.log(arr10); // ["hello","world"]
11.some(callback)
功能：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true
参数：some()接收一个回调函数作为参数，这个回调函数需要有返回值，some(callback);callback默认有三个参数，分别为value，index，self
返回值：true/false
功能1：因为要判断数组中的每一项，只要有一个回调函数返回true，some都会返回true，所以与every正好相反，当遇到一个回调函数的返回值为true时，可以确定结果，那么停止执行，后面都数据不再遍历，停在第一个返回true的位置；当回调函数的返回值为false时，需要继续向后执行，到最后才能确定结果，所以会遍历所有数据，实现类似于forEach的功能，遍历所有
功能2：与every相反，只要有一个回调函数的返回值都为true，some的返回值为true，所有回调函数的返回值为false，some的返回值才为false
demo1：
var bool111 = arr.some(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self));
// 2--0--true
// 3--1--true
// 5--2--true
// hello--3--true
return value.length > 3;
});
console.log(arr);// 原数组
console.log(bol111); // true
demo2：
var bool112 = arr.some(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self));
// 2--0--true
return true;
});
console.log(arr);// 原数组
console.log(bool112); // true
demo3：
var bool113 = arr.some(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self));
// 2--0--true
// 3--1--true
// 5--2--true
// hello--3--true
// true--4--true
// world--5--true
// 5,6,7--6--true
// [object Object]--7--true
// function(){console.log(1)}--8--true
return false;
});
console.log(arr);// 原数组
console.log(bool113); // false
12.every(callback)
功能：判断数组中每一项是否都满足条件，只有所有项都满足条件，才会返回true
参数：every()接收一个回调函数作为参数，这个回调函数需要有返回值，every(callback);callback默认有三个参数，分别为value，index，self
功能1：当回调函数的返回值为true时，类似于forEach的功能，遍历所有；如果为false，那么停止执行，后面的数据不再遍历，停在第一个返回false的位置
功能2：当每个回调函数的返回值都为true时，every的返回值为true，只要有一个回调函数的返回值为false，every的返回值都为false
demo1：
var bool121 = arr.every(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self));
// 2--0--true
});
console.log(arr);// 原数组
console.log(bool121); // false
解释：因为回调函数中没有return true，默认返回undefined，等同于返回false
demo2：
var bool122 = arr.every(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self));
// 2--0--true
// 3--1--tr
// 5--2--true
// hello--3--true
// true--4--true
// world--5--true
// 5,6,7--6--true
// [object Object]--7--true
// function(){console.log(1)}--8--true
return true;
});
console.log(arr);// 原数组
console.log(bool122); // true
13.reduce(callback,initial)
功能：从数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值。
参数1：callback是回调函数，表示在数组的每一项上调用的函数。callback默认有四个参数，分别为prev，now，index，self。callback返回的任何值都会作为下一次执行的第一个参数prev。如果initial参数被省略，那么第一次迭代发生在数组的第二项上，因此callback的第一个参数是数组的第一项，第二个参数就是数组的第二项。
参数2：initial，可选。作为归并的初始值，被回调函数第一次执行时的第一个参数prev接收
返回值：callback的return返回值
demo1(有initial，无return)：
var a131 = arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self))
}, 2019);
// 2019--2--0--true
// undefined--3--1--true
// undefined--5--2--true
// undefined--hello--3--true
// undefined--true--4--true
// undefined--world--5--true
// undefined--5,6,7--6--true
// undefined--[object Object]--7--true
// undefined--function(){console.log(1)}--8--true
console.log(arr);// 原数组
console.log(a131); // undefined
解释：回调函数没有返回值，所以从第二次递归开始，prev值为undefined
demo2(无initial，无return)：
var a132 = arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self))
});
// 2--3--1--true
// undefined--5--2--true
// undefined--hello--3--true
// undefined--true--4--true
// undefined--world--5--true
// undefined--5,6,7--6--true
// undefined--[object Object]--7--true
// undefined--function(){console.log(1)}--8--true
console.log(arr);// 原数组
console.log(a132); // undefined
解释：没有initial，第一次的prev值是数组的第一个值，数组的第二个值作为now值；回调函数没有返回值，所以从第二次递归开始，prev值为undefined
demo3(无initial，有return)：
var a133 = arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self));
return "hello";
});
// 2--3--1--true
// hello--5--2--true
// hello--hello--3--true
// hello--true--4--true
// hello--world--5--true
// hello--5,6,7--6--true
// hello--[object Object]--7--true
// hello--function(){console.log(1)}--8--true
console.log(arr);// 原数组
console.log(a133); // hello
解释：没有initial，第一次的prev值是数组的第一个值，数组的第二个值作为now值；回调函数有返回值，所以从第二次递归开始，prev值为hello
demo4(有initial，有return)：
var a134 = arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self));
return "hello";
}, 2019);
// 2019--2--0--true
// hello--3--1--true
// hello--5--2--true
// hello--hello--3--true
// hello--true--4--true
// hello--world--5--true
// hello--5,6,7--6--true
// hello--[object Object]--7--true
// hello--function(){console.log(1)}--8--true
console.log(arr);// 原数组
console.log(a134); // hello
demo5(无initial，利用reduce计算数组的和)
var arra = [2,3,4,5,6];
var sum1 = arra.reduce(function(prev,now,index,self){
return prev + now;
});
console.log(arra);// 原数组
console.log(sum1); // 20
demo6(有initial，利用reduce计算数组的和-- sum = 数组中各数组的和 + initial)
var arra = [2,3,4,5,6];
var sum2 = arra.reduce(function(prev,now,index,self){
return prev + now;
},5);
console.log(arra);// 原数组
console.log(sum2); // 25
14.reduceRight
功能：（与reduce类似）从数组的最后一项开始，向前逐个遍历到第一位，迭代数组的所有项，然后构建一个最终返回的值
文中部分内容借鉴了前人的成果，也补充了自己的想法，如有不正确的内容，欢迎大家指正...