数组方法

陈宏章
320 阅读7分钟

给数组增加项的方法

var ary =[1,2,3]

  • 利用数组的length属性给数组向末尾增加
    • ary[ary.length]=4;给数组末尾增加数字4
  • push方法：给数组的的末尾增加，传参多项就增加多项
    • push的返回值是改变后的数组长度
var ary = [1, 2, 3];
ary.push("push进来的",2,3,4);
  console.log(ary);[1, 2, 3, "push进来的", 2, 3, 4]  length: 7
  • unshift向数组的开头增加，传参几项，就增加几项
    • 会改变原有数组的索引
    • unshift的返回值是改变后数组的长度
ary.unshift("我是unshif增加进来的",8)
会在数组的前面增加

给数组删除项的方法

  • pop 删除数组最后一项
    • pop的返回值是被删除的那一项
    • 会改变数组原有的索引
var ary1 = [4, 5, 6];
 var res=ary1.pop();
console.log(res);的输出结果是6
  • shift 删除数组中的第一项
    • 会改变数组原有项的索引
    • 返回值是被删除的那一项
 var ary1 = [4, 5, 6];
console.log(ary1);
console.log(ary1.shift());  结果是4
  • delete 删除键值对的方式，也可以删除数组中的对应项
    • 不会改变数组中原有项的索引
delete ary1[1];
[4, empty, 6]
//length还是3；
  • length==删除数组中的最后一项
    • 这里用操作length来改变数组
    • 输出取决--的位置

splice 增删改都可以

第一个参数表示从哪个索引开始，第二个参数表示要删除几项，从第三个参数开始表示增加的项

  • splice(n,0,x)当第二个参数为0时，就是不删除，并且有第三项，就是增加，是在索引n的前面增加
  • splice（n,m）从索引n开始删除m个元素，返回结果是以新数组的方式，把删除的内容进行存储
  • splice（n，m，x）从索引n开始删除m个元素,增加的元素放在索引n处
  • 返回值是数组，内容是被删除的项
  • ary2.splice(0,0,"增加的项");从索引0开始不删除并且有第三项参数就是在第一项增加
  • ary2.splice(0,1,"修改的项");从索引0开始的位置删除一个元素，并把第三个元素添加到这个位置

验证某一项是不是在数组中

  • var ary2 = ["陈", "宏", "章","陈"];

indexOf 验证某一项是不是在该数组，返回值如果是负一就不在数组里，从前往后找； 如果在数组中会返回对应的索引

var res2 = ary2.indexOf("小明");//如果数组中没有这一项输出的结果是-1
var res2 = ary2.indexOf("陈");//=>0

lastIndexOf 从后往前找

var res3=ary2.lastIndexOf("陈");//=>3
 console.log(res3);//输出结果是3  因为是从后向前查找，最后一个陈的索引是3所以输出结果是三

includes验证该项有没有在数组里

有返回true，没有返回false

var res4 = ary2.includes("陈")

console.log(res4);

不改变原数组的方法

  • concat数组的拼接，把多个数组（或多个值）最后拼接为一个数组，原始的数组都不会变，返回结果是拼接后的新数组
    • var ary1=[4,5,6,"陈"];
    • 如果参数是个数组，会扒掉数组的一层[]
    • 可以传多个参数，都拼接在一起
    • var res=ary1.concat(["宏","章"]);
    • 什么参数都不传就是数组的克隆
      • var res =ary1.concat(); 输出结果是[4,5,6,"陈"]
  • slice（n，m）从索引n开始复制到索引m处（不包括索引m）把查找到的内容以新数组方式返回，原始数组不会改变。
var ary =[1,2,3,4,5,6];
var res =ary.slice(0,4);
 console.log(ary);//输出原数组
 console.log(res);//输出[1,2,3,4],从索引0开始复制到索引4处，不包括索引4
  • slice(-3,-2)
    • 从索引（-3+length）到（-2+length）不包括-2+length
var ary =[1,2,3,4,5,6];
var res =ary.slice(-3,-2);
 console.log(ary);//输出愿数组
 console.log(res);//输出4，因为6-3=3，6-2=4（3，4）
  • 克隆数组
    • var res =ary.slice(0)，可以理解为把原始数组中的每一项都查找到，以新数组返回，实现数组的克隆，得到的新数组和原始数组是两个不同的堆，但是存储的内容是一样的
    • console.log(ary);
    • console.log(res);
    • 如果第二个参数比length大则直接到末尾

把数组转化为字符串：

  • toString();把数组中的每一项按照“逗号分隔”，拼接成对应的字符串，原始数组不会改变
let arr =[10,20,30,40,50,60,70]
console.log(arr.toString());//输出结果为'10,20,30,40,50,60,70'
  • join（[char]）；指定分隔符
    • join用字符把数组中的每一项拼接在一起，返回是字符串
  var arr =[1,2,3]
        // join用字符把数组中的每一项拼接在一起，返回是字符串
        var res =arr.join("+");
        // var res =arr.join();//如果不传参，默认用逗号拼接在一起，相当于toString（）
        console.log(res);
  • eval可以让字符串变成表达式执行
    • 如果上边的字符串能够变成JS表达式执行，则代表数组每一项的求和
 eval 可以让字符串变成表达式执行
   console.log(eval(res))

数组排序

  • reverse把数组中的每一项倒过来排序
  • 给数组排序
  • 在没有传参的情况下，只会根据第一位来排序
  • 数字按照从小到大排
  • 字母按照编码顺序
     console.log(res);


        var res2=ary.sort((a,b)=> {

            console.log(a,b);
            return a-b;//升序
            // return b-a;//降序
        })
        console.log(ary,res2);

        var arrobj=[            {name:"q",age:12},            {name:"qw",age:22},            {name:"er",age:11},            {name:"sdf",age:1}        ];
        arrobj.sort((a,b)=>{
            return a.age-b.age;
        })
        console.log(arrobj);

字符串的方法

  • indexOf
  • lastindexOf
  • includes
  • substr(n,m)从索引n开始截取m个字符，不支持负数
  • slice(n,m)从索引n开始截取到索引m，不包括m,支持负数
  • substring(n,m)从索引n开始截取到索引m，不包括m
var str2 = '一家人倒计时';
   var res = str2.substr(0, 3);
   var res1 = str2.substring(2, 5);
   var res2 = str2.slice(2, 5);
   console.log(res1,res,res2)

获取字符串相关索引的字符

  • charAt 获取字符串相关索引的字符
  • charCodeAt获取字符串相关索引的字符，在把字符转成ASCII表里的数字
  • String.fromCharCode 把ASCII表里的数字转成字符
var str ='一家人就要整整七七'
        var res =str.charAt(0);
        var res1 =str.charCodeAt(0);
        console.log(res1);
        console.log(String.fromCharCode(19968));
        console.log(str[0]);

字母转大写

  • toUpperCase()所有字母转成大写
  • toLowerCase()所有字母转成小写
var abc='abcdefg';
        console.log(abc.toUpperCase());
        console.log(abc.toLowerCase());

实现首字母大写

  • 1.先拿到首字母，然后转成大写
  • 2.拿到除了首字母的剩余字符，然后拼接到一起
var res =abc.substring(0,1).toUpperCase()+abc.substring(1);
        console.log(res);

指定字符把字符串拆分成数组中的每一项

\

\

       // split  一指定字符把字符串拆分成数组中的每一项
        // var str ='1+2+3';
        // var res =str.split("+");//【1，2，3】
        // console.log(res);

        var str2 ='https://www.baidu.com/s?wd=JS&rsv_spt=1&a=1&b=2'
        var res4 = str2.split("?");
        var ary =res4[1].split("&");
        // console.log(ary);
        var obj={};
        ary.forEach((item,index)=>{
            // item 是数组中的每一项
            // index 是该项索引
            // console.log(item,index);
            var inner =item.split('=');
            // var shuxingming=inner[0];
            // var shuxingzhi=inner[1]
            // obj[shuxingming]=shuxingzhi;
            obj[inner[0]]=inner[1];
            console.log(obj);
        })

数组中常用的迭代方法

  • foreach([函数])
    • 遍历数组中的每一项（数组中有多少项，函数会相继被执行多少次，每一次执行函数，都可以在函数中获取到当前遍历的这一项和对应的索引）
arr.forEach(function(item,index){
    //此函数会被循环执行五次（数组中有五项）
    //item:当前遍历这一项的内容
    //index：当前项的索引
console.log(item,index)

})

数组求和的方式

  • join
let arr =[10,20,30,40,50]
console.log(eval(arr.join('+')));//如果数组中出现非有效数字，则最后结果是NaN
  • 通过for循环
let total=0;
for(let i=0;i<arr.length;i++){
                  total+=arr[i];
   }
 console.log(total)
  • forEach方法
let total=0;
arr.forEach(function(item.index){
item =Number(item);
if(isNaN(item)===false){
total+=item;

}
})
console.log(total);
  • map 方法:forEach是不支持返回值的，而map可以在forEach的基础上支持返回值,把原来数组中每一项的值替换称为新值，最后存储在一个新的数组中，但是原始数组是不变的
let arr =[10,20,30,40,50];
let reault=arr.map(function(item,index){
    //此函数会被循环执行五次（数组中有五项）
    //item:当前遍历这一项的内容
    //index：当前项的索引

//函数中返回啥，都是把数组中当前项替换成啥
return item;
})
console.log(result);
avatar
文章
阅读
粉丝