JS数组方法详解（上篇）

1.join()

（1）Array.join()方法将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串；
（2）可指定一个字符串来分隔数组中的各个元素，如果不指定，默认用逗号分隔。

    let arr = [1, 2, 3];
    arr.join();//=> "1,2,3"
    arr.join(" ");//=> "1 2 3"
    arr.join("");//=>"123"
    let arr1 = new Array(5);//长度为5的空数组
    arr1.join('*');//=>'****':4个*组成的字符串

2.toString()

（1）Array.toString()方法将每个元素转为字符串，并用逗号分隔 ，与不使用参数的Array.join()方法一样；
（2）输出不包括方括号或其他任何形式的包裹数组值的分隔符。

    [1, 2, 3].toString();//=>"1,2,3"
    ["a","b","c"].toString();//=>"a,b,c"
    [1,[2,[3,'a'],'b'],'c'].toString();//=>'1,2,3,a,b,c'

3.toLocaleString()

（1）toLocaleString()是 toString()的本地化版本。

4.reverse()

（1）Array.reverse()方法将数组的元素颠倒顺序，返回逆序的数组。

    [1, 2, 3].reverse();//=>[3,2,1]
    [1, 2, 3].reverse().join("");//=>"321"

5.sort()

（1）Array.sort()方法将数组中的元素排序并返回排序后的数组；
（2）不带参数时，元素按照转换为的字符串的各个字符的Unicode位点进行排序；
（3）如果数组包含undefined元素，它们会被排到数组的尾部；
（4）如果想按照其他标准进行排序，就需要提供比较函数。比较函数有2个参数，这2个参数模拟排列顺序，如果第一个参数应该在前，函数应返回一个小于0的数值。反正返回大于0的数值。若顺序无关紧要，返回0。

	//没有参数的情况
    let arr1 = ['b','a','c'];
    arr1.sort();//=>['a','b','c']
    
    let arr2 = ['c','a','B'];
    arr2.sort();//=>['B','a','c']
    
    let arr = [111, 222, 33, 4];
    arr.sort();//=>[111, 222, 33, 4]
    
    //有参数
    //从小到大排序
    arr.sort(function (a, b) {
        return a - b
    });//=>[4,33,111,222]
    
    //从大到小排序
    arr.sort(function (a, b) {
        return b - a
    });//=>[222,111,33,4]

	//对不区分大小写的字母排序
	let arr3 = ['ant', 'Bug', 'cat', 'Dog'];
    arr3.sort();//=>['Bug','Dog','ant','cat']
    arr3.sort(function (x, y) {
        let a = x.toLowerCase();//转化成小写
        let b = y.toLowerCase();
        if (a < b) return -1;
        if (a > b) return 1;
        return 0;
    });//=>['ant', 'Bug', 'cat', 'Dog']

6.concat()

（1）Array.concat()的方法创建并返回一个新数组，它的元素包括调用concat()的原始数组的元素和concat()的每个参数；
（2）如果concat()的参数中任意一个是数组，则连接的是数组的元素，而非数组本身；
（3）concat()不会递归扁平化数组的数组；
（4）concat()不会修改调用的数组。

    let arr = [1, 2, 3];
    arr.concat(4, 5);//=>[1,2,3,4,5]
    arr.concat([4, 5]);//=>[1,2,3,4,5]
    arr.concat([4, 5], [6, 7]);//=>[1,2,3,4,5,6,7]
    arr.concat([4], [5, [6, 7]]);//=>[1,2,3,4,5,[6,7]]

7.slice()

（1）Array.slice()方法返回指定数组的一个片段或子数组；
（2）它的两个参数分别指定了片段的开始（包括）和结束（不包括）的位置；
（3）如果只有一个参数，返回的数组将包含从开始位置到数组结尾的所有元素；
（4）如果参数中出现负数，它表示相对于数组中最后一个元素的位置（-1指最后一个元素）；
（5）slice()不会修改调用的数组。

    let arr = [1, 2, 3, 4, 5];
    arr.slice(1, 3);//=>[2,3]
    arr.slice(2);//=>[3,4,5]
    arr.slice(2, -1);//=>[3,4]
    arr.slice(-4, -2);//=>[2,3]
    arr.slice(-1);//=>[5]
    arr.slice(-2);//=>[4,5]

8.splice()

（1）Array.splice()方法是在数组中插入或删除元素的通用方法；
（2）不同于concat()和slice()，splice()会修改调用的数组；
（3）第一个参数指定了插入和（或）删除的起始位置；
（4）第二个参数指定了需要删除的元素的个数（0代表不删除），注意！如果省略第二个参数的话，从起始点到结尾的所有元素都会被删除；
（5）splice()返回一个由删除元素组成的数组，没有删除元素就返回空数组；
（6）splice()前两个参数指定了需要删除的数组元素，其后的任意个数的参数指定了需要插入到数组中的元素，从（占据）第一个参数指定的位置开始插入。

    let arr = [1, 2, 3, 4, 5, 6,7];
    arr.splice(5);//返回[6,7]；arr是[1,2,3,4,5]
    arr.splice(2,2);//返回[3,4]；arr是[1,2,5]
    arr.splice(1,0);//返回[]；arr是[1,2,5]
    arr.splice(2,1,3,4,5,6);//返回[5]；arr是[1,2,3,4,5,6]
    arr.splice(2,3,[3,4],5);//返回[3,4,5]；arr是[1,2,[3,4],5,6]

9.push()

（1）Array.push()方法在数组的尾部添加一个或多个元素，并返回数组的长度；
（2）会修改并替换原数组。

    let arr = [];
    arr.push(1,2,3); //返回3；arr是[1,2,3]

10.pop()

（1）Array.pop()方法删除数组的最后一个元素，减小数组的长度并返回删除的值；
（2）会修改并替换原数组。

    let arr = [1,2,3,4];
    arr.pop(); //返回4
	
	//组合使用push()和pop()能够用JavaScript数组实现先进后出的栈
	let stack = [];
    stack.push(2,3,5); //=>[2,3,5]；返回3
    stack.pop(); //=>[2,3]；返回5
    stack.push([4,5]); //=>[2,3,[4,5]]；返回3
    stack.pop(); //=>[2,3];返回[4,5]
    stack.pop(); //=>[2];返回3

11.unshift()

（1）Array.unshift()方法在数组的头部添加一个或多个元素，并将已经存在的元素移动到更高索引的位置来获得足够的空间，返回数组新的长度；
（2）插入多个元素时，插入元素的顺序和它们在参数列表的顺序一致，说明是参数是一次性插入。

    let arr = [1];
    arr.unshift(2, 3, [4,5]); //=>[2,3,[4,5],1];返回4

12.shift()

（1）Array.shift()方法删除数组的第一个元素并将其返回，然后把所有随后的元素下移一个位置来填补数组头部的空缺。

    let arr = [3,1,2];
    arr.shift();//=>[1,2]；返回3