面试利器原生JS灵魂拷问，你能答上多少(三）

Posted 2021-11-10 战场小包

前言

目前的前端世界，三大框架横行，原生javascript所用越来越少。但我认为JavaScript作为每一个前端工程师的立身之本，学再多遍都不为过。

因此我决定整理JavaScript中容易忽视或者混淆的知识点，写一系列文章，以灵魂拷问的方式，系统且完整的带大家遨游基础的的JavaScript，给大家带来不一样的体验。

系列文章链接：

• 【面试利器】原生JS灵魂拷问，你能答上多少(一)
• 【面试利器】原生JS灵魂拷问，你能答上多少(二)

JavaScript数组之问

第二十七问：那些数组方法会修改原数组吗？那些不会？

这是一个比较重要的考点，我在看牛客的前端面试题时，该问题反复出现。

1. 改变自身值的方法(共9个)

pop push shift unshift splice sort reverse
// ES6新增
copyWithin
fill

2. 不改变自身值的方法

join // 返回字符串
forEach // 无返回值
concat map filter slice // 返回新数组
every some // 返回布尔值
reduce // 不一定返回什么
indexOf lastIndexOf // 返回数值(索引值)
// ES6新增
find findIndex

第二十八问：shift 与 unshift 的返回值是什么？

1. unshift() 在数组开始处插入元素，shift() 删除数组第一个元素
2. 关于两者返回值，直接上测试代码:

const arr = [1,2,3,4,5]
undefined
console.log(arr.unshift(0)) // 6
console.log(arr.shift()) // 0

由上述代码可知：unshift返回插入元素后的新数组元素个数，shift返回删除的元素值。

那么可以类比推理一下，push返回的是插入元素的新数组元素格式，pop返回删除的元素值。

第二十九问：new Array() 与 Array.of() 的区别是什么？

1. Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。这好像跟 new Array 的功能极度接近，为什么 ES6 添加了新方法那？

原因就在于 new Array(n) ，只有一个参数时，构造的并非只含 n 的数组，而是 1*n 的数组，值全为 undefined。具体看测试：

Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

第三十问：你能灵活运用 splice() 方法吗？splice() 的返回值是什么？

1. 基本使用
   语法：

array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

参数：

• start​: 指定修改的开始位置（从0计数）
• deleteCount (可选): 整数，表示要移除的数组元素的个数。
• item1, item2... (可选): 添加到数组的元素

返回值：由被删除的元素组成的一个数组，没有删除返回空数组。
2. 数组中插入元素

数组中只提供了在数组头尾插入与删除的方法，没有提供在中间位置插入的方法，但可以通过将 deleteCount 设置为0，来实现插入效果。

const arr = [1,2,3,4,5]
console.log(arr.splice(2,0,100)) // []
console.log(arr) // [1, 2, 100, 3, 4, 5]

第三十一问：splice() 删除元素时有没有要注意的地方？

大家看到这个问题，可能会感觉有几分蒙，没遇到过应该比较难想到，我来假设一个场景大家就懂了。

现在有这样一个数组 [1,-1,2,-1,-5]，我想删除掉所有的负数，于是我就写出了下面的代码：

const arr = [1,-1,-2,1,-5]
for(let i = 0; i<arr.length; i++) {
    if (arr[i] < 0) {
        arr.splice(i, 1)
    }
}
console.log(arr) // [1, -2, 1]

这就奇怪了，为啥 -2 没被删除掉？我在上面的代码加一句打印，大家应该就懂了。

for(let i = 0; i<arr.length; i++) {
    if (arr[i] < 0) {
        arr.splice(i, 1)
        console.log(a[i]) // -2 undefined
    }
}

数组删除 -1 之后，当前的 i 值为 -2，此次遍历结束，i++，正好空过了 -2 元素。因此如果splice删除元素发生在数组中，一定要注意回调i的位置。

第三十二问：你会使用 reduce() 吗？

1. 累加累乘

function Accumulation(...vals) {
    return vals.reduce((t, v) => t + v, 0);
}

function Multiplication(...vals) {
    return vals.reduce((t, v) => t * v, 1);
}

2. 代替 reverse

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}

3. 数组扁平化

function Flat(arr = []) {
    return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
}

4. 反转字符串

[..."hello world"].reduce((a, v) => v + a)
[..."hello world"].reverse().join('')

5. 验证括号是否合法

// 这是一个十分巧妙的用法，如果结果等于0说明，括号数量是合法的。
[..."(())()(()())"].reduce((a,i)=> i === '(' ? a+1 : a-1 , 0);

第三十三问：map、filter、every、some 如何使用？

1. map(): 创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。其中原始数组不会发生改变。

// 返回numbers的平方根
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt); // [1, 2, 3]

2. filter(): 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

// 筛选排除所有较小的值
function isBigEnough(element) {
  return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); // filtered is [12, 130, 44]

3. some：用于检测数组中的元素是否满足指定条件。

   • 如果有一个元素满足条件，则表达式返回 true, 剩余的元素不会再执行检测
   • 如果没有满足条件的元素，则返回 false

// 检测在数组中是否有元素大于 10
function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

4. every: 检测数组所有元素是否都符合指定条件.

   • 如果数组中检测到有一个元素不满足，则整个表达式返回 false，且剩余的元素不会再进行检测
   • 如果所有元素都满足条件，则返回 true

// 检测在数组中元素是否都大于 10
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

第三十四问：数组有多少种遍历方式，各自的效率如何？

第三十五问：如何实现数组乱序？

1. Math.random

提到乱序，大家首先会想到使用 Math.random，比如下面代码：

var values = [1, 2, 3, 4, 5];

values.sort(function(){
    return Math.random() - 0.5;
});

console.log(values)

Math.random() - 0.5 随机得到一个正数，负数或者0，之后通过sort实现乱序。

但这种方法的效果其实并不如人意，具体测试可参考博客：JavaScript专题之乱序

2. Fisher–Yates洗牌算法

function shuffle(a) {
    var j, x, i;
    for (i = a.length; i; i--) {
        j = Math.floor(Math.random() * i);
        x = a[i - 1];
        a[i - 1] = a[j];
        a[j] = x;
    }
    return a;
}

第三十六问：你知道多少种数组去重的方法吗？

1. 解法一：使用双重 for 和 splice

function unique(arr){            
    for(var i=0; i<arr.length; i++){
        for(var j=i+1; j<arr.length; j++){
            if(arr[i]==arr[j]){         
            //第一个等同于第二个，splice方法删除第二个
                arr.splice(j,1);
                // 删除后注意回调j
                j--;
            }
        }
    }
return arr;
}

2. 使用 indexOf 或 includes 加新数组

//使用indexof
function unique(arr) {
    var uniqueArr = []; // 新数组
    for (let i = 0; i < arr.length; i++) {
        if (uniqueArr.indexOf(arr[i]) === -1) {
            //indexof返回-1表示在新数组中不存在该元素
            uniqueArr.push(arr[i])//是新数组里没有的元素就push入
        }
    }
    return uniqueArr;
}
// 使用includes
function unique(arr) {
    var uniqueArr = []; 
    for (let i = 0; i < arr.length; i++) {
        //includes 检测数组是否有某个值
        if (!uniqueArr.includes(arr[i])) {
            uniqueArr.push(arr[i])//
        }
    }
    return uniqueArr;
}

3. sort 排序后，使用快慢指针的思想

function unique(arr) {
    arr.sort((a, b) => a - b);
    var slow = 1,
        fast = 1;
    while (fast < arr.length) {
        if (arr[fast] != arr[fast - 1]) {
            arr[slow ++] = arr[fast];
        }
        ++ fast;
    }
    arr.length = slow;
    return arr;
}

sort 方法用于从小到大排序(返回一个新数组)，其参数中不带以上回调函数就会在两位数及以上时出现排序错误(如果省略，元素按照转换为的字符串的各个字符的 Unicode 位点进行排序。两位数会变为长度为二的字符串来计算)。
4. ES6 提供的 Set 去重

function unique(arr) {
    const result = new Set(arr);
    return [...result];
    //使用扩展运算符将Set数据结构转为数组
}

Set 中的元素只会出现一次，即 Set 中的元素是唯一的。
5. 使用哈希表存储元素是否出现(ES6 提供的 map)

function unique(arr) {
    let map = new Map();
    let uniqueArr = new Array();  // 数组用于返回结果
    for (let i = 0; i < arr.length; i++) {
      if(map.has(arr[i])) {  // 如果有该key值
        map.set(arr[i], true); 
      } else { 
        map.set(arr[i], false);   // 如果没有该key值
        uniqueArr.push(arr[i]);
      }
    } 
    return uniqueArr ;
}

map 对象保存键值对，与对象类似。但 map 的键可以是任意类型，对象的键只能是字符串类型。

如果数组中只有数字也可以使用普通对象作为哈希表。
6. filter 配合 indexOf

function unique(arr) {
    return arr.filter(function (item, index, arr) {
        //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
        //不是那么就证明是重复项，就舍弃
        return arr.indexOf(item) === index;
    })
}

这里有可能存在疑问，我来举个例子：

const arr = [1,1,2,1,3]
arr.indexOf(arr[0]) === 0 // 1 的第一次出现
arr.indexOf(arr[1]) !== 1 // 说明前面曾经出现过1

7. reduce 配合 includes

function unique(arr){
    let uniqueArr = arr.reduce((acc,cur)=>{
        if(!acc.includes(cur)){
            acc.push(cur);
        }
        return acc;
    },[]) // []作为回调函数的第一个参数的初始值
    return uniqueArr
}

第三十七问：你知道类数组如何转化为数组吗？

1. Array.prototype.slice.call()

const arrayLike = {
    0: '111',
    1: '222',
    length: 2
}
console.log(Array.prototype.slice.call(arrayLike)) // ["1", "2"]

2. Array.from()

Array.from 是 ES6 新增的方法，它可以将**类数组对象和可遍历(iterable)**转变为真正的数组。

const arrayLike = {
    0: '1',
    1: '2',
    length: 2
}
console.log(Array.from(arrayLike)) // ["1", "2"]

3. (...)扩展运算符

扩展运算符调用的是遍历器接口，如果一个对象没有部署此接口就无法完成转换。

上面咱们自己写的普通类数组就无法使用…运算符。

const arrayLike = {
    0: '1',
    1: '2',
    length: 2
}
// Uncaught TypeError: arrayLike is not iterable
console.log([...arrayLike]) // ["1", "2"]

如果部署了遍历器接口，例如 arguments 类数组，便可以使用扩展运算符。

function fn() {
    console.log([...arguments])
}
fn(1,2,3) // [1, 2, 3]