数组的方法

1、join：将数组中所有的元素都转化为字符串拼接在一起，返回最后生成的字符串。

注意：不改变原数组

    let arr=[1,2,3,4];

    console.log(arr.join(","));    //1,2,3,4    join()和join(',')的结果都是一样的

    console.log(arr.join(""));    //1234

    console.log(arr.join());    //1,2,3,4

    console.log(arr.join("  "));  //1  2  3  4   

    console.log(arr);  //[1,2,3,4]

2、reverse：将数组中的元素颠倒顺序，返回逆序的字符串。

注意：原数组被改变

    let arr=[1,2,3,4];

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

    console.log(arr);    //[4,3,2,1]

3、sort：将数组中的元素排序后返回排序后的数组，undefined都是排在最后的

注意：原数组被改变

(1)给0-10数字排序，直接使用

let arr=[1,2,4,3,3];

console.log(arr.sort())  //[1,2,3,3,4]

console.log(arr)  //[1,2,3,3,4]

（2）给负数和大于一位数的排序

let arr=[22,1,4444,111,3]；

console.log(arr.sort(function(a,b){

            return a-b

  }))        //[1,3,22,111,4444]

console.log(arr);    //[1,3,22,111,4444]

(3)给字母排序,大写字母排前面，小写字母排后面

let arr=["a","c","A","C","b","B"];

console.log(arr.sort());      //["A","B","C","a","b","c"]

console.log(arr);    //["A","B","C","a","b","c"]

4、concat：创建并返回一个新数组。新数组由原数组和concat()里面的参数组成,只能扁平化一维

注意：不改变原数组

let arr=[1,2,3];

let arr1=[5,6]

console.log(arr.concat(arr1))  //[1,2,3,5,6]

注意：concat只能扁平化一维,不能扁平化多维数组

let arr2=[5,6,[7,[8,9]]];

console.log(arr.concat(arr2))  //[1,2,3,5,6,[7,[8,9]]]

console.log(arr)    //[1,2,3,4]   

5、slice：返回指定数组的片段或者子数组，两个参数分别指是片段的开始和结束位置（按照索引来的，不包含结束的位置）

注意：不改变原数组

let arr=[1,2,3,4,5];

console.log(arr.slice(1,3))  //[2,3]

注意：只有一个数字代表就指取得这个索引和后面所有项

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

注意：开始参数小于结束参数，返回空数组（同为负数一样，单负数不行）

console.log(arr.slice(3,1))  //[]

console.log(arr.slice(-1,-3)) // []

注意：参数中含有负数，负数代表倒数，倒数第一位就是-1

console.log(arr,slice(2,-1))  //[3,4]

console.log(arr.slice(-3,-1))  //[3,4]

console.log(arr)    //[1,2,3,4,5]

6、splice:在数组中输入和删除元素的通用方法。返回的原数组是由删除元素组成的新数组，没有删就返回空数组[],可以删除、替换、插入

第一个参数是从哪个索引开始，第二个参数代表删除几项，后面的参数都代表从该索引添加元素

注意：原数组被改变

    删除：

    let  arr=[1,2,3,4,5];

    console.log(arr.splice(1,2));      //[1,4,5]

    console.log(arr);    //[2,3]  返回的是删除的元素

    注意：只有一个参数，表示删除从此索引往后的所有项（索引负数也可）

    console.log(arr.splice(1))    //[2,3,4,5]

    console.log(arr);    //[1]

    console.log(arr.splice(-2))    //[4,5]

    console.log(arr);    //[1,2,3]

    替换：

    let arr=[1,2,3,4,5];

    console.log(arr.splice(1,2,6,7));    //[1,6,7,4,5]  从索引为1开始删除2个数，并添加后面连个数

    console.log(arr)    //[2,3]

    删除：

    let arr=[1,2,3,4,5];

  console.log(arr.splice(1,0,6,7))    //[1,6,7,2,3,4,5]    从索引为1，删除0个，并添加后面的两个数

7、push：push在数组的末尾添加一个或者多个元素，返回新数组的长度。所以不能链式操作

注意：原数组被改变

let arr=[1,2,3,4];

console.log(arr.push(5));    //5

console.log(arr)    //[1,2,3,4,5]

8、pop：pop删除数组的最后一个元素，返回它删除的值元素

注意：原数组被改变

    let arr=[5,4,3,2,1];

    console.log(arr.pop());    //1

    console.log(arr)    //[5,4,3,2]

9、unshift：unshift是在数组头部添加一个或多个元素。如果一次性传入多个参数，多个参数按照按照原先的位置直接加到数组中。返回新数组的新数组的长度。

注意：原数组被改变

let arr=[1,2,3,4];

console.log(arr.unshift(5));    //5

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

10、shift：删除数组的第一个元素，并返回删除的元素

注意：原数组被改变

let    arr=[1,2,3,4];

console.log(arr.shift());    //1

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

11、toString:将数组数组中的每个元素转化为字符串。 输出用逗号分隔的字符串列表（可能数组的内部元素(数组)还会再次调用toString()，高维数组扁平化正是利用这点）

注意：原数组被改变

let arr=[1,2,3,4];

console.log(arr.toString())    //1,2,3,4

console.log(arr)    //[1,2,3,4]

12、forEach：该方法从头到尾遍历数组，为某个元素调用指定的函数。传递函数包括三个参数（数组元素、元素索引、数组本身），如果只关心数组元素的值，可以只传一个参数。

    var data = [1,2,3];

    var sum = 0;

    data.forEach(function(value,index,data){

          sum+=value;

    });

    console.log(sum); //6

13、map：将调用的数组的每个元素传递给指定的函数，并返回一个新数组，它包含该该函数的返回值

注意：传递给map的函数应该有返回值，返回的是新数组，不修改调用的数组。

(1)    let arr=[1,2,3,4,5];
    let arr1=arr.map(function(item,index){
            return item*2
    })
console.log(arr1)    //[2,4,6,8,10]

（2） let arr=[1,2,3,4,5];
        let arr1=[];
        arr.map(function(item,index){
            item=item*3;
            arr1.push(item)
        })
        console.log(arr1)    //[3,6,9,12,15]

14：filter() //过滤：返回的数组元素是调用的数组的一个子集，就传递的函数是用来做逻辑判定的，返回true，传给给判定函数的元素就是这个子集的成员。

let arr=[1,2,3,4];

let arr1=arr.filter(function(item,index){

    return item>2

})

console.log(arr1)    //[3,4]

15、every 当且仅针对数组中的所有元素调用判定的函数都返回true,它才返回true

some 至少有一个判定为true就返回true.

let arr=[1,2,3,4];

console.log(arr.every(function(item,index){

    return item>0

}))    //true

console.log(arr.some(function(item,index){

    return item>3

}))        //true

16、reduce：使用指定的函数将数组元素进行组合，生成一个单值。参数一是执行简化操作的函数，参数二是传给简化函数的初始值。

注意：一旦确认之后，就停止遍历数组了。

var data5 = [1,2,3,4,5];

var sum = data5.reduce(function(x,y){

  return x+y;

},10);    

console.log(sum);     //sum=10+1+2+3+4+5=25

var product = data5.reduce(function(x,y){

  return x*y;

},100);        

console.log(product); //product=100*1*2*3*4*5=12000

17、indexOf和lastIndexOf：搜索整个数组中具有给定值的位子，返回找到第一个元素的索引，如果没有找到就返回-1；indexOf()是从头找到尾，lastIndexOf()正好相反

注意：不接受函数作为参数，第一个参数是需要搜索的值，第二个参数是可选的，表示从哪里搜索，可以是负数，如果是负数，表示从后先前数第几个数，搜索还是一样从前向后搜

let    arr=[1,2,3,4,5];

console.log(arr.indexOf(2))        //1    返回的是索引

console.log(arr.indexOf(6))        //-1    未找到，返回-1

console.log(arr.indexOf(2,0))    //1    表示从第二个参数索引为0开始向后找，返回的是索引

console.log(arr.indexOf(2,2))    //-1    表示从第二个参数索引为2开始向后找，未找到返回-1

console.log(arr.indexOf(4,-2))    //3    -2表示从倒数第二个数向后找，返回的是索引

console.log(arr.indexOf(4,-1))    //-1    -1表示从倒数第一个数向后找，未找到返回-1

console.log(arr.lastIndexOf(1))    //0    lastIndexOf也是从后向前搜索，但返回的索引是不变

console.log(arr.lastIndexOf(5,-1))    //4   -1表示从倒数第1个数开始向前数，返回也是索引

console.log(arr.lastIndexOf(5,-2))    //-1  -2表示从倒数第2个数开始向前数，未找到返回-1

18、isArray：判断对象是否为数组

let arr=[1,2,3,4];

let obj={a:1,b:2};

console.log(Array.isArray(arr));    //true

console.log(Array.isArray(obj));    //false