JS数组常用方法

1. push

   • 作用：给数组末尾添加一项
   • 返回值：数组的最新长度
   • 原数组发生改变

   var a = [2,3,4];
   var b = a.push(5);
   console.log(a);  //[2,3,4,5]
   console.log(b);  //4
   

2. pop

   • 作用：删除数组最后一项
   • 返回值：被删除的内容
   • 原数组发生改变

   var arr = [2,3,4];
   console.log(arr.pop()); //4
   console.log(arr);  //[2,3]
   

3. unshift

   • 作用：给数组开头增加新内容
   • 返回值：数组的最新长度
   • 原数组发生改变

   var arr = [2,3,4,5];
   console.log(arr.unshift(3,6)); //6
   console.log(arr); //[3, 6, 2, 3, 4, 5]
   

4. shift

   • 作用：删除数组第一项
   • 返回值：被删除的内容
   • 原数组发生改变

   var arr = [2,3,4];
   console.log(arr.shift()); //2
   console.log(arr);  //[3,4]
   

5. splice

   • splice(n,m,x)
   • 作用：从索引n开始，删除m个，替换成x新内容；
   • 返回值：被删除的数据以一个新数组的形式返回；
   • 原数组改变
   • 用该方法可以进行添加或删除元素，如果添加，则m=0， 如果需要删除，则不传x

   var a = [5,6,7,8];
   console.log(a.splice(1,0,9)); //[]
   console.log(a);  // [5, 9, 6, 7, 8]
   var b = [5,6,7,8];
   console.log(b.splice(1,2,3));  //[6, 7]
   console.log(b); //[5, 3, 8]
   

6. slice

   • slice(n,m)
   • 作用：截取(查找)索引n到索引m，但是不包含m；
   • 返回值：截取的项以数组的形式返回
   • 原数组不改变

   var arr = [2,3,4,5];
   console.log(arr.slice(1,3));  //[3,4]
   console.log(arr);  //[2,3,4,5]
   

7. concat

   • ary.concat(ary1,ary2...);
   • 作用：数组拼接
   • 返回值：拼接后的数组
   • 原数组不改变

   var arr1 = [1,2,3];
   var arr2 = [4,5];
   var arr3 = arr1.concat(arr2);
   console.log(arr1); //[1, 2, 3]
   console.log(arr3); //[1, 2, 3, 4, 5]
   

8. sort

   • sort(function(a,b){return a-b;})
   • 作用：数组排序，原理是冒泡排序
   • 返回值：排序后的数组
   • 原数组改变

   var scores = [1, 10, 21, 2];
   scores.sort(); // [1, 10, 2, 21]
   

9. reverse

   • ary.reverse()
   • 作用：数组反转
   • 返回值：反转后的数组
   • 原数组改变

   var arr = [2,3,4];
   console.log(arr.reverse()); //[4, 3, 2]
   console.log(arr);  //[4, 3, 2]
   

10. join

    • 作用：用于将数组的每一项放入一个字符串中
    • 返回值：拼接后的字符串
    • 原数组不改变

    var arr = [2,3,4];
    console.log(arr.join());  //2,3,4
    console.log(arr);  //[2, 3, 4]
    

11. indexOf 和 lastIndexOf

    • 作用：查找元素的index值
    • 返回值：查找元素的index，若不存在，则返回-1
    • 原数组不改变
    • indexOf是从前向后查找，lastIndexOf是从后向前查找

    var a = [2, 9, 9];
    a.indexOf(2); // 0
    a.indexOf(7); // -1
    
    if (a.indexOf(7) === -1) {
      // element doesn't exist in array
    }
    

12. every

    • 作用：对数组的每一项都运行给定的函数，每一项都返回 ture,则返回 true
    • 返回值：Boolean

    function isBigEnough(element, index, array) {
      return element < 10;
    }    
    [2, 5, 8, 3, 4].every(isBigEnough);   // true
    

13. some

    • 作用：对数组的每一项都运行给定的函数，任意一项都返回 ture,则返回 true
    • 返回值：Boolean
    • every是需要每一项都符合，some是任意一项符合

    function compare(element, index, array) {
      return element > 10;
    }    
    [2, 5, 8, 1, 4].some(compare);  // false
    [12, 5, 8, 1, 4].some(compare); // true
    

14. filer

    • 作用：对数组的每一项都运行给定的函数，返回 结果为 ture 的项组成的数组
    • 返回值：返回结果为true的项组成的数组
    • 原数组不改变

    var words = ["spray", "limit", "elite", "exuberant", "destruction", "present", "happy"];
    
    var longWords = words.filter(function(word){
      return word.length > 6;
    });
    

15. map

    • 作用：对数组的每一项都运行给定的函数，返回每次函数调用的结果组成一个新数组
    • 返回值：每次函数调用的结果组成一个新数组
    • 原数组不改变

    var numbers = [1, 5, 10, 15];
    var doubles = numbers.map(function(x) {
       return x * 2;
    });
    // doubles is now [2, 10, 20, 30]
    // numbers is still [1, 5, 10, 15]
    

16. forEach

    • 作用：数组遍历

    const items = ['item1', 'item2', 'item3'];
    const copy = [];    
    items.forEach(function(item){
      copy.push(item)
    });
    

17. includes

    • 作用：判断数组中是否存在该元素， 可以代替indexOf， indexOf判断元素是否为 NaN，会判断错误。
    • 返回值：存在，返回true，否则返回false

    var a = [1, 2, 3];
    a.includes(2); // true
    a.includes(4); // false
    

18. find

    • 作用：传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，一旦搜索到，终止搜索
    • 返回搜索到的元素

    const arr = [1, "2", 3, 3, "2"]
    console.log(arr.find(n => typeof n === "number")) // 1
    

19. findIndex

    • 作用：传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，一旦搜索到，终止搜索
    • 返回搜索到的元素的下标

    const arr = [1, "2", 3, 3, "2"]
    console.log(arr.findIndex(n => typeof n === "number")) // 0
    

20. from

    • 将类似数组的对象（array-like object）和可遍历（iterable）的对象转为真正的数组

    const bar = ["a", "b", "c"];
    Array.from(bar);
    // ["a", "b", "c"]
    
    Array.from('foo');
    // ["f", "o", "o"]
    

21. reduce

    • 作用：接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值
    • 它的用处很多，这里列举一些常见实例：

// 数组求和
var ary = [1,2,3,1]
var sum = ary.reduce(function(total, num){
	return total+num
}, 0);

// 数组最大值
const a = [23,123,342,12];
const max = a.reduce(function(pre,cur,inde,arr){
	return pre>cur?pre:cur;
}); 

// 数组去重
let arr = [1, 2, 2, 4, null, null].reduce((accumulator, current) => {
    return accumulator.includes(current) ? accumulator : accumulator.concat(current);
}, []);

文章参考：
JavaScript常用数组操作方法，包含ES6方法