首页 > 编程语言 > 详细

原生JS数组的内置方法--记录

时间:2021-01-05 22:23:07      阅读:3      评论:0      收藏:0      [点我收藏+]

1、数组转为字符串

    join    连接符,将数组的元素连接为字符串                                                  他的使用不会影响原数组

   eg:let haha = [1, 2, 3, 4, 5, 6, 7, 8]
        console.log(haha.join(‘‘));         //‘12345678‘
        console.log(haha.join(‘&‘));       //‘1&2&3&4&5&6&7&8‘
        console.log(haha.join());          //‘1,2,3,4,5,6,7,8‘  不穿参数默认用逗号隔开
 
2、数组添加元素
   a、unshift   向数组的开始添加元素,并返回新的长度                                     他的使用会影响原数组
   b、push      向数组的末尾添加元素,并返回新的长度                                     他的使用会影响原数组
   c、splice     添加、删除、替换集一身的方法                                                   他的使用会影响原数组
 
 eg:  let haha = [1, 2, 3, 4, 5, 6, 7, 8]
        let newhaha = haha.unshift(0)
        console.log(newhaha);                //9  返回是添加后的长度

 eg:  let heihei = [1, 2, 3, 4, 5, 6, 7, 8]
        let newheihei = heihei.push(9)
        console.log(newheihei);              //9  返回是添加后的长度
 
        console.log(haha, heihei);           //[0, 1, 2, 3, 4, 5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8, 9]
 eg:  //删除
        let haha = [1, 2, 3, 4, 5]
        console.log(haha.splice(1, 3));  //从索引为1开始截取,截取3位      [2, 3, 4]
        console.log(haha);               //[1, 5]

        // 替换,原理为先删除后插入
        let haha1 = [1, 2, 3, 4, 5]
        console.log(haha1.splice(1, 3, ‘11‘, ‘22‘, ‘33‘));   //从索引为1的位置开始删除(含1),删除3位并替换为‘11‘,‘22‘,‘33‘   [2, 3, 4]
        console.log(haha1);                                  //[1, "11", "22", "33",5]

        // 插入
        let haha2 = [1, 2, 3, 4, 5]
        console.log(haha2.splice(4, 0, 6, 7, 8));      //[]      从索引为4的位置上,删除0位,添加6,7,8
        console.log(haha2);                            //[1,2,3,4,6,7,8,5]
 
3、数组删除元素
  a、pop           删除数组的最后一个元素                            他的使用会改变原数组
  b、shift          删除数组的第一个元素           他的使用会改变原数组
  c、splice        请查看第2点
 
  eg: let haha = [1, 2, 3, 4, 5]
        console.log(haha, haha.pop());           //[1, 2, 3, 4]   5
 
  eg: let heihei = [1, 2, 3, 4, 5]
        console.log(heihei, heihei.shift());       //[2, 3, 4, 5]   1
 
4、数组降维
  flat()                 数组降维                                                                                   他的使用不会改变原数组
         如果值为Infinity无论是几维数组,直接降为一维,一般使用它
    如果值为1,降一维下来; 如果值为2,降两维下来;降维方式从2--n的方式往下降           
 
    eg: let haha = [1, 2, 3, [22, 33, 44, [31, [999, 333, 888, 666]]]]
        console.log(haha.flat(Infinity));     //[1, 2, 3, 22, 33, 44, 31, 999, 333, 888, 666]
 
5、截取指定部分数组
  a、slice           选取数组的一部分(根据索引),返回一个新数组                   他的使用不会影响原数组
  b、splice         请看第2点
 
 eg:  let haha = [1, 2, 3, 4, 5]
        console.log(haha.slice(2, 4));       //前闭后开,含索引2不含索引4               [3,4]
 
6、查找指定元素
 
 
  a、includes( )          是否含有指定元素             值是布尔值 (true/false)                                                                     他的使用不会影响原数组
  b、find( )                 查找目标元素,值为多个的话返回找到的第一个元素,找不到undefined                                    他的使用不会影响原数组
  c、findIndex( )        查找目标元素的索引,返回他的索引值,值为多个返回找到的第一个索引值,找不到返回-1      他的使用不会影响原数组
  d、indexOf              查找数组中的元素,并返回它所在位置的索引(有多个返回第一个),顺序是从左至右            他的使用不会影响原数组
  e、lastIndexOf        查找数组中的元素,并返回它所在位置的索引(有多个返回第一个),顺序是从右至左     他的使用不会影响原数组
 
  eg: let haha = [1, 2, 3, 4, 5]
        console.log(haha.includes(3));        //true    含有
        console.log(haha.includes(8));        //false   不含有
 
  eg: let haha = [1, 2, 3, 4, 5]
        let newhaha = haha.findIndex(function (item, index, haha) {
            return item > 3
        })
        console.log(newhaha);        //3   第一个大于3的索引
 
        let newhaha1 = haha.find(function (item, index, haha) {
            return item > 3
        })
        console.log(newhaha1);       //4  第一个大于3的元素
 
  eg: let haha = [1, 2, 3, 4, 5, 3, 6, 7, 8, 9, 3]
        console.log(haha.indexOf(3));               //2
        console.log(haha.lastIndexOf(3));         //10
 
7、合并数组
  concat        连接两个或多个数组,并返回一个新的数组                                  他的使用不会影响原数组
 
  eg: let haha = [1, 2]
        let haha1 = [1, 2, 3, 4]
        console.log(haha.concat(haha1));            //[1, 2, 1, 2, 3, 4]
 
8、数组排序(正序、倒序)
  a、reverse          倒序,逆序                                                             他的使用会影响原数组
  b、sort( )             数组的排序,根据返回值的不同可正序也可逆序             他的使用会影响原数组
 
  eg: let haha = [1, 2, 3, 4, 5]
        let newhaha = haha.reverse()
        console.log(newhaha, haha);          //  [5, 4, 3, 2, 1]       [5, 4, 3, 2, 1]
 
  eg: //正序
   let haha = [5, 6, 7, 1, 2, 3, 6, 5, 4]
        let result = haha.sort(function (a, b) {
            return a - b
        })
        console.log(result);               //[1, 2, 3, 4, 5, 5, 6, 6, 7]
  //逆序
        let haha1 = [5, 6, 7, 1, 2, 3, 6, 5, 4]
        let result1 = haha.sort(function (c, d) {
            return d - c
        })
        console.log(result1);              //[7, 6, 6, 5, 5, 4, 3, 2, 1]

9、数组内置方法涉及循环遍历
  a、forEach         数组循环遍历
  b、map              通过指定的return条件返回新的数组
  c、filter              根据指定条件筛选数组元素,并返回符合条件所有元素的新数组
  d、every            检测数值元素的每个元素是否都符合条件,所有都符合返回true,否则false;遇见false直接结束,后面不会再循环
  e、some            检测数组元素中是否有元素符合指定条件,有一项或以上的返回true,结果就位true;都为false值才为false
 
  eg: let haha = [1, 2, 3, 4, 5]
        haha.forEach(function (item, index, haha) {
            console.log(item);  //item是数组的每一项元素  Index是数组的索引值   haha是数组
        })
 
  eg:let haha = [1, 2, 3, 4, 5]
        let age = haha.map(function (item, index, haha) {
            return item + 1
        })
        console.log(age);             //[2, 3, 4, 5, 6]
 
  eg:let haha = [1, 2, 3, 4, 5]
        let age = haha.filter(function (item, index, haha) {
            return item > 3
        })
        console.log(age);             //[4, 5]
 
   eg:let haha = [1, 2, 3, 4, 5]
        let age = haha.every(function (item, index, haha) {
            return item > 3
        })
        console.log(age);             //false
        let age1 = haha.every(function (item, index, haha) {
            return item > 0
        })
        console.log(age1);             //true
 
   eg:let haha = [1, 2, 3, 4, 5]
        let age = haha.some(function (item, index, haha) {
            return item > 3
        })
        console.log(age);            //true
        let age1 = haha.some(function (item, index, haha) {
            return item > 5
        })
        console.log(age1);           //false
 
10、数组的长度
  length
 
   eg:let haha = [1, 2, 3, 4, 5]
        console.log(haha.length);             //5
 

原生JS数组的内置方法--记录

原文:https://www.cnblogs.com/Lilianyang/p/14237721.html

(0)
(0)
   
举报
评论 一句话评论(0
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号