数组的常见操作方法

数组的常见操作

let arr = [1,4,5,7,9];

 

1. 判断数组中某个元素是否存在  

 para1:待判断的元素

 返回值：元素在数组中的索引，如果不存在，返回-1

 let isExist = arr.indexOf(4) !=-1;

2、向数组中追加元素

 para1:要追加的元素

 返回值是数组的长度;

arr.push(100);

 

 3、在数组的开头添加元素

 para1:待添加的元素

返回值是数组的长度

场景：下拉刷新

arr.unshift(-2);

 

 4、删除数组结尾的元素

 无参数

 返回值是删除的元素

let e= arr.pop();

console.log(e);//100

 

5、删除数组开头的元素

返回值是删除的元素

arr.shift();

 

6、从数组中删除一些元素，插入一些元素;

 para1:开始索引

para2：删除元素的数目（开始索引是删除的起始位置）

para3...:要插入的元素（开始索引也就是插入的位置，可以插入多个）

 场景：用新元素替换旧数组的一个元素

返回值是被删除的元素构成的数组;

console.log(arr)

let de= arr.splice(1,2,1000,200);

 可以删可以加

 

 7、获取一个子数组

para1:开始位置;包含开始

para2:结束位置;不包含结束 [start,end);

返回值是子数组;

let s= arr.slice(1,3);

console.log(s);

 

 8、数组的拼接

console.log(arr);

let arr2=[-1,-2,90];

para1.....:待拼接的数组(可以拼接多个)

返回值拼接之后的新数组;（arr）原数组不受影响

let c= arr.concat(arr2);

console.log(c);

console.log(arr);

弱类型语言可以多个参数,强类型的参数是固定的

 9、数组的遍历

参数： 元素，索引，所在的数组

para1:操作函数

       para1:元素

        para2:索引

        para3：元素所在的数组

arr.forEach((item,index,array)=>{

    console.log(item)

    console.log(index)

    console.log(array)

    // 想要进行的操作：无明确要求

})

 

10、数组的映射

para1:操作函数

         para1:元素

         para2:索引

         para3:元素所在的数组

         返回值是该元素映射的新元素（一一对应）

 返回值是映射得到的新数组
 

let m= arr.map((item,index,array)=>{

    return item*3;

})

console.log(m);



let stus = [

    {name:'lucy',age:20},

    {name:'lily',age:21},

    {name:'小兰',age:20},

]

let stuNames = stus.map((item)=>{

    return item.name;

})

console.log(stuNames);

 11、数组的聚合

 para1:操作函数

         para1:旧值;上一次聚合的结果;

         para2:当前元素

         para3：当前元素的索引

         para4:当前元素所在的数组

         返回值：该次聚合的结果

 para2:聚合时使用的初值（0加，1乘）

 返回值是 聚合后的数据

let rd=arr.reduce((preValue,curValue,curIndex,array)=>{

    console.log('1111111111111');

    // console.log(preValue);

    // console.log(curValue);

    console.log(curIndex);

    // console.log(array);

    return preValue+curValue;

},0)

console.log(rd);



// [1,10000,200,7,9]

// 初值：0 

// 第一次    0     1    0      1 

// 第二次    1    10000  1     10001

// 第三次  10001  200    2    10201

// 第四次  10201  7      3     10208

// 第五次  10208  9      4     10217 

// 返回值是 10217



// 计算每个字母出现的频率

let str ='fsadfasdfagagajkgnahjgasdjfajsfjk';

let strArr=str.split('');

console.log(strArr);

let sr=strArr.reduce((preValue,curValue,curIndex,array)=>{

    if(!preValue[curValue]){

        preValue[curValue]=0;

    }

    preValue[curValue] +=1;

    console.log(preValue);

    return preValue;

},{})

console.log(sr);

 

12、数组过滤

 para1:操作函数

         para1:元素

         para2:索引

         para3:元素所在的数组

         返回值 true/false ; true:满足条件；false:不满足条件

返回值是 满足过滤条件的新数组

let fa = arr.filter((item,index,array)=>{

    return item%2==0;

})

console.log(fa);

 

13、数组排序

 para1：操作函数

     para1:数组中一个元素

     para2:数组中另一个元素

     返回值是true/false;

 返回值排序后的新数组

let sortedArr=arr.sort((num1,num2)=>{

    return num1>num2;//升序

    // return num1<num2;//降序

});

console.log(sortedArr);



let goods=[

    {name:"裙子",price:37,sales:10000},

    {name:'裙子',price:100,sales:100},

    {name:'裙子',price:340,sales:102},

    {name:'裙子',price:734,sales:16},

    {name:'裙子',price:1235,sales:10},

    {name:'裙子',price:3214,sales:6},

    {name:'裙子',price:777,sales:60},

]

let sortedGoods=goods.sort((obj1,obj2)=>{

    console.log(obj1.price);

    return obj1.price<obj2.price;

})

console.log(sortedGoods);

14、判断一个变量是不是数组

 返回值是true或者false

let a=1;

// let a=[1,2];

console.log(Array.isArray(a)); //Array是一个类

console.log(a instanceof Array);//instanceof 关键字

 

 数组中最大的元素

let arrt1=[1,5,6,43,99,42,3];

// 第一种方法。数组中不能有重复元素，推荐第二种

let sor1=arrt1.sort((num,num3)=>{

    return num>num3

})

console.log(sor1);

sort=sor1[0];

sort2=sor1[sor1.length-1];

console.log(sort);

console.log(sort2);



// 第二种方法

let num4;

let str1=arrt1.forEach((item)=>{

    num4=num4>item ? num4 : item

    return num4

})

console.log(num4)