数组方法

Push():

        /*
          arr.push 
            在数组最后添加一个元素，
            使原数组发生改变，
            返回值是新数组的length
        */
        let arr = [1,2,3];
        let a = arr.push("1");
        console.log(a);//4
        console.log(arr);//[1, 2, 3, "1"]

Pop():

        /*
          arr.pop()
            用于删除数组中最后的一个元素
            返回被删除的元素，
            用在空数组上，会返回undefined
        */
        let arr = [1,2,3];
        console.log(arr.pop());//3
        console.log(arr);//[1,2]
        let arr2 = [];
        console.log(arr2.pop());//undefined

Unshift():

        /*
          arr.unshift
          在数组内第一个位置添加一个元素，
          返回值是添加元素后数组的长度
        */
        let arr = [1,2,3];
        console.log(arr.unshift(5));
        console.log(arr);

Shift():

        /*
          arr.shift()
          从数组中删除第一个元素，
          返回值是被删除的元素
        */
        let arr = [1,2,3,4];
        console.log(arr.shift());
        console.log(arr);

       /*
           arr.splice(start,[num,item1,item2...])
                - start 删除的起始位置
                        如果大于length，则不删除
                        如果是负数(负数的绝对值超过length，则起始位置被设定为length)，则从右到左查找相应地起始位置
                        length + start
                - num 可选参数，默认删除到数组的末尾，
                       如果给值，代表删除的个数。
                       如果小于0或者是NaN，则当成0处理，不删除任何元素
                - item1,item2...从删除的位置，添加第二个参数以后的内容

                返回值是所有删除的元素组成的数组
                如果没有删除元素就会返回一个空数组
        */
        let arr = [1,2,3,4];
        //arr.splice(1);
        //console.log(arr);//[1]
        //删除
        //arr.splice(1,2);
        //console.log(arr);//[1,4]
        //替换
        //arr.splice(1,2,"b","c");
        //console.log(arr);//[1, "b", "c", 4]
        //arr.splice(6);
        //console.log(arr);//[1,2,3,4]
        //arr.splice(-1);
        //console.log(arr);//[1, 2, 3]
        //arr.splice(-50);
        //console.log(arr);//[]
        
        //添加
        //arr.splice(1,0,'a','b');
        //console.log(arr);//[1, "a", "b", 2, 3, 4]
        //返回值
        //console.log(arr.splice(1,2));//[2, 3]
        //console.log(arr.splice(1,0,'a','b'));//[]

Sort():

       /*
          arr.sort()
             - 不提供参数，则根据默认规则进行排序(根据unicode来进行排序)
             - 如果提供参数(函数)，可以指定排序的规则
             - a,b
            如果a-b>0, b排到a前面
            如果a-b<0, a排到b前面
            如果a-b=0, a和b位置不变
        */
        let arr = ['a','m','c','j','z'];
        console.log(arr.sort());//['a','c','j','m','z']
        let price = [1,10,4,6,9];
        // price.sort(function(a,b){
        //      return a - b ;
        // });
        price.sort((a,b)=>a - b);
        console.log(price);//[1,4,6,9,10]

        //特殊的sort
        let arr1 = ['A','b','a','B'];
        arr1.sort((a,b)=>{
            a = a.toLowerCase();
            b = b.toLowerCase();
            if(a>b){
                return 1;
            }else if(a < b){
                return -1;
            }
            return 0;

        });
        console.log(arr1);//["A", "a", "b", "B"]

        let arr2 = ['A','b','a','B'];
        arr2.sort((a,b)=>Math.random() - 0.5);
        console.log(arr2);

Concat():

        /*
          concat()拼接不同的数组，并返回一个新的数组
          不改变原来的数组
        */
        let arr = [1];
        let arr2 = [2];
        console.log(arr.concat(arr2));//[1,2]

Join():

        /*
          join(separator)
            把数组拼接起来，以字符串的形式返回，
            如果没有参数，默认以逗号进行间隔
            separator
              数组进行拼接的间隔符号
            
            如果是一个空数组，则返回一个空字符串
        */
       let arr = ['a','b','c','d'];
       console.log(arr.join());//a,b,c,d
       console.log(arr.join(""));//abcd
       let arr1 = [];
       console.log(arr1.join());//空字符串

Reverse():

        /*
          reverse()
            将数组元素倒序显示，会改变原数组
        */
       let arr = [1,2,3];
       console.log(arr.reverse());//[3,2,1]
       console.log(arr);//[3,2,1]

indexOf():

       /*
         arr.indexOf(searchValue,[fromIndex])
         查找目标字符串是否包含searchValue，如果包含，返回第一次出现的索引，如果不包含，则返回-1
         searchValue 要查找的值
         fromIndex 查找的起始位置，如果不给值，则默认为0
                   如果大于或者等于length，则返回-1
                   如果是一个负数(如果这个负数的绝对值超过length，则fromIndex为0)，则进行倒序查找
                   length + fromIndex

       */  
       let  arr = [1,2,3,4,5];
       console.log(arr.indexOf(1));//0
       console.log(arr.indexOf(1,1));//-1
       console.log(arr.indexOf(1,10));//-1
       console.log(arr.indexOf(3,-3));//2
       console.log(arr.indexOf(3,-30));//2

lastIndexOf():

        /*
          arr.lastIndexOf(searchValue,fromIndex)
          返回数组中指定值最后一次出现的位置，
          如果不存在，则返回-1
          fromIndex
             搜索的起始位置，默认为length
             如果大于等于length，则为length
             如果是一个负数，则倒数找到对应的起始位置
             length - fromIndex
             如果负数的绝对值大于length，则返回-1
        */
        let arr = [1,2,1,4,1,6,6];
        console.log(arr.lastIndexOf(1,arr.length-2));//4
        console.log(arr.lastIndexOf(1));//4
        console.log(arr.lastIndexOf(1,10));//4
        console.log(arr.lastIndexOf(1,-10));//-1
        console.log(arr.lastIndexOf(1,1));//0
        console.log(arr.lastIndexOf(4,-2));//3

Slice():

        /*
          slice(begin,end)
            用于截取数组中的内容，返回一个新数组
            -begin
               如果不给值，默认为0
               截取的起始位置
               如果值超过了length，返回空数组
               如果是一个负数(负数的绝对值超过了length，就会从0开始截取)，则从倒数第begin开始截取
               length + begin
            -end
               如果不给值，默认到数组结尾
               控制截取的结束位置
               如果位置上小于begin，会得到一个空字符串
               如果是负数(负数的绝对值超过了length，返回一个空字符串)，那就从倒数end开始截取
               如果超过了length，默认只到数组的结尾
            begin是包含在内的，end是不包含在截取范围内
        */
        let arr = [1,2,3,4,5,6];
        console.log(arr.slice());//[1,2,3,4,5,6]
        console.log(arr);//[1,2,3,4,5,6]
        console.log(arr.slice() === arr);//false
        console.log(arr.slice(2));//[3,4,5,6]
        console.log(arr.slice(10));//[]
        console.log(arr.slice(-10));//[1,2,3,4,5,6]
        console.log(arr.slice(-1));//[6]
        console.log(arr.slice(2,4));//[3,4]
        console.log(arr.slice(2,1));//[]
        console.log(arr.slice(2,-1));//[3,4,5,6]
        console.log(arr.slice(2,-10));//[]
        console.log(arr.slice(2,10));//[3,4,5,6]
        /*
           深拷贝：
              数据拷贝过来后，和原数组之间完全没有任何关联了
           浅拷贝：
              数据拷贝过来后，第一层的基本类型没有关联，但是复杂类型依旧是有关联的
           赋址：
              数据包含基本类型和复杂类型都是和原来相关联的
              
        */

forEach():

        /*
          arr.forEach(callback,[thisArg])
            对数组中的每个元素执行一次提供的函数
            -callback()函数
              - ele 循环过程中的每个元素
              - index 当前元素对应的下标
              - arr 调用forEach的当前数组
            - thisArg 控制当前callback中的this指向
           该方法返回值是undefined
        */
        let arr = [1,3,4,6];
        arr.forEach((item,key,arr)=>{
            console.log(item,key,arr);
            console.log(this);
        },arr);

filter():

      /*
          arr.filter(callback,[thisArg])
            筛选符合条件的元素，并返回一个新的数组
            -callback()函数
              - ele 循环过程中的每个元素
              - index 当前元素对应的下标
              - arr 调用forEach的当前数组
            - thisArg 控制当前callback中的this指向
        */
      let arr = [1, 2, 3, 4, 5];
      let newRes = arr.filter((item,key,arr)=>{
        console.log(this);
        // return item >= 3;
      },arr);
      //只有function可以改变this
      arr.filter(function(item,key,arr){
        console.log(this);
        console.log(item,key,arr);
      },arr);

      console.log(newRes);

Map():

        /*
          map()
            循环过程中每个元素处理后返回新值组成新的数组
        */
        let arr = [1,2,3,4,5,6];
        arr.map(function(item,key,arr){
            console.log(this);
            console.log(item,key,arr);
        },arr);

        let res = arr.map((item)=>{
            return item * 2 ;
        })
        console.log(res);//[2,4,6,8,10,12]