Js数组基本问题

总结了最近的一些面试题和之前的知识点

JS判断数组中是否包含某个值

方法一：array.indexOf

此方法判断数组中是否存在某个值，如果存在，则返回数组元素的下标，否则返回-1。

1
2
3
var arr=[1,2,3,4];
var index=arr.indexOf(3);
console.log(index);

方法二：array.includes(searcElement[,fromIndex])

此方法判断数组中是否存在某个值，如果存在返回true，否则返回false

1
2
3
4
5
var arr=[1,2,3,4];
if(arr.includes(3))
    console.log("存在");
else
    console.log("不存在");

方法三：array.find(callback[,thisArg])

返回数组中满足条件的第一个元素的值，如果没有，返回undefined

1
2
3
4
5
var arr=[1,2,3,4];
var result = arr.find(item =>{
    return item > 3
});
console.log(result);

如果元素是对象：

1
2
3
4
5
6
7
8
9
10
var items=[
    {id:1,name:'yxy'},
    {id:2,name:'whc'},
    {id:3,name:'hzj'},
    {id:4,name:'fyq'}
];
var result = items.find(item=>{
    return item.id == 3;
});
console.log(result);

方法四：array.findeIndex(callback[,thisArg])

返回数组中满足条件的第一个元素的下标，如果没有找到，返回**-1**

1
2
3
4
5
var arr=[1,2,3,4];
var result = arr.findIndex(item =>{
    return item > 3
});
console.log(result);

方法五：当然不能忘了养大我们的for循环和if

1
2
3
4
5
6
7
8
9
10
var arr=[1,2,3,4];
var k=0;
for(var i=0;i<arr.length;i++){
    if(arr[i]==3)
        k=1;
}
if(k)
    console.log("存在");
else
    console.log("不存在");

js获取数组中的最大值

  1. es6拓展运算符
1
Math.max(...arr)
  1. es5 apply(与方法1原理相同)
1
Math.max.apply(null,arr)
  1. for循环
1
2
3
4
let max = arr[0];
for (let i = 0; i < arr.length - 1; i++) {
    max = max < arr[i+1] ? arr[i+1] : max
}
  1. 数组sort()
1
2
3
4
arr.sort((num1, num2) => {
    return num1 - num2 < 0
})
arr[0]
  1. 数组reduce
1
2
arr.reduce((num1, num2) => {
    return num1 > num2 ? num1 : num2}

js获取最大值和最小值

  1. 排序法
  2. 假设法 （for 循环前后逐一对比）
  3. Math max() min()
  4. ES

JS求数组的交集、并集、差集

现有两个数组

1
2
let a = [101,201,601]
let b = [201,301,801]

求交集（交集元素由既属于集合a又属于集合b的元素组成）

  1. 方法1 filter includes()
1
let intersection = a.filter(v => b.includes(v)) // [201]
  1. 方法2 filter indexOf()
1
let intersection = a.filter(function(v) { return b.indexOf(v) > -1 }) //[201]
  1. 方法3 filter Set() set.has
1
2
let intersection = Array.from(new Set(a.filter(v=> new Set(b).has(v))))  //[201]

  1. 方法4 
1
let intersection = a.filter(v => new Set(b).has(v))  // [201]

2.求并集 (并集元素由集合a和集合b中所有元素去重组成)

  1. 方法1 filter includes()
1
2
3
4
let union = a.concat(b.filter(v=> {
   return !a.includes(v)
 }
)) // [101, 201, 601, 301, 801]
  1. 方法2 Array.from() Set() concat() (最简单)
1
let union = Array.from(new Set(a.concat(b))) // [101, 201, 601, 301, 801]
  1. 方法3 concat() filter() indexOf()
1
2
3
let union = a.concat(b.filter(function(v) {
    return a.indexOf(v) === -1
})) // [101, 201, 601, 301, 801]

3.求差集 (差集元素由集合a和集合b的并集减去集合a和集合b的交集)

  1. 方法1 (写法最优。indexOf有个对NaN返回-1的问题)
1
let difference = a.concat(b).filter(v => !a.includes(v) || !b.includes(v)))  // [101, 601, 301, 801]
  1. 方法2
1
2
3
let difference = Array.from(new Set(a.concat(b).filter(
  v => !new Set(a).has(v) || !new Set(b).has(v)
))) // [101, 601, 301, 801]
  1. 方法3
1
2
3
4
5
let difference = a.filter(function(v) {
    return b.indexOf(v) === -1
}).concat(b.filter(function(v) {
    return a.indexOf(v) === -1
})) // [101, 601, 301, 801]

JS如何实现数组扁平化？

ES6的flat

1
2
ary = arr.flat(Infinity)
console.log([1, [2, 3, [4, 5]]].flat(Infinity))

Array.protype.flat()用于将数组“拉平”，变成一维数组，返回一个新数组。flat()默认只会拉平一层，flat（n）拉平n层，Infinity无限次。好用归好用，但效率我们就心里明白，这也是我们面试官最不想听到的答案了。

正则处理

1
2
3
4
5
6
7
//第一种处理
ary = str.replace(/(\[|\])/g, '');

//第二种处理
str = str.replace(/(\[|\]))/g, '');
str = '[' + str + ']';
ary = JSON.parse(str);

递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 let arr = [1, [2, [3, 4]]];

 function flattern(arr,result =[]) {

        for(let i = 0; i < arr.length; i++) {
            if(Array.isArray(arr[i])) {
                flattern(arr[i], result)
            } else {
                result.push(arr[i])
            }
        }
        return result;
    }
console.log(flattern(arr));

这也是我当时面试想到最简单的解决方案，思路很简单，通过遍历最外层数组的每一个元素，看看是否还是数组，如果是的话，继续递归执行，不是的话，放到最后的结果数组当中

reduce

1
2
3
4
5
6
7
8
9
10
11
let arr = [1, [2, [3, 4]]];
function flatten(arr) {
    return arr.reduce(function(prev, next){
        return prev.concat(Array.isArray(next) ? flatten(next) : next)
    }, [])
}
console.log(flatten(arr))

//reduce搭配扩展运算符
const flatten = (array) => array.reduce((acc,cur)=>
    (Array.isArray(cur)?[...acc,...flatten(cur)]:[...acc,cur]),[])

提到数组的方法，就会联想到非常常用的2个高阶函数map和reduce。其实思路上和上面递归的很相似。

ES6扩展运算符

1
2
3
4
5
6
7
8
const arr = [1,2,[3,4,5,[6,7],8],9,10,[11,[12,13]]];
const flatten = (arr) => {
    while(arr.some(item=>Array.isArray(item))){
        arr=[].concat(...arr);
    }
    return arr;
}
console.log(flatten(arr)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

由于扩展运算符一次只能展开一层数组

1
2
var arr = [1, [2, [3, 4]]];
console.log([].concat(...arr)); // [1, 2, [3, 4]]

因此考虑只要数组中还有数组，就使用扩展运算符展开一次。

toString

1
2
3
4
5
6
7
function flatten(arr){

    //arr.join(',').split(',');  join也可以实现  
    return arr.toString().split(',').map(function(item){
        return +item;  //+将字符转换为数字
 })
}

如果数组的元素都是数字，可以考虑使用 toString 方法，因为：toString会将数组中的数以逗号形式结合起来。toString之后再split转成数组，并将其转换回数字。所以这种场景只适用于数组内全部是数字的情况，因为中间是全部转换为字符串了。

参考文章

🔥🔥JS如何实现数组扁平化？不同的方法有什么区别？