数组常用API

数组的常用方法

shift()：删除数组的第一项

返回值：被删除的项，

改变原数组

let arr = [11, 33, 55, 77];
arr.shift(); // 删除的第一项为0
console.log(arr); // [33, 55, 77]

unshift()：向数组首位添加新内容

参数：要添加的项，

多项用之间用逗号隔开，

返回值：新数组的长度，

改变原数组

let arr = ['a', 'b'];
arr.unshift('c', 'd');
console.log(arr); // ['c', 'd', 'a', 'b']

push()：向数组的末尾添加新内容

参数：要添加的项。传递多个用逗号隔开，任何数据类型都可以，

返回值：新增后数组的长度，

改变原数组

let arr = [11, 22, 33];
arr.push(66); // 返回一个新的长度 
// length = 4
console.log(arr); // 结果为 [11, 22, 33, 66]

pop()：删除数组的最后一项

返回值：被删除的项

改变原数组

let arr = [11, 33, 55, 77];
arr.pop(); // 删除的最后一项为10
console.log(arr); // [11, 33, 55]

slice()：按照条件查找出其中的部分内容

参数：array.slice(a, b)，从索引a开始查找到b处（不包含b）

array.slice(a) 第二个参数省略，则一直查找到末尾

array.slice(0)原样输出内容，可以实现数组克隆

array.slice(-a, -b) slice支持负参数，从最后一项开始算起，-1为最后一项，-2为倒数第二项，

返回值：返回一个新数组，

不改变原数组

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        console.log(arr.slice(2,8)); // [3, 4, 5, 6, 7, 8] 
        console.log(arr.slice(0));  // [1, 2, 3, 4, 5, 6, 7, 8, 9]
        console.log(arr.slice(-2, -1)); // [8]

splice()：对数组进行增删改

增加：ary.splice(a, 0, b)从索引a开始删除0项，把m或者更多的内容插入到索引a的前面

返回空数组

// 增加
        let arr1 = [11, 22, 55, 66, 77, 99];
        arr1.splice(3, 0, 'a', 'b');
        console.log(arr1); // [11, 22, 55, 'a', 'b', 66, 77, 99]

修改：ary.splice(a, x, b)从索引n开始删除x个，b替换删除的部分

把原有内容删除掉，然后用新内容替换掉

// 修改
        let arr2 = [11, 22, 55, 66, 77, 99];
        arr2.splice(2, 1, 'x', 'y');
        console.log(arr2); // [11, 22, 'x', 'y', 66, 77, 99]

删除：ary.splice(n, m) 从索引n开始删除m个内容（如果第二个参数省略，则从n删除到末尾）

返回删除的新数组，原有数组改变

// 删除
        let arr3 = [11, 22, 55, 66, 77, 99];
        console.log(arr3.splice(2)); // [55, 66, 77, 99]
        console.log(arr3.splice(1,3)); // [22]

reverse() ：反转数组

返回值：倒序后新数组

改变原数组

let arr = [1,3,5,7,9];
        console.log(arr.reverse()); // [9, 7, 5, 3, 1]

join()：用指定的分隔符将数组每一项拼接为字符串

参数：指定的分隔符（如果省略该参数，则使用逗号作为分隔符）

返回值：拼接好的字符串

不改变原数组

let arr = [1, 2, 3];
        console.log(arr.join()); // 1,2,3
        console.log(arr.join("、")); // 1、2、3

indexOf()：检测当前值在数组中第一次出现的位置索引

参数：array.indexOf(a, b) a:查找的元素 b: 字符串中开始检索的位置

返回值：第一次查到的索引，未找到返回 - 1

不改变原数组

let arr = ['a', 'b', 'c', 'd', 'e', 'a', 'f'];
        console.log(arr.indexOf('c')); // 2
        console.log(arr.indexOf('a', 3)); // 5

lastIndexOf()    检测当前值在数组中最后一次出现的位置索引

参数：array.lastIndexOf(a, b) a:查找的元素，b: 字符串中开始检索的位置

返回值：第一次查到的索引，未找到返回 - 1

不改变原数组

let arr = ['a', 'b', 'c', 'd', 'e', 'a', 'f'];
        console.log(arr.lastIndexOf('c')); // 2
        console.log(arr.lastIndexOf('f', 1)); // -1

concat()：用于连接两个或多个数组

参数：参数可以是具体的值，也可以是数组对象。可以是任意多个

返回值：返回连接后的新数组

不改变原数组

let arr = ['你'];
        let arr1 = arr.concat('好');
        console.log(arr1); // ["你", "好"]

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

参数：指定的内容

返回值：布尔值

不改变原数组

let arr = ['a', 'b', 'c', 'd'];
        console.log(arr.includes('c')); // true
        console.log(arr.includes(2)); // false

数组的高阶函数

forEach()：循环遍历数组每一项

参数：函数 ary.forEach(function (value, index, arr) { })

value:每一项，index:索引，arr: 当前数组（一般不用）

无返回值

不改变原数组

forEach中不能使用continue和break，forEach中不能跳出，只能跳过(return跳过)

let arrN = ['a', 'b', 'c', 'd'];
        let newArr = arrN.forEach(function (value, index, arr) {
            console.log(value, index, arr);   /* 
                                                a 0 (4) ['a', 'b', 'c', 'd']
                                                b 1 (4) ['a', 'b', 'c', 'd']
                                                c 2 (4) ['a', 'b', 'c', 'd']
                                                d 3 (4) ['a', 'b', 'c', 'd']

                                            */
        })

findIndex()：当数组中的元素返回 true 时, 该方法会返回符合条件的元素的索引位置，之后的值不会再调用执行函数，

如果没有符合条件的元素返回 -1、原数组不变

var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 89, 100]
        var w = arr1.findIndex(function (v, i) {
            return v > 4
            //  return v < 0  // -1
            //  return v > 90  // 9
        })
        console.log(w); // 4 

find()：当数组中的元素在测试条件时返回 true 时, 返回符合条件的元素，之后的值不会再调用执行函数，

如果没有符合条件的元素返回 undefined、原数组不变

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        var a = arr.find(function (v, i) {
            return v > 5
           // return v < 0  // undefined
        })
        console.log(a); // 6

filter()：方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素、原数组不变

var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 89, 100]
        var newArr = arr1.filter(function (v, i) {
            return v > 6
        })
        console.log(newArr); // [7, 8, 89, 100]

sort()：对数组的元素进行排序（默认是从小到大来排序 并且是根据字符串来排序的）

参数：可选(函数) 规定排序规则 默认排序顺序为按字母升序

返回值：排序后新数组

改变原数组

sort在不传递参数情况下，只能处理10以内（个位数）数字排序

let arr = [32, 44, 23, 54, 90, 12, 9];
        arr.sort(function (a, b) {        // return a-b; 结果[9, 12, 23, 32, 44, 54, 90]
            return b - a;
        })   // 结果[90, 54, 44, 32, 23, 12, 9]   
        console.log(arr);

map()：该方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值、原数组不变

var arr = [10, 2, 3, 5, 70, 60, 100];
        var answer = arr.map(function (v, i) {
            return v + 100;
        })
        console.log(answer); // [110,102,103,105,170,160,200]

flat()：数组扁平化

参数：（默认不填、数值是1)，即展开一层数组，如果是多层，参数可以传进 Infinity，代表不论多少层都要展开

// 数组扁平化
        var arr = [1,2,[3,6,[5,7]]];
        // Infinity 无穷的
        var answer2 = arr.flat(Infinity);
        // var answer2 = arr.flat(2);
        console.log(arr.flat(1),arr.flat(2));
        console.log(answer2); // [1, 2, 3, 6, 5, 7]

some()：对数组每一项进行判断，如果有一个元素满足条件，则返回true , 并停止遍历

如果没有满足条件的元素，则返回false，原数组不变

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        var c = arr.some(function (v, i) {
            return v > 8
        })
        console.log(c); // true

every()：对数组中每一项进行判断，若每一项都返回true、则返回true

有一个为false，则返回false，并停止遍历，原数组不变

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        var b = arr.every(function (v, i) {
            return v % 2 > 0
        })
        console.log(b);  // false