数组的常用方法：

=> 就是 JS 自带一些操作数组的方法
=> 数组常用方法的使用格式，必须是 数组.xxx()
=> 数组和维数组的区别
=> length 和 索引都一样，循环遍历都一样
=> 长的都一样
=> 唯独数组的常用方法，伪数组用不了

数组基础方法-- (只要它还是个浏览器它就能用)

1. push()

            => 语法: 数组.push(数据1，数据2，数据3……)
            => 作用：把所有的参数按照顺序追加到数组的末尾位置
            => 返回值： 追加以后的数组的长度
            => 直接操作原始数组

        var arr = ['hello','world','你好','世界']
        var res = arr . push('新来的','新来的2',[10,20])
        //把所有的参数按照顺序追加到数组的末尾位置
        console.log(res);
        console.log(arr);

2. pop()

            => 语法：数组.pop()
            => 作用：删除数组的最后一个数据
            => 返回值：被删除的数据
            => 直接操作原始数组

                => 语法：数组.pop()
                => 作用：删除数组的最后一个数据
                => 返回值：被删除的数据
                => 直接操作原始数组

3. unshift()

            => 语法：数组.unshift(数据1，数据2，数据3，……)
            => 作用：从数组的最前面插入一些数据
            => 返回值：插入后的数组长度
            => 直接操作原始数组
            => 和push方法的区别
                + 消耗性能的区别 unshift的性能消耗比较大 因为它对每一个数据都有操作

        var arr = ['hello','world','你好','世界']
        var res = arr.unshift('新来的','新来的2')
        //从数组的最前面插入一些数据
        console.log(res);
        console.log(arr);

4. shift()

            => 语法：数组.shift()
            => 作用：删除数组的最前面一个数据
            => 返回值：被删除的数据
            => 直接操作原始数组

        var arr = ['hello','world','你好','世界']
        var res = arr.shift();
        //删除数组的最前面一个数据
        console.log(res);
        console.log(arr);

ES3.0 -- IE6 7 8 都兼容可用

5. reverse()

            => 语法：数组.reverse()
            => 作用：反转数组
            => 返回值：反转后的数组
            => 直接操作原始数组

        var arr = ['hello','world','你好','世界']
        var res = arr.reverse()
        //反转数组
        console.log(res);
        console.log(arr);

6. sort()

            => 语法：
                1. arr.sort()
                    -> 按照每一个数据中每一个数据的 ASCII 码进行排序
                2. arr.sort(function (a,b){ return a-b})
                    -> 按照大小排序 升序排列
                3. arr.sort(function (a,b) { return b-a})
                    -> 按照大小排序 降序排列
            => 作用：数组排序
            => 返回值：排序后的数组
            => 直接操作原始数组

         var arr = [1,11,33,26,51,19,32,27,15,100] 
        var res = arr.sort()
        console.log(res);
        console.log(arr);

        var res = arr.sort(function (a,b) {return a-b})
        //升序排列
        console.log(res);
        console.log(arr);

        var res = arr.sort(function (a,b) {return b-a})
        //降序排列
        console.log(res);
        console.log(arr);

7. splice()

            => 语法：
                1. 数组.splice(开始索引，多少个)
                    -> 从开始索引截取多少个
                    -> 第二个参数不写，直接到末尾
                2. 数组.splice(开始索引，多少个,替换数据1，替换数据2，替换数据3，……)
                    -> 把替换数据按照顺序插入到你截取的位置
                    -> 注意：**从哪个索引开始删除，替换数据的第一个就插入哪个位置**
            => 作用：有两个
                1. 截取数组
                2. 替换新内容
            => 返回值：一定是数组
                -> 如果你截取多个数据，数组里面有多个
                -> 如果你截取一个数据，数组里面有一个
                -> 如果你一个都不截取，那么是一个空数组
            => 直接操作原始数组
            
            

        var arr = ['hello','world','你好','世界'] 
        var res = arr.splice(1,2)
        console.log('res:',res);
        console.log('arr:',arr);

        var res = arr.splice(1,2,'新来的','新来的2')
        console.log('res:',res);
        console.log('arr:',arr);
        //['hello','新来的','world'] 

        var res = arr.splice(1,0,'新来的','新来的2') //从哪删从哪插入
        console.log('res:',res);
        console.log('arr:',arr);
        //['hello','新来的','新来的2','world','你好','世界']

8. concat()

            => 语法：数组.concat(数组1，数据2，……)
            => 作用：
                -> 如果参数是数组，那么把数组拆开，里面每一项追加到原数组后面
                -> 如果参数是数据，那么直接追加
            => 返回值：追加好的数组
            => 不改变原数组
            
            

    var arr = ['hello','world','你好','世界'] 
        var res = arr.concat([10,20],[30,40],100)
        console.log(res);
        console.log(arr);

9. slice()

            => 语法：
                1. 数组.slice(开始索引，结束索引) - 包前不包后
                    -> 第一个参数可以不写，表示从头
                    -> 第二个参数可以不写，表示到尾
                2. 数组.slice(开始索引，结束索引) - 包前不包后
                    -> 参数可以写一个负整数
                    -> 当你书写了一个负整数以后，表示 length + 负整数
            => 作用：获取数组里面的某些数据
            => 返回值：一个数组
                -> 如果你获取多个数据，数组里面有多个
                -> 如果你获取一个数据，那么数组里面有一个
                -> 如果你一个都不获取，那么数组是一个空数组
            => 不改变原数组
        
        

        var arr = ['hello','world','你好','世界'] 
        var res = arr.slice(1,2)
        console.log('res:',res);
        console.log('arr:',arr);

        //因为length是4  -2的位置实际上相当于 4 + -2 ，2
        var res2 = arr.slice(1, -2)
        console.log('res2:',res2);
        console.log('arr:',arr);

10. join()

            => 语法：数组.join('连接符号')
                -> 不传递，是按照 逗号(,)连接
                -> 你传递什么，按照什么连接
            => 作用：把数组里面的每一个数据使用连接符号连接在一起
            => 返回值：是一个连接好的内容，是一个 String 类型
            
            

        var arr = ['hello','world','你好','世界'] 
        var res = arr.slice(1,2)
        console.log('res:',res);
        console.log('arr:',arr);

        //因为length是4  -2的位置实际上相当于 4 + -2 ，2
        var res2 = arr.slice(1, -2)
        console.log('res2:',res2);
        console.log('arr:',arr);

ES5.0, IE6 7 8 不可用了

11. indexOf()

            => 语法：
                1. 数组.indexOf(数据)
                2. 数组.indexOf(数据，开始索引)
                    -> 从哪个索引开始向后查找
            => 作用：正向查看数据里面指定这个数据的索引
            => 返回值：
                -> 如果有这个数据，是第一个满足条件的数据的索引
                -> 如果没有这个数据，那么是 -1

        var arr = ['hello','world','你好','世界','hello']
        var res =  arr.indexOf('hello')
        console.log(res);

        var res =  arr.indexOf('hello',1)
        //正向查看数据里面指定这个数据的索引
        console.log(res);

12. lastIndexOf()

            => 语法：
                1. 数组.lastIndexOf(数组)
                2. 数组.lastIndexOf(数组，开始索引)
                    -> 从哪一个索引开始向前查找
            => 作用：反向查看数组里面指定这个数据的索引
            => 返回值：
                -> 如果有，就是找到的第一个数据的索引
                -> 如果没有就是 -1
                -> 注意：虽然是从后向前查找，但是索引还是正常索引

        var arr = ['hello','world','你好','世界','hello']
        var res =  arr.lastIndexOf('hello')
        console.log(res);

        var res2 =  arr.lastIndexOf('hello',3)
        //反向查看数组里面指定这个数据的索引
        console.log(res2);

13. forEach()

            => 语法：数组.forEach(function (item,index,arr){})
                -> item : 数组的每一项
                -> index ：数组每一项索引
                -> arr : 原始数组
            => 作用： 取代 for 循环的作用，遍历数组 
            => 没有返回值 
            => 比 for 循环 浪费很多

        var arr = ['hello','world','你好','世界']
        var res = arr.forEach(function(item,index,arr){
            //这个函数，会根据数组里面有多少个数据执行多少回
            console.log('我执行了');

            // 这个函数每一次执行的时候，item 分别是数组里面的每一项
            // 这个函数每一次执行的时候，index 分别是数组里面的每一项的索引
            // 这个函数每一次执行的时候，arr 每一次都是原始数组
            console.log(item,'--------',index , '--------' ,arr);
        })

14. map()

            => 语法：数组.map(function (item,index,arr){})
                -> item : 数组的每一项
                -> index ：数组每一项索引
                -> arr : 原始数组
            => 作用：映射数组
            => 返回值：是一个新数组
                -> 里面是对原始数组每一个数据的操作
                -> 返回值数组，一定和原始数组长度一样
            => 不改变原始数组

        var arr = [10, 100, 1000]
        var res = arr.map(function (item, index, arr) {
            console.log(item, '--------', index, '--------', arr);
            return item*1.3
        })

        console.log(res);

map 底层封装 -- 解释

/* map 底层封装 1. 准备一个新的数组 2. 遍历原始数组，分别执行函数 3. 把每一次函数执行时候的返回值放在新数组里面 4. 把新数组当做 map 的返回值给出来 / // 我自己写的一个函数 // 我要想用，必须是 myMap(a,b,c) // 我为了可以像数组常用方法一样 // 我需要把这个方法放在Array.prototype上 function myMap(fn){ / console.log('我被调用了'); // 这个函数里面 this 表示调用方法的那个玩意 console.log(this); */ // fn 就是你调用 myMap 的时候传递的函数

        var newArr = []

    // this 就是调用 myMap 的那个数组
        for(var i = 0; i< this.length; i++){
            // console.log(this[i]);
            newArr.push(fn(this[i],i,this)) //调用的是arr.myMap函数
        }
        return newArr;  
   }
   Array.prototype.myMap = myMap;
   var res = arr.myMap(function (item,index,arr) {
    //console.log(123);
    console.log(item,index,arr);
    return item * 1.3
})
console.log(res);

15. filter()

            => 语法：数组.filter(function (item,index,arr){})
                -> item : 数组的每一项
                -> index : 数组每一项的索引
                -> arr : 原始数组
            => 作用：过滤原始数组中的数据，把满足条件的放在新数组里面
            => 返回值：新数组，里面是所有原始数组中满足条件项
            => 不改变原始数组

    var arr = [10,20,30,40,50]
    var res = arr.filter(function (item,index,arr) {
        return item > 20
    })
    console.log(res);

16. every()

            => 语法：数组.every(function(item,index,arr){})
                -> item : 数组的每一项
                -> index : 数组每一项的索引
                -> arr : 原始数组
            => 作用：判断原始数组里面是不是每一个满足条件
            => 返回值：
                -> 如果原始数组中每一个都满足条件，那么返回 true
                -> 只要原始数组中有任意一个不满足条件，那么久返回 false

    var arr = [10,20,30,40,50]
    var res = arr.every(function (item,index,arr) {
            console.log(item,index,arr)

            return item < 40
        })
        console.log(res);

17. some()

            => 语法：数组.some(function (item,index,arr){})
                -> item : 数组的每一项
                -> index : 数组每一项的索引
                -> arr : 原始数组
            => 作用：判断数组中是不是有某一个满足条件
            => 返回值：一个布尔值
                -> 如果数组中有任意一个数据满足条件，那么返回true
                -> 如果数组中所有数据都不满足条件，那么返回 false

    var arr = [10,20,30,40,50]
    var res = arr.some(function (item,index,arr) {
            console.log(item,index,arr)

            return item > 10
        })
        console.log(res);

ES2015(ES6) 以后，标准浏览器，IE 10 以上 兼容

18. copyWithin()

            => 语法：数组.copyWithin(目标位置，开始索引，结束索引)
                -> 目标位置：当你替换内容的时候，从哪一个索引位置开始替换
                -> 开始索引：数组哪一个索引位置开始当前替换内容,默认值是 0 
                -> 结束索引：数组哪一个索引位置结束当前替换内容，默认值是 末尾
                -> 包前不包后
            => 作用：使用数组里面的内容替换数组里面的内容
            => 返回值： 是一个新数组
                ->替换后的数组

        var arr = [100,200,300,400,500]
        // 第一个参数 0，表示不管将来我用什么东西替换，都从 0 位置开始替换 
        // 例子： 比如我要用 'a','b','c' 来替换，从索引 [0] 开始替换
        var res = arr.copyWithin(0)

        // 第二个参数 3，表示原始数组索引 [3] 位置开始向后查找
        // 因为没有写第三个参数，默认到末尾
        // 找到的就是 400 和 500
        // 把 400 和 500 两个数据从 [0] 开始替换
        var res = arr.copyWithin(0,3)
        console.log(res);

        // 第三个参数 4， 表示原始数组索引 [4] 位置结束查找
        // 找到的就是 [3] 开始 [4] 结束，包前不包后，找到的就是 400
        // 把400 从 [0] 开始替换
        var res = arr.copyWithin(0,3,4)
        var res = arr.copyWithin(0,3,4)
        console.log(res);

19. fill()

            => 语法：数组.fill(要填充的数据，开始索引，结束索引)
                -> 要填充的数据：你想用什么数据填充数组里面每一位
                -> 开始索引：从哪一个索引开始填充，默认值是 0
                -> 结束索引：填充到哪一个索引位置，默认值是 末尾
                -> 前提 数组要有 length
                -> 包前不包后
            => 作用：使用指定数据区填充数组
            => 返回值：填充好的数组

    var arr = new Array(30)
        // 使用 '填充内容' 去把数组填满
       /*  var res3 = arr.fill('填充内容')
        console.log(res3); */

        // 使用 '填充内容' 从 [5] 开始填充数组，填充到末尾
        /* var res1 = arr.fill('填充内容',5)
        console.log(res1); */

        // 使用 '填充内容' 从 [5] 开始填充到 数组 [25]
        var res2 = arr.fill('填充内容',5,25)
        console.log(res2);

20. includes()

            => 语法：数组.includes(数据)
            => 作用：查看数组中是不是有某一个数据
            => 返回值：一个布尔值
                -> 有这个数据， 就是true
                -> 没有这个数据，就是false

         var arr = [10,20,30,40,50]
        var res = arr.includes(50)
        console.log(res);

21. flat()

            => 语法：数组.flat(数字)
                -> 数字：表示扁平化多少层，默认是1
                -> 数字这个参数还可以填写 Infinity - 无限
            => 作用：拍平数组
            => 返回值：拍平以后的数组

        var arr = [
            10,20,30,
            [40,50],
            [60,70,[80,[90]]]
        ]
        var res = arr.flat(3)
        //拍平数组 （3） 是指多少层
        console.log(res);

        console.log(arr);

22. flatMap()

            => 语法：数组.flatMap(function (item,index,arr){})
            => 作用: 拍平数组，但是只能拍一层
            => 返回值：是有新的数组
                -> 一遍拍平一遍操作

        var arr = [[10,21,30],[40,51,60]]
        var res = arr.flatMap(function (item){ //拍平二维数组并映射
            return item.filter(function (item){return item % 2 === 0 })
        })

        console.log(res);

23. find()

            => 语法：数组.find(function (item){})
            => 作用：根据条件找到数组里面满足条件的数据
            => 返回值： 找到的那个 ** 数据 **

        var arr = [10,20,30,40,50]
        var res = arr.find(function (item){
            return item > 20
        })
        console.log(res);

24. findIndex()

            => 语法：数组.findIndex(function (item){})
            => 作用：根据条件找到数据里面满足条件的数据
            => 返回值：找到的那个 ** 数据索引 **

        var arr = [10,20,30,40,50]
        var res = arr.findIndex(function (item){
            return item > 20
        })
        console.log(res);