五、数组

数组的API

数组的API：前辈们提前定义好的一些函数，可以直接使用，这些函数只有数组可用

（join concat slice splice reverse sort push pop shift unshift）

Array.isArray() —— 用来检查一个对象是否是数组

一、不修改原数组的数组API

1.数组转为字符串（2种）

（1）toString

    var arr = [1, 2, 3]

        console.log(arr.toString()); //1,2,3

(2)join(可以分割) —— 将数组转换成字符串

        var arr = ["green", "blue", "red"];

        console.log(arr.join()); //green,blue,red

        console.log(arr.join("-")); //green-blue-red

面试题：split()和join()的区别

2.拼接数组：添加元素到末尾的新方式

以前的方式：arr[arr.length]=新元素;只能一个个添加

arr.concat(值1....)；里面想放几个放几个。

注意：（1）此方法不会修改原数组，必须拿一个变量去接住它

           （2）哪怕拼接的是一个数组，也会打散数组，单个添加

     

            var arr = [1, 2, 3];

            var newArr = arr.concat(4);

            console.log(newArr)

            

                      

            var arr1=[1,2,3];

            var arr2=[4,5,6,7];

            var newArr=arr1.concat(arr2);

             console.log(newArr);//[1,2,3,4,5,6,7]

3.截取子数组：

arr.slice(starti,endi);  含头不含尾

注意：（1）此方法不会修改原数组，必须拿一个变量去接住它（返回的是一个新数组）

    （2）含头不含尾（所以   arr.slice(starti,endi+1);）

    （3）如果只传入了一个实参，则从starti开始，到末尾

      (4)如果两个实参都省略，则相当于复制了一份（深拷贝），两者不会互相影响

      (5)支持负数参数，-1代表倒数第一个，-n代表倒数第n个

  (1)   var arr = [1, 2, 3, 4, 5];

        var subArr = arr.slice(1, 4);

        console.log(subArr); //[2,3,4]  含头不含尾

        

  (2)    //只传一个参数，从starti到末尾

        var arr = [1, 2, 3, 4, 5];

        var subArr = arr.slice(1);

        console.log(subArr); //[2,3,4,5]

二、修改原数组的API

连接数组 ： 

at（）

    

                可以根据索引获取数组中的指定元素

                at可以接收负索引作为参数

    

        const arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]

        console.log(arr.at(-2)) //沙和尚

删插替

splice:

1.删除：arr.splice(starti,n);//从starti位置开始删除n个元素

         特殊：返回的是你删除的元素组成的数组——有可能你删除的正好是你需要的

        var arr1 = [1, 2, 3, 4, 5];

        var arr2 = arr.splice(1, 2);

        console.log(arr); //[1,4,5]

        console.log(arr2); //删除的元素[2,3]

2.插入：var arr2=arr.splice(starti,0,新值1....)；

         特殊：1.原来starti位置的元素以及后续元素都会被向后移动

    2.没有删除元素，也会有返回值，返回的是一个空数组

        var arr = [10, 20, 60, 40, 50];

        var arr2 = arr.splice(1, 0, 11, 12, 13);

        console.log(arr);//[10,11,12,13,20,60,40,50]

        console.log(arr2);//[]空数组

3.替换：var arr2=arr.splice(starti,n,新值1....)；var arr2=arr.splice(starti,0,新值1....)；

    特殊：删除个数和插入个数不必相同

        var arr = [10, 20, 60, 40, 50];

        var arr2 = arr.splice(1, 2, 11, 12, 13); //删两个插三个，从第二个开始删，插入11,12,13

        console.log(arr); //[10,11,12,13,40,50]

        console.log(arr2); //[20,60]

4.翻转数组：arr.reverse()；——仅仅只能翻转

三、

1.排序：

数组提供了一个排序API：

语法：arr.sort();

特殊：（1）默认转为字符串，按位PK每个字符的Unicode（ascii）

    （2）希望按照数字排序——升序

arr.sort(funcction(){

})//匿名回调函数

普通排序冒泡排序

        var arr = [1, 2, 5, 8, 9, 3, 6];

        for (var j = 1; j < arr.length; j++) {

            for (var i = 0; i < arr.length - j; i++) {//执行一次就把最大的放最后

                if (arr[i] > arr[i + 1]) {

                    var m = arr[i];

                    arr[i] = arr[i + 1];

                    arr[i + 1] = m;

                }

            }

        }

        console.log(arr);

API排序

     var arr = [7, 5, 9, 8, 4, 6, 1, 3, 2, 111, 11, 12, 13];

        //          arr.sort();//字符串排序

        // 数字升序

        arr.sort(function(a, b) { //匿名回调函数，是不需要我们程序员区调用的，而且都是前辈们提供好了的，我们

        只需要学习如何使用的

            // console.log(a, b); //a是后一个数，b是前一个数

            return a - b; //如果a>b，就会返回一个正数，说明后一个数>前一个数

            //如果a<b，就会返回一个负数，说明后一个数<前一个数

            //如果a==b，就会返回一个0，说明后一个数==前一个数

            //而sort的底层就能通过你返回的值来判断要不要帮你交换位置

        })

       //降序  return b - a;

        console.log(arr);

2.栈和队列：作用：添加元素和删除元素的新方式

栈：一端封闭，只能从另一端进出。

何时使用：希望用到最新的数据的时候

开头入：arr.unshift(新值...)

       var arr = [4, 5, 6];

        arr.unshift(1, 2, 3);//开头入

        console.log(arr); //[1,2,3,4,5,6]

开头出：var first=arr.shift();一次只能删除一个，而且一定是删除的第一个元素，有可能删除的东西就是你需要的东西。

       var arr = [4, 5, 6];

        var first = arr.shift();//开头处，只出第一个元素

        console.log(arr); //[5,6] 一次只能删除一个,删除的是第一个元素

开头进出，会导致每个元素的下标都会发生变化。

结尾入:arr.push(新值...)

        var arr = [4, 5, 6];

        arr.push(7, 8, 9);//结尾入

        console.log(arr);//[4,5,6,7,8,9]

结尾出：var last=arr.pop();//一次只能删除一个元素，而且一定是删除最后一个

         var arr = [4, 5, 6];

         var last = arr.pop();//结尾出，只出第一个

        console.log(arr); //[4,5]

更推荐它，不会影响其它人的位置

队列：只能一端进入，另一端进出

何时使用：按照先来后到的顺序

2.数组的新的API：3组6个。他们都简化了同一件事，for循环。以后可以不再写for循环。

（1）判断：判断数组中的元素是否复合要求

every：判断数组中的每个元素都要符合要求最后结果才为true。——类似于&&

语法：arr.every(function(val,i,arr){

return 判断条件;

})

        var arr1 = [1, 2, 3, 4, 5];

        var arr2 = [2, 4, 6, 8, 10];

        arr1.every(function(val, i, arr1) {

            // console.log(val); //1 —— 数组的第一个值。为什么只有1？因为函数不写return，也默认有return, return undefined;

            // return undefined; //false。 every特点：一旦出现false，则不再看后面

            console.log(val); //val：遍历到的当前元素

            console.log(i); //遍历到的当前元素的下标

            return true;

        })

判断数组是否都是由偶数组成

        // 判断数组是否都是由偶数组成的

        var arr1 = [1, 2, 3, 4, 5];

        var arr2 = [2, 4, 6, 8, 10];

        console.log(arr1.every(function(val, i, arr) {

     

            return val % 2 == 0;

        })); //false

        console.log(arr2.every(function(val, i, arr) {

            return val % 2 == 0

        })); //true

some：判断数组中是否包含复合要求的元素，只要有一个结果则为true。——类似于||

    // 判断数组是否包含偶数

        var arr1 = [1, 2, 3, 4, 5];

        var arr2 = [2, 4, 6, 8, 10];

        var arr3 = [1, 3, 5, 7, 9];

         console.log(arr3.some(function(val, i, arr) {

            return val % 2 == 0

        })); //false

        console.log(arr1.some(function(val, i, arr) {

            return val % 2 == 0

        })); //true

（2）遍历：对每个元素执行相同或者相似的操作

forEach：直接修改原数组

语法：arr.forEach(function(val,i,arr){

操作;

})

数组每个元素都*2

        var arr = [1, 2, 3, 4, 5, 6]

        arr.forEach(function(val, i, arr) {

            arr[i] *= 2 //arr[i]代表 某个位置，val代表某个字，所以不能写成val*=2

        })

        console.log(arr); //[2,4,6,8,10,12]

map：不修改原数组，返回新数组

语法：var newArr=arr.map(function(val,i,arr){

return 操作;

})

         var arr1 = [2, 4, 5, 3, 1];

         var newArr = arr1.map(function(val, i, arr) {

            return arr1[i] * 2

        })

        console.log(arr1); //[2,4,5,3,1]

        console.log(newArr); //[4,8,10,6,2]

（3）过滤和汇总

过滤：筛选出原数组中符合条件的元素组成一个新数组。元素组不变

语法：var newArr=arr.filter(function(val,i,arr){

return 判断条件;

})

  // 过滤,筛选出所有奇数

        var arr = [1, 3, 5, 4, 8];

        var newArr = arr.filter(function(val, i, arr) {

            return val % 2 == 1

        })

        console.log(arr); //[1,3,5,4,8]

        console.log(newArr); //[1,3,5]

汇总：将数组中的每一个元素，取出来整合为一个最终结果

语法：var newArr=arr.reduce(function(prev,val,i,arr){

return prev+val;

},基础值)

  var arr = [1, 3, 5, 4, 8];

        // 汇总

        var newA = arr.reduce(function(prev, val, i, arr) {

            return prev + val;

        }, 100)

        console.log(newA); //121