数组Array的API2

数组的方法
arr.push()
arr.unshift()
arr.pop()
arr.shift()
arr.slice()
arr.splice()
arr.join()
arr.find()
arr.indexOf()
arr.findIndex()
arr.reverse()

8.arr.push()

理解：往数组最后添加一个或几个元素，返回产生新数组的长度。
使用：arr.push()
参数：往数组最后面添加的元素
返回值：添加之后的原数组的长度
原数组：改变

    let arr1 = ["a","b","c","d"];
    let res1 = arr1.push('ddd');

    console.log('原数组',arr1);             //["a","b","c","d","ddd]
    console.log('返回值',res1);             //5

9.arr.unshift()

理解：往数组最前面添加一个或多个元素，返回产生新数组的长度。
使用：arr.unshift()
参数：往数组最前面添加的元素
返回值：添加之后的原数组的长度
原数组：改变

9.arr.pop()

理解：将数组最后一个元素删除，返回删除的元素。
使用：arr.pop()
参数：没有参数
返回值：删除最后一个元素的原数组
原数组：改变

    let arr1 = ["a","b","c","d"];
    let res1 = arr1.pop();

    console.log('原数组',arr1);             //["a","b","c"]
    console.log('返回值',res1);             //d

10.arr.shift()

理解：往数组最前面添加一个或多个元素，返回产生新数组的长度。
使用：arr.shift()
参数：没有参数
返回值：删除最前一个元素的原数组
原数组：改变

11.arr.slice()

理解：截取数组中的元素，返回截取的元素组成的数组。
使用：arr.slice()
参数：多种情况
返回值：截取出来的元素组成的新数组
原数组：不改变原数组。

参数情况：

有一个参数：从指定的位置开始截取到最后一位元素，包括指定的位置的元素。
有一个参数，参数是负数：从指定的位置开始截取到最后一位元素，包括指定的位置的元素。开始的位置是arr的长度加负数。
负数绝对值大于arr的长度，则从0开始截取。
有两个参数：从指定的位置开始截取到指定的位置，包括起始的指定位置的元素，不包括结束的指定位置的元素。

    let arr1 = [0,1,2,3,4,5];
    let res1 = arr1.slice();      //没有参数
    let res2 = arr1.slice(2);  //一个参数
    let res3 = arr1.slice(1,2);      //两个参数，第一中情况，第一个参数比第二个参数大
    let res4 = arr1.slice(2,1);  //两个参数，第二中情况，第一个参数比第二个参数小
    let res5 = arr1.slice(2,-1);  //两个参数，第二中情况，参数是负数

    console.log('原字符串',arr1);   //[0, 1, 2, 3, 4，5]
    console.log(res1);             //[0, 1, 2, 3, 4，5]
    console.log(res2);             //[2, 3, 4]
    console.log(res3);             //[1]
    console.log(res4);             //[]
    console.log(res5);             //[2, 3，4]

12.arr.splice()

理解：删除或添加元素，返回删除的元素组成的数组。
使用：arr.splice()
参数：多种情况
返回值：截取的元素组成的新数组
原数组：改变，截取之后剩余的元素组成的数组

参数情况：

无参数：不删除元素。
有一个参数：从指定的位置开始删除到最后一位元素，包括指定的位置的元素。
有两个参数：从指定的位置开始删除，删除指定的个数，包括起始的指定位置的元素。
三个以上参数：从指定的位置开始删除，删除指定的个数，包括起始的指定位置的元素，并且添加第三位以后的元素。
三个以上参数，第二个参数是0：从指定的位置之前添加第三位以后的元素。

    let arr1 = [0,1,2,3,4,5];
    let res1 = arr1.splice();         //没有参数----升序

    let arr2 = [0,1,2,3,4,5];
    let res2 = arr2.splice(2);         //1个参数

    let arr3 = [0,1,2,3,4,5];
    let res3 = arr3.splice(2,1);

    let arr4 = [0,1,2,3,4,5];
    let res4 = arr4.splice(2,1,'aa','bb');

    console.log('原数组',arr1);             //[0, 1, 2, 3, 4, 5]
    console.log('返回值',res1);             //[]

    console.log('原数组',arr2);             //[0, 1]
    console.log('返回值',res2);             //[2, 3, 4, 5]

    console.log('原数组',arr3);             //[0, 1, 3, 4, 5]
    console.log('返回值',res3);             //[2]

    console.log('原数组',arr4);             //[0, 1, "aa", "bb", 3, 4, 5]
    console.log('返回值',res4);             //[2]

13.arr.concat()

理解：合并数值。
使用：arr.concat()
参数：需要合并的数组或元素
返回值：合并之后的新数组
原数组：不改变

    let arr1 = ["a","b","c","d"];
    let res1 = arr1.concat([1,2,3]);
    let res2 = arr1.concat('ddd');

    console.log('原数组',arr1);             //["a", "b", "c", "d"]
    console.log('返回值',res1);             //["a", "b", "c", "d", 1, 2, 3]
    console.log('返回值',res2);             //["a", "b", "c", "d","ddd"]

14.arr.join()

理解：将数值转出字符串，没有参数，默认用逗号隔开。
使用：arr.join()，arr.join(',')
参数：没有参数，或一个参数
返回值：返回字符。没有参数，默认用逗号隔开；有参数，用参数隔开
原数组：不改变

    let arr1 = ["a","b","c","d"];
    let res1 = arr1.join();         //没有参数
    let res2 = arr1.join('*');      //有参数

    console.log('原数组',arr1);             //["a", "b", "c", "d"]
    console.log('返回值',res1);             //a,b,c,d
    console.log('返回值',res2);             //a*b*c*d

15.arr.find()

理解：循环数组，每循环一次，执行一次数组，当数组中的元素满足回调函数的条件时，停止循环，并返回该元素。
使用：arr.find()
参数：
返回值：找到满足回调函数条件的元素，没有则undefined
原数组：不改变

    let arr1 = [0,1,2,3,4,5];

    let res1 = arr1.find((item,i,arr)=>{
        console.log(item,i,arr);    //0 0 (6) [0, 1, 2, 3, 4, 5]
        return item > 2
    })

    console.log('原数组',arr1);             // [0,1,2,3,4,5]
    console.log('返回值',res1);             // 3

16.arr.indexOf()

理解：查找数组中指定的元素的位置，没有则返回-1。
使用：arr.indexOf()
参数：指定的元素
返回值：指定的元素的位置，没有则返回-1。
原数组：不改变

    let arr1 = [0,1,2,3,4,5];

    let res1 = arr1.indexOf(4);
    let res2 = arr1.indexOf(9);


    console.log('原数组',arr1);             // [0,1,2,3,4,5]
    console.log('返回值',res1);             // 4
    console.log('返回值',res2);             // -1

17.arr.findIndex()

理解：循环数组，每循环一次，执行一次数组，当数组中的元素满足回调函数的条件时，停止循环，返回这个元素的位置，没有则返回-1。
使用：arr.findIndex()
参数：指定的元素
返回值：指定的元素的位置，没有则返回-1。
原数组：不改变

   let arr1 = [0,1,2,3,4,5];

    let res1 = arr1.find((item,i,arr)=>{
        console.log(item,i,arr);    //0 0 (6) [0, 1, 2, 3, 4, 5]
        return item >2
    })

    console.log('原数组',arr1);             // [0,1,2,3,4,5]
    console.log('返回值',res1);             // 3

18.arr.reverse()

理解：数组元素倒置
使用：arr.reverse()
参数：
返回值：倒置之后的数组
原数组：改变

    let arr1 = ["a","b","c","d"];
    let res1 = arr1.reverse();         //没有参数

    console.log('原数组',arr1);             //["d", "c", "b", "a"]
    console.log('返回值',res1);             //["d", "c", "b", "a"]