JS数组的相关知识

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

数组

数组：一系列有序数组的集合

数组的方法：

pop():删除数组的最后一项。不用书写参数，返回值删除项的值。

push():在数组最后添加数据。参数：要添加的数据，多项用逗号隔开，返回数组的长度。

shift():删除数组的第一项。不用书写参数，返回值删除项得值。

unshift():数组开头添加数据，参数：要添加的数据，多项用逗号隔开。返回数组的长度。

concat():用于两个或者多个数组的合并。参数是要合并的数组。返回值是合并后的新数组。

slice(start,end):用于截取数组中某一片段。start，end表示数组的索引值。start表示截取数组的起始位置索引值（包括start）到end结束位置索引值（不包括end)。start和end还可以写成负数。表示倒数第几。倒数是从-1开始。仍是包括start不包括end。只写一个start表示从start开始截取到数组最后一项。

splice(index,howmany,element1,element2…)

​ index:表示要删除数组的首项的索引值。

​ howmany:表示要删除数组的个数。

​ elements:表示要替换或者插入的元素。

​ 返回值：删除数据组成的数组。没有要删除的数据返回空数组。原数组发生改变

插入：howmany:0表示没有要删除的数据（不能省略）。elements必须书写，表示要插入元素。

删除：howmany:必须不能是0，表示要删除的个数。elements:不能书写。

替换：三个参数都要书写。howmany,elements个数不相同。

reverse():表示将原数组的顺序前后颠倒。不用书写参数

sort():表示排序，可以不写参数，从小到大排序。还可以传递参数，是一个比较大小的函数。如果书写比较函数，数组会按照比较函数返回值进行排序。将比较函数的两个元素记为a,b。

​ a<b,返回值是负数。 表示排序后的数组，a在b前面

​ a==b,返回值是0。表示a b 相同，排序顺序不变

​ a>b,返回值是正数。表示a比b大，排序后的数组，a在b后面。

注：排序依据是将所有数据先转换为字符串，然后按照字符串的大小进行排序。按照字符编码排序，顺序为：数字、大写字母、小写字母。

join():数组转为字符串的方法。join可以书写参数，表示数组中每一个数据以参数进行连接。不书写参数，元素以逗号连接。

堆栈与队列：

堆栈：push—pop (先进后出) 队列：push—shift （先进先出）

        //一个变量存储一个数组，想用一个变量存储多个数据，可以使用数组
        // 数组是一个有序数组集合
        var arr = [10,20,30];
        console.log(arr);
        // 通过索引值访问
        console.log(arr[1]);
        // 修改数据也通过索引值
        arr[0] = 50;
        console.log(arr[0]);
        // 查看数组成员总数
        console.log(arr.length);
        // 访问数组最后一个成员
        // 有效长度：0-arr.length-1
        console.log(arr[arr.length-1]);
        // 通过length为数组设置成员，数组被拉长(有序拉长)
        arr[arr.length] =100;
        // 通过大于length的下标设置数组成员，是一种无规律拉长(中间看不到成员数据)
        arr[10] = 66;
        arr[11] = 'hello';
        console.log(arr);

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

        // 删除末尾成员
        var result = arr1.pop();
        // 添加成员
        var result1 = arr1.push(6,7,8);
        // 删除第一个成员
        var result = arr1.shift();
        // 添加成员
        var result = arr1.unshift(0,-1,-2);
        console.log(result,arr1);
        console.log(result1,arr1);

        堆栈
        最后一个成员后进先出
        arr1.push(6);
        console.log(arr1);
        arr1.pop();
        console.log(arr1)

        队列
        最后一个成员后进后出
        arr1.push(6);
        console.log(arr1);
        arr1.shift();
        console.log(arr1);

        // 例题：将最后一项移动到最前面
        var arr2 = ['春','夏','秋','冬'];
        var item = arr2.pop();
        console.log(item)
        arr2.unshift(item)
        // 将第一个移到最后
        var first = arr2.shift();
        arr2.push(first);
        console.log(arr2);

数组的合并与拆分代码示例：

   var arr1 = [1,2,3,4,5],
            arr2 = [6,7,8];
        // 合并在一起
        var result = arr1.concat(arr2);
        console.log(result,'---',arr1,'---',arr2);
        // 数组的截取
        var arr3 = [0,1,2,3,4,5,6,7,8];
        // 截取3,4,5
        var result1 = arr3.slice(3,6);
        console.log('result1---->',result1);
        // 从4截取到数组结束
        var result2 = arr3.slice(4);
        console.log('result2---->',result2);
        // 复制了一份
        var result3 = arr3.slice();
        console.log('result3---->',result3);
        // 传递负数表示倒数（倒数就是加上长度）
        var result4 = arr3.slice(-5,-2);//slice(-5+10,-2+10)---->slice(5,8)
        console.log('result4---->',result4);
        // 如果起始位置大于结束位置，截取不到
        var result5 = arr3.slice(8,5);
        console.log('result5---->',result5);

运行结果：

数组的删除、插入、替换

      var arr = [0,1,2,3,4,5,6,7,8,9];
        //删除4,5,6
        var result = arr.splice(4,3);
        console.log('删除4,5,6----->',result,arr);
        //插入：4后面插入a,b,c
        var result1 = arr.splice(4,0,'a','b','c');
        console.log('4后面插入a,b,c----->',result1,arr,);
        // 不能写数组，否则数组将作为整体插入
        var result2 = arr.splice(4,0,['a','b','c']);
        console.log('数组将作为整体插入----->',result2,arr);
        // 替换：将0,1,2换成A,B
        var result3 = arr.splice(0,2,'A','B');
        console.log('将0,1,2换成A,B----->',result3,arr);

数组的排序

 var arr = [0,1,2,3,4,5];
        // 倒置
        var result = arr.reverse();
        console.log('result:',result,'arr:',arr);

        var arr1 = [0,1,7,2,4,5];
        // 对数组进行排序
        var result1 = arr1.sort();
        console.log('result1:',result1,'arr1:',arr1);

        // 参数可以是比较函数
        var arr2 = [0,1,7,2,4,5,9];
        var result2 = arr2.sort(function(a,b){
            // a表示后一个成员，b表示后一个成员
            // console.log(a,b);
            if(a<b){
                // 如果a<b,返回负数，表示a在b前面
                return -1;
            }else if(a == b){
                // 如果a=b,不需要改变顺序
                return 0;
            }else if(a>b){
                // 如果a>b,返回正数,a在b的后面
                return 1;
            }
        })
        console.log('result2',result2,'arr2:',arr2);

        // 简写，返回值正负数用减法获取
        var arr3 = [0,1,7,2,4,5,9];
        // 升序
        var result3 = arr3.sort(function(a,b){
            // a表示后一个成员，b表示后一个成员
            // console.log(a,b);
            return a - b;
        })
        console.log('result3',result3,'arr3:',arr3);

        var arr4 = [0,1,7,2,4,5,9];
        // 降序
        var result4 = arr4.sort(function(a,b){
            // a表示后一个成员，b表示后一个成员
            // console.log(a,b);
            return b - a;
        })
        console.log('result4',result4,'arr4:',arr4);
        
        //乱序：随机返回正负1
        // random方法：随机返回一个[0,1)之间的随机数
        var arr5 = [0,1,7,2,4,5,9];
        var result5 = arr5.sort(function(a,b){
            return Math.random() >=0.5 ?  1: -1;
        })
        console.log('result5',result5,'arr4:',arr5);

运行结果：

数组转字符串

        var arr = ['春', '夏', '秋', '冬'];
        // 转成字符串
        var result = arr.join();
        // 等价形式
        var result2 = arr.join(',');
        console.log(result,arr);
        // 参数表示连接符号
        var result1 = arr.join('--');
        console.log(result1);
        // 空字符串连接，表示字符直接相连
        var result3 = arr.join('');
        console.log(result3);

运行结果：