数组的方法

总结一下数组的方法，不足之处还有很多，请大家多多指导

文章有参照  热爱前端的17号诶 https://www.cnblogs.com/sqh17/p/8529401.html https://www.cnblogs.com/sqh17/p/8529401.html的部分

1、arr.length  修改原数组的长度 修改了原数组

// 可以通过length直接修改数组
let arr = [1,1,2,3,6,8,45];
// 获取数组的长度 
// console.log(arr.length) // 7

// arr.length = 10; // 增加数组的长度
// console.log(arr); // [1, 1, 2, 3, 6, 8, 45, empty × 3]

// arr.length = 2; // 缩短数组的长度
// console.log(arr); //  [1,1]
 arr.length = 0; // 清空数组
 console.log(arr) // []

 2、arr.pop () 数组末尾删除一个值 并返回删除的值 修改了原数组

// 删除数组末尾的一个元素，返回删除的这个元素，修改原数组
let arr = [1,1,2,3,6,8,45];
console.log(arr.pop()) // 45
console.log(arr) // [1, 1, 2, 3, 6, 8]

3、arr.push() 数组末尾添加值 并返回数组的长度 修改了原数组

// 在数组的末尾添加零个或者若干个值  修改了原数组 并返回数组的长度
let arr = [1,1,2,3,6,8,45];
console.log(arr.push(100,200)) // 8
console.log(arr) // [1, 1, 2, 3, 6, 8, 45, 100, 200]

4、arr.shift() 数组起始位置删除一个值 并返回删除的值 修改了原数组

// 在数组的起始位置删除一个值，并返回删除的值 修改了原数组
let arr = [1,1,2,3,6,8,45];
console.log(arr.shift()) // 1
console.log(arr) // [1, 2, 3, 6, 8, 45]

5、arr.unshift() 数组起始位置添加值 并返回数组的长度 修改了原数组

// 在数组的起始位置添加零个或者若干个值，并返回数组的长度，修改了原数组
let arr = [1,1,2,3,6,8,45];
console.log(arr.unshift(5,6)) // 9
console.log(arr) // [5, 6, 1, 1, 2, 3, 6, 8, 45]

6、arr.splice() 数组元素的替换 修改了原数组

/*
    splice(start, length, data1, data2...); 修改替换
        start 从第几位开始替换 可为负数
        length 替换掉几位
        data1, data2... 要替换进去的数据

    以数组形式返回被删除数据 修改原数组
*/

let arr = [1,1,2,3,6,8,45];

// console.log(arr.splice(1,2,'a','b','c')) // [1, 2]
// console.log(arr) // [1, 'a','b','c', 3, 6, 8, 45]

// 如果不传要替换的数据 就是指定位删除
// console.log(arr.splice(2,1)); // [2]
// console.log(arr) // [1, 1, 3, 6, 8, 45]

// 如果删除的长度为0 就是指定位添加
// console.log(arr.splice(2,0,'A','B','C')); // []
// console.log(arr) // [1, 1, "A", "B", "C", 2, 3, 6, 8, 45]

// 如果开始位数是负数 就从末尾倒数
console.log(arr.splice(2,0,'A','B','C')); // []
console.log(arr) // [1, 1, "C", 2, 3, 6, "A", "B", 8, 45]

7、arr.join() 将数组链接成字符串 返回一个字符串 不修改原数组

// arr.join('分隔符')将数组链接成字符串，用分隔符分开，如果没有传分隔符默认用','分开，返回一个字符串
let arr = [1,1,2,3,6,8,45];
// console.log(arr.join('-')) // 1-1-2-3-6-8-45

// 未写分隔符
console.log(arr.join()) // 1,1,2,3,6,8,45

// 注 空数组
let arr1 = [];
console.log(arr1.join()) // 空的 什么也不返回

// 只有长度没有值的数组
let arr2 = new Array(3)
console.log(arr2.join()) // ,,

8、arr.concat() 将一个或多个数组合并起来 或者数组末尾添加新元素 返回一个新数组 不改变原数组

// arr.concat() 将数组合并或者数组末尾添加值 返回一个新数组 不改变原数组
let arr1 = ['a','b','c'];
let arr2 = ['A','B','C'];
let arr3 = [1,2,3];

console.log(arr1.concat(arr2,arr3)) // ["a", "b", "c", "A", "B", "C", 1, 2, 3]
console.log(arr2.concat(arr3,5,89,100)) // ["A", "B", "C", 1, 2, 3, 5, 89, 100]

9、arr.reverse() 将数组内元素颠倒 返回一个数组内元素颠倒了的数组，原数组内元素也颠倒了 修改了原数组

// arr.reverse() 将数组内元素颠倒 返回的数组元素颠倒 原数组与返回的数组一样 元素颠倒  修改了原数组

let arr3 = [1,2,3];
let arr4 = arr3.reverse();

console.log(arr3.reverse()); // [3, 2, 1]     [3, 2, 1]
console.log(arr3 === arr4); // true

10、arr.sort() 排序 是根据字典排序  修改了原数组

/*
    arr.sort()默认排序是字典序
        a 
            aa
                aaa
                aab
            ab
        b
            ba
            bb
*/ 
let arr = [1,25,2,3,55,6,10,1008,45];

// 默认排序
console.log(arr.sort()); // [1, 1008, 2, 25, 3, 45, 55, 6, empty]
console.log(arr) // [1, 1008, 2, 25, 3, 45, 55, 6, empty]

// 寻找一个排序的规律
/*  arr.sort(function(n1, n2){
       console.log(n1,n2);
       return  根据返回的值决定是否交换n1 n2的位置
       大于等于0不换位置
       小于0互换位置
}) */

arr.sort(function(n1,n2){
    // 从大到小排序
    // return n2-n1
    // 从小到大
     return n1-n2
})
console.log(arr) // [1, 2, 3, 6, 10, 25, 45, 55, 1008]

// 自定义排序 如要如下数组从大到小排序
let arr1=['十','一','三','五','九','八','零','六','七'];
        let sortNum = {
            零: 0,
            一: 1,
            三: 3,
            五: 5,
            六: 6,
            七: 7,
            八: 8,
            九: 9,
            十: 10
        }
        console.log(sortNum['一']); // 1
        console.log(sortNum['十']); // 10

        arr1.sort(function(n1, n2){
            return sortNum[n2]-sortNum[n1]
        })
        console.log(arr1) // ["十", "九", "八", "七", "六", "五", "三", "一", "零"]

11、arr.forEach() 遍历数组中的每一位 不修改原数组

        // forEach数组的循环遍历 循环数组中的每一位 不修改原数组
        let arr = ["a","b","c","d","e"];
        /*
            arr.forEach(function(item,index, array){
                console.log(item, index);
                // item 数组中这一位的值
                // index 数组中这一位的索引
                // array 是原数组
            })
        */
        let arr2 = []
        arr.forEach(function(item,index){
                console.log(item, index);
                arr2.push(item.toUpperCase())
        })
        console.log(arr,arr2) // ["a", "b", "c", "d", "e"]   ["A", "B", "C", "D", "E"]

12、arr.map() 替换  返回一个替换后的新数组 不修改原数组

/*
    不改变原数组
    arr.map(function(item, index, array){ // 根据arr的每一位生成一个新的数组 array 是原数组
        return 一个要生成的新数组
    }) 
    map 的返回值是一个替换后的数组
*/
let arr = ["a","b","c","d","e"];
let arr2 = arr.map(function(item, index){
    console.log(item, index);
    return item.toUpperCase()
})
console.log(arr, arr2) // ["a", "b", "c", "d", "e"]  ["A", "B", "C", "D", "E"]

forEach和map的区别

1、forEach()和for循环一样，map()是修改数组中的数据，并返回新的数组

2、forEach()没有return，而map()必须要有return

13、arr.filter()  过滤数组 返回值是一个过滤后的新数组  不修改原数组

/*
    不修改原数组
    arr.filter(function(item, index){ // 对数组进行过滤
        return true 保留这这个元素 false 过滤掉这个元素
    }) 
*/
let arr = [1,25,2,3,55,6,10,1008,45];
let arr2 = arr.filter(function(item, index){
    console.log(item, index);
    return item>10
})
console.log(arr, arr2) // [1, 25, 2, 3, 55, 6, 10, 1008, 45]  [25, 55, 1008, 45]

14、arr.every() 数组中的数据是否全都满足条件语句的值 返回true | false  不修改原数组

/*
    不修改原数组
    arr.every(function(item, index){
        console.log(item,index) // 有不满足条件的就不执行了 返回false
        return 条件语句
    })
    数组中的数据是否全都满足条件语句 有不满足的就返回false 全部满足则返回true 
*/
let arr = [1,25,2,3,55,6,10,1008,45];
let arr2 = arr.every(function(item, index){
    console.log(item, index);
    return item>10
})
console.log(arr, arr2) // [1,25,2,3,55,6,10,1008,45] false

15、arr.some() 数组中的数据是否有满足条件语句的值 返回true | false  不修改原数组

/*
    不修改原数组
    arr.some(function(item, index){
        console.log(item,index)  // 有满足条件的就不执行了 返回true
        return 条件语句
    })
    数组中的数据是否有满足条件语句 
    有一项满足的就返回true 全部不满足则返回false
*/
let arr = [1,25,2,3,55,6,10,1008,45];
let arr2 = arr.some(function(item, index){
    console.log(item, index); 
    return item>10
})
console.log(arr, arr2) // [1,25,2,3,55,6,10,1008,45] true

16、arr.reduce() 不修改原数组

/*
    不修改原数组  
    arr.reduce(function(n1, n2){
        console.log(n1,n2)
        return n1+n2
    },a)

    如果a不传值
    第0次执行：默认传入 n1: 第0位 n2: 第一位
    第1次执行：传入 n1：第0次执行的返回值(如果没有return 就是undefined) n2: 第2位
    第2次执行：传入 n1：第1次执行的返回值(如果没有return 就是undefined) n2: 第3位
    ...

    如果a传值 第0次执行 默认传入n1 就是a的值 依次类推

    最终reduce 返回值是最后一次的返回值
    如果arr是空数组 会报错 解决办法就是传入a值(随便传，不要影响计算结果就好)
*/
let arr = [11,9,2,3,55,6,10,1008,45];
let arr2 = arr.reduce(function(n1, n2){
    console.log(n1, n2);
    return n1+n2
    // return item>10
})
console.log(arr, arr2) // [11, 9, 2, 3, 55, 6, 10, 1008, 45]  1149

let arr = [11,9,2,3,55,6,10,1008,45];

// 用reduce() 找数组的最大值
let arr2 = arr.reduce(function(n1, n2){
    console.log(n1, n2);
    // return n1 > n2? n1 : n2
    return Math.max(n1, n2)
})
console.log(arr2) // 1008

// 用reduce() 找数组的最小值
let arr3 = arr.reduce(function(n1, n2){
    console.log(n1, n2);
    // return n1 > n2? n1 : n2
    return Math.min(n1, n2)
})
console.log(arr3) // 2


// 用reduce给数组去重
let dou = [11,9,11,3,55,6,9,1008,3,7,7];
let arr4 = dou.reduce(function(n1, n2){
    if(!Array.isArray(n1)){
        n1[0] = n1
    }

    return n1.includes(n2)? n1 : n1.concat(n2)
})
console.log(arr4) // [11, 9, 3, 55, 6, 1008, 7]

// 将数组扁平化 一维化
let flat = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13]

function newArr(arr){
    return arr.reduce(function(item1, item2){
        if(Array.isArray(item2)){
            return item1.concat(newArr(item2))
        }else{
            return item1.concat(item2)
        }
    },[])
}
console.log(newArr(flat)) // [100, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]


// 计算数组中每个元素出现的次数
 let duc = ['nn','aa','ad','nn', 'aa', 'aa','df','ad','nn'];
 let arr6 = duc.reduce(function(n1,n2){
    if(n2 in n1){
        n1[n2]++
    }else{
        n1[n2] = 1
    }
    return n1
 },{})

console.log(arr6) // {nn: 3, aa: 3, ad: 2, df: 1}

还有一个reduceRight()与reduce()功能用法一样，不同点是前者是从数组末尾向前开始进行计算的

 17、arr.slice() 切割数组 以数组形式返回切割下来的值 不修改原数组

/*
    arr.slice(start, end) 切割数组
    start 切割开始的位置(若为负数则不切割)
    end   切割结束的位置 不包含这个位置的值(若为负数则从后向前数, 若不传则会切割从start开始往后的所有值)

    不修改原数组  并以数组的形式返回切割下的值
*/

let arr = [11,9,2,3,55,6,10,1008,45]
// console.log(arr.slice(2,5), arr) // [2, 3, 55] [11, 9, 2, 3, 55, 6, 10, 1008, 45]
// console.log(arr.slice(6)) // [10, 1008, 45]
console.log(arr.slice(2,-3)) // [2, 3, 55, 6]

此外数组能用的方法中还有 arr.indexOf()    arr.lastIndexOf()

与字符串的用法一样

18、Array.from(arr) 将类数组arr 转换成数组  不改变原来的类数组

/*
    Array.from(类属组, callBack, this指向)
    把类属组转化成真正的数组
        类属组: 要转化的类属组
        callBack： 不定参可用可不用，把数组遍历一遍，有两个参数分别对应数组当前项和下标
        this指向： 不定参 绑定this的指向
    不改变原类属组
*/

// 模拟一个类数组 转化成数组
let data = {
    0: 12,
    1: 3,
    2: 5,
    3: 7,
    length: 4
}
// console.log(Array.from(data)) // [12, 3, 5, 7]

let arr1 = Array.from(data,function(item, index){
    console.log(item, index, this);
    return item+item
},document)
console.log(arr1) // [24, 6, 10, 14]

// 监测是一个对象还是一个数组
console.log(Object.prototype.toString.call(arr1)) // [object Array]
console.log(Object.prototype.toString.call(data)) // [object Object]

19、Array.isArray(arr) 判断一个变量是不是数组  类数组不是数组

<body>
    <ul id="list">
        <li>li1</li>
        <li>li2</li>
        <li>li3</li>
        <li>li4</li>
        <li>li5</li>
    </ul>
    <script>
        // 类数组不是数组，在Array.isArray(arr)的判断中是false
        // arr是要检测的变量
        // 返回值true | false
        let arr = ["a","b","c","d","e"];
        let ul = document.getElementById('list');
        let li = ul.querySelectorAll('li'); // 这个li是类数组
        console.log(Array.isArray(li))     // false
        console.log(Array.isArray(arr))    // true

    </script>
</body>

20、Array.of(data1,data2...) 将参数转化成一个数组 也可用作生成数组 返回一个新数组

/*
    Array.of(data1,data2...) 将参数转化成数组
        data: 要放入数组中的值
        返回一个新的数组 如果参数为空则返回一个空数组
*/
let arr = Array.of(1,2,3,4,5);
console.log(arr) // [1, 2, 3, 4, 5]

21、arr.find() 查找数组中满足要求的第一个元素

/*
    Array.find(callBack, this指向) 查找数组中满足要求的第一个元素的值
        callBack接收三个参数
            遍历到的元素
            遍历到元素的下标
            数组本身
        this指向：绑定this指向
    返回数组中第一个满足要求的值，否则返回undefined
*/
let arr = [11,9,2,3,55,6,10,1008,45];
let arr2 = arr.find(function(el,idx){
    return el>20
    // return el>2000  // undefined
},document);
console.log(arr, arr2) // [11, 9, 2, 3, 55, 6, 10, 1008, 45] 55

22、arr.findIndex() 查找数组中满足要求的第一个元素的索引值

/*
    Array.findIndex(callBack, this指向) 查找数组中满足要求的第一个元素的下标
        callBack接收三个参数
            遍历到的元素
            遍历到元素的下标
            数组本身
        this指向：绑定this指向
    返回值：一个包含将数组与子数组中所有元素的新数组
*/
let arr = [11,9,2,3,55,6,10,1008,45];
let arr2 = arr.findIndex(function(el,idx){
    return el>20
    // return el>2000 // -1
},document);
console.log(arr, arr2) // [11, 9, 2, 3, 55, 6, 10, 1008, 45] 55

23、arr.flat() 扁平化多维数组

/*
    arr.flat(deep) 将数组扁平化 将将多维数组转换成一维数组
        deep: 可选参数 
        默认是1 就是提取一层
        不知道有多少层  可用Infinity 无限层直接转换成一维
    不改变原数组    
*/
let flat = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13]
console.log(flat.flat(Infinity)) // [100, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

24、arr.flatMap()用遍历的方法数组扁平化 不过只能提取一层

/*
    arr.flatMap(callBack, thisArg) 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和 深度值1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些
        callBack有三个参数：
            callBack接收三个参数
            遍历到的元素
            遍历到元素的下标
            数组本身
        this指向：绑定this指向
        默认是1 就是提取一层
        不知道有多少层  可用Infinity 无限层直接转换成一维
    不改变原数组    
*/
let arr = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13];

let arr1 = arr.flatMap(function(item, index){
    return item
},document)
console.log(arr1) //  [100, 99, 1, 2, 3, 4, 5, Array(3), 13]

25、arr.fill() 填充指定位置的数组 改变原数组

/*
    arr.fill(data, start, end);用一个固定值填充一个数组中从起始索引到终止索引的内的全部元素，不包括终止索引。相当于替换 不改变原始数组的长度
        data: 要填充的值
        可选参数
            start： 起始索引
            end： 终止索引，默认值为arr.length 
    返回一个新的数组  修改原数组  
*/
let arr = [11,9,2,3,55,6,10,1008,45];

// let arr1 = arr.fill('a',2, 5)
// console.log(arr1 , arr) //  [11, 9, "a", "a", "a", 6, 10, 1008, 45]   [11, 9, "a", "a", "a", 6, 10, 1008, 45]

// 当什么参数都不传时
/* let arr2 = arr.fill()
console.log(arr2) // [undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined] */

// 当直传一个填充参数时
/* let arr2 = arr.fill('A')
console.log(arr2) // ["A", "A", "A", "A", "A", "A", "A", "A", "A"] */

// 当穿两个参数时
let arr2 = arr.fill('A', 5)
console.log(arr2) // [11, 9, 2, 3, 55, "A", "A", "A", "A"]

26、arr.includes() 判断数组中是否包含一个指定的值

/*
    arr.includdes(val, index)判断数组中是否包含一个指定的值
        val：需要查找的值
        index: 可选参数 从下标为index的位置开始查
    返回一个Boolean的值  true | false  
*/
let arr = ["a","b","c","d","e"];

console.log(arr.includes('c')) // true
console.log(arr.includes('c',3)) // false
console.log(arr.includes('c',-3)) // true 从后往前数3位再从这三位里找有没有 'c'

27、arr.copyWithin() 在当前数组内部，将数组指定位置的值放到其他位置，并覆盖原数组值，返回一个新的数组，改变原数组

/*
    arr.copyWithin(target, start, end)方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，                    
     不会改变原数组的长度定的值
        target：0 为基底的索引，复制序列到该位置。
                如果是负数，target 将从末尾开始计算。
                如果 target 大于等于 arr.length，将会不发生拷贝。
                如果 target 在 start 之后，复制的序列将被修改以符合 arr.length。

        start: 0 为基底的索引，开始复制元素的起始位置,
                如果是负数，start 将从末尾开始计算。
                如果 start 被忽略，copyWithin 将会从0开始复制

        end:0 为基底的索引，开始复制元素的结束位置。
            copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。
            如果是负数， end 将从末尾开始计算.
            如果 end 被忽略，copyWithin 方法将会一直复制至数组结尾（默认为 arr.length）。
    修改了原数组
*/
let arr = ["a","b","c","d","e"];

// console.log(arr.copyWithin()) // ["a", "b", "c", "d", "e"]
// console.log(arr.copyWithin(1,2,3),arr) // ["a", "c", "c", "d", "e"]  ["a", "c", "c", "d", "e"]
// console.log(arr.copyWithin(1)) // ["a", "a", "b", "c", "d"]
console.log(arr.copyWithin(1,3)) // ["a", "d", "e", "d", "e"]

28、arr.keys() 遍历数组的键名

/*
    arr.keys()返回一个包含数组中每一个索引键的 Array Iterator对象
    返回值 一个新的Array迭代器对象
*/
let arr = ["a","b","c","d","e"];
let arr1 = arr.keys();
console.log(arr1) // Array Iterator迭代器对象
for(let key of arr1){
    console.log(key, arr1[key]) // 0,undefined 1,undefined 2,undefined...
}

29、arr.values() 遍历数组的键值

/*
    arr.values()返回一个包含数组中每一个索引值的 Array Iterator对象
    返回值 一个新的Array迭代器对象 包含数组每个索引对应的值
*/
let arr = ["a","b","c","d","e"];
let arr1 = arr.values();
console.log(arr1) // Array Iterator迭代器对象
for(let key of arr1){
    console.log(key, arr1[key]) // a,undefined b,undefined c,undefined...
}

30、arr.entries() 遍历数组的键名和键值

/*
    arr.entries()返回一个包含数组中每一个索引值/值对的 Array Iterator对象
    返回值 一个新的Array迭代器对象 包含数组每个索引与其对应的值
*/
let arr = ["a","b","c","d","e"];
let arr1 = arr.entries();
console.log(arr1) // Array Iterator迭代器对象
for(let key of arr1){
    console.log(key) // [0,'a'] [1,'b'] [2,'c'] [3,'d'] [4,'e']
}

31、 new Set(arr) 可以储存任何类型的唯一值包括数组不修改原数组

/*
    new Set(arr)  可以储存任何类型的唯一值包括数组
    其本身也是一个构造函数  会自动去重
    传递的是数组时 返回的不是数组 而是有size长度的对象
*/
let arr = ["b","c","d","e", 'b','d','f'];
let mySet = new Set(arr);
console.log(mySet) // {"b", "c", "d", "e", "f"}
// 转换成数组
// console.log(Array.from(mySet)) // ["b", "c", "d", "e", "f"]
// 或者用解构赋值转换成数组
// console.log([...mySet]) // ["b", "c", "d", "e", "f"]
console.log(mySet.size) // 5
/*
    mySet.size 获取对象中值的个数
    mySet.add('n') 在set对象末尾添加一个元素，返回该set对象
    mySet.clear() 移出set对象内所有元素
    mySet.delete(val) 移出set中val这个元素，如果这个元素在则返回true 不在没有删除成功则返回false
    mySet.entries() 返回一个新的迭代器对象，
        该对象包含Set对象中的按插入顺序排列的所有元素的值的[value, value]数组。
        为了使这个方法和Map对象保持相似， 每个值的键和值相等。
    mySet.has(val) set 中是否包含val 返回值为true | false
*/

32、new Map(arr) 接收的不能是一维数组 要以key value形式

/*
    new Map(arr)  对象保存键值对，并且能够记住键的原始插入顺序。
    任何值(对象或者原始值) 都可以作为一个键或一个值。
    传递的是数组时 返回的不是数组 而是有size长度的对象
*/
// let arr = [[100,99],1,2,[3,4],[5,[6,7,[8,9,[10,11],12]]],13];
// let arr = ["b","c","d","e", 'b','d','f'];
let myMap = new Map([['xiaohua','aa'],['xiaohong','bb'],['xiaolan','dd']]);
console.log(myMap) // Map(3) {"xiaohua" => "aa", "xiaohong" => "bb", "xiaolan" => "dd"}
console.log(myMap.size) // 3
// console.log(myMap.delete('xiaohong')) // true
// console.log(myMap.delete('bb')) // false
/*
    myMap.size 获取对象中值的个数
    myMap.set(key,val) 在map对象末尾添加一个元素，返回该map对象
    myMap.get(key) 返回键对应的值，如果不存在，则返回undefined。
    myMap.clear() 移出map对象内所有元素
    myMap.delete(key) 这里传的是key而不是value移出map中key这个元素，如果这个元素在则返回true 不在没有删除成功则返回false
    myMap.entries() 返回一个新的 Iterator 对象，它按插入顺序包含了Map对象中每个元素的 [key, value] 数组。
    myMap.has(key) map 中是否包含key 返回值为true | false
*/

汇总：

1、修改了原数组的

arr.length 修改原数组的长度

arr.pop () 数组末尾删除一个值 并返回删除的值

arr.push() 数组末尾添加值 并返回数组的长度

arr.shift() 数组起始位置删除一个值 并返回删除的值

arr.unshift() 数组起始位置添加值 并返回数组的长度

arr.splice() 数组元素的替换

arr.reverse() 将数组内元素颠倒 返回一个数组内元素颠倒了的数组，原数组内元素也颠倒了

arr.sort() 排序 是根据字典排序

arr.fill() 填充指定位置的数组

arr.copyWithin() 在当前数组内部，将数组指定位置的值放到其他位置，并覆盖原数组值，返回一个新的数组

 

2、未修改原数组的

arr.indexOf()

arr.lastIndexOf()

arr.slice() 切割数组 以数组形式返回切割下来的值

arr.join() 将数组链接成字符串 返回一个字符串

arr.concat() 将一个或多个数组合并起来 或者数组末尾添加新元素 返回一个新数组

arr.forEach() 遍历数组中的每一位

arr.map() 替换  返回一个替换后的新数组

arr.filter()  过滤数组 返回值是一个过滤后的新数组

arr.every() 数组中的数据是否全都满足条件语句的值 返回true | false

arr.some() 数组中的数据是否有满足条件语句的值 返回true | false

arr.reduce()

reduceRight()

Array.from(arr) 将类数组arr 转换成数组

Array.isArray(arr) 判断一个变量是不是数组

arr.includes() 判断数组中是否包含一个指定的值

Array.of(data1,data2...) 将参数转化成一个数组 也可用作生成数组

arr.find() 查找数组中满足要求的第一个元素

arr.findIndex() 查找数组中满足要求的第一个元素的索引值

arr.flat() 扁平化多维数组

arr.flatMap()用遍历的方法数组扁平化 不过只能提取一层

arr.keys() 遍历数组的键名

arr.values() 遍历数组的键值

arr.entries() 遍历数组的键名和键值

new Set(arr) 可以储存任何类型的唯一值包括数组不修改原数组

new Map(arr) 接收的不能是一维数组 要以key value形式