数组-操作方法

js 数组操作方法总结

去重

方法一
相当于双层 for 循环，时间复杂度 O(n²)

function uniq(){
    return arr.reduce((result, item) => {
        console.log('111', result)
        if (result.indexOf(item) === -1) {
            result.push(item)
        }
        return result

    }, [])
}

function uniq(arr) {
    var result = [];
    for (var i = 0; i < arr.length; i++) {
        if (!result.includes(arr[i])) {
            result.push(arr[i])
        }
    }
    return result
}

方法二
ES6 的 Set 结构

function uniq(arr) {
    let obj = {};
    arr.forEach(item => obj[item] = item)
    return Object.values(obj)
}

方法三
对象 key 的唯一，时间复杂度 O(n)


function uniq(arr) {
    let resultObj = {};
    arr.forEach((item, index)=>{
        resultObj[item] = item;
    })
    return Object.values(resultObj)
}

拉平嵌套数组

es6 中数组的操作方法flat可以返回扁平化的数组，不修改原数组，默认参数是1，只拉平一层嵌套的数组，如果是多层的需要传入层数，最大是Math.pow(2,53)-1

1
2
3

 function flattenDeep(arr, deepLength) {
    return arr.flat(deepLength)
}

2.利用 concat 和 reduce

1
2
3

  function flattenDeep(arr, deepLength) {
    return arr.reduce((pre, val, index) => Array.isArray(val) ? pre.concat(flattenDeep(val)) : pre.concat(val), [])
}

3.stack 无限反嵌套数组

 function flattenDeep(inputArr) {
    const stack = [...inputArr];
    const res = [];
    while (stack.length) {
        let next = stack.pop();
        console.log(next)
        if (Array.isArray(next)) {
            stack.push(...next)
        } else {
            res.push(next)
        }
    }
    return res.reverse()
}

数组遍历

var peoples=[‘Tom’,’Jerry’,’Jack’,’Mary’]

for 循环

ES5

for(let i =0; i<peoples.length; i++){
    let people=peoples[i];
    console.log(people)
}

for…in

for(let i in peoples){
    let people=peoples[i];
    console.log(people)
}

for…of

1
2
3

for(let people of peoples){
    console.log(people)
}

forEach

ES6

1
2
3

peoples.forEach(people=>{
    console.log(people)
})

map

将数组映射成另一个数组，返回新数组。
如果没有return，默认返回undefined。

1 2	let new_peoples=peoples.map(people=>({name:people,age:10})) //[{name:'Tom',age:10},{name:'Jerry',age:10},{name:'Jack',age:10},{name:'Mary',age:10}]

filter

返回数组中符合条件的元素组成新数组。

1
2
3

let peoples=[{name:'Tom',age:10},{name:'Jerry',age:11},{name:'Jack',age:11},{name:'Mary',age:10}]
let new_peoples=peoples.filter(people=>people.age===10);
//[{name:'Tom',age:10},{name:'Mary',age:10}]

find

参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为 true 的成员，然后返回该成员。如果没有符合条件的成员，则返回 undefined。

1 2	let peoples=[{name:'Tom',age:10},{name:'Jerry',age:11},{name:'Jack',age:11},{name:'Mary',age:10}] peoples.find(people=>people.age===10);//[{name:'Tom',age:10}]

every

数组中是否每个元素都满足指定的条件
返回Boolean

1 2	peoples.every(people=>people.age>10)//false peoples.every(people=>people.age>9)//true

some

数组中是否有元素满足指定的条件
返回Boolean

1 2	peoples.some(people=>people.age>10)//true peoples.some(people=>people.age<10)//false

reduce

求和

let arr=[1,2,3,4];
let sum =arr.reduce((prev,cur,index,arr)=>{
 return prev+cur
},0)
sum //10

prev：第一项的值或上一次叠加的结果值
cur：当前会遍历的值
index：当前值的索引
arr：数组本身
传入参数 0，叠加的初始值
如果不传入参数，第一个 prev 就是第一项的值，cur 是第二项的值，如果传参，第一个 prev 就是传入参数，cur 就是数组第一项的值。
传入参数的类型决定 reduce 最终结果

计算字符串中字母出现的次数

var str='asdaaddad';
str.split('').reduce((res,cur)=>{
    res[cur]?res[cur]++:res[cur]=1;
    return res
},{});

Array.from()

将类数组转化为数组。
类数组：一个对象的所有键名都是正整数或零，并且具有length属性，例如 arguments,DOM 元素集，字符串。
参数：

obj：要转换的对象
map：类似数组的 map 方法，用来对每个对象进行处理，处理后返回一个数组
context：绑定 map 中用到的this
只要是部署了 iterator 接口的数据结构，Array.from 都能将其转为数组:

let arr=Array.from('Hello');//['H','e','l','l','o'];
Array.from('123',(x)=>x*x);//[1,4,9]
//等同于
[1,2,3].map(x=>x*x);//[1,4,9]

Array.from()可以将各种值转为真正的数组，并且还提供map功能。这实际上意味着，只要有一个原始的数据结构，你就可以先对它的值进行处理，然后转成规范的数组结构，进而就可以使用数量众多的数组方法。

1	Array.from({ length: 2 }, () => 'jack')// ['jack', 'jack']

Array.of(v1,v2,v3)

将传入的所有参数转换为一个数组，而不管参数的数量与类型。

1 2	Array.of(1,'1','a',true,{a:1}) //[1, "1", "a", true, {a:1}]