【面试利器】原生JS灵魂拷问，你能答上多少(三）
前言
目前的前端世界，三大框架横行，原生JavaScript所用越来越少。但我认为JavaScript作为每一个前端工程师的立身之本，学再多遍都不为过。
因此我决定整理JavaScript中容易忽视或者混淆的知识点，写一系列文章，以灵魂拷问的方式，系统且完整的带大家遨游基础的的JavaScript，给大家带来不一样的体验。
系列文章链接：
- 【面试利器】原生JS灵魂拷问，你能答上多少(一)
- 【面试利器】原生JS灵魂拷问，你能答上多少(二)
JavaScript数组之问
第二十七问：那些数组方法会修改原数组吗？那些不会？
这是一个比较重要的考点，我在看牛客的前端面试题时，该问题反复出现。
- 改变自身值的方法(共9个)
pop push shift unshift splice sort reverse
// ES6新增
copyWithin
fill
- 不改变自身值的方法
join // 返回字符串
forEach // 无返回值
concat map filter slice // 返回新数组
every some // 返回布尔值
reduce // 不一定返回什么
indexOf lastIndexOf // 返回数值(索引值)
// ES6新增
find findIndex
第二十八问：shift 与 unshift 的返回值是什么？
unshift()在数组开始处插入元素，shift()删除数组第一个元素- 关于两者返回值，直接上测试代码:
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() 的区别是什么？
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() 的返回值是什么？
- 基本使用
语法：
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() 吗？
- 累加累乘
function Accumulation(...vals) {
return vals.reduce((t, v) => t + v, 0);
}
function Multiplication(...vals) {
return vals.reduce((t, v) => t * v, 1);
}
- 代替
reverse
function Reverse(arr = []) {
return arr.reduceRight((t, v) => (t.push(v), t), []);
}
- 数组扁平化
function Flat(arr = []) {
return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
}
- 反转字符串
[..."hello world"].reduce((a, v) => v + a)
[..."hello world"].reverse().join('')
- 验证括号是否合法
// 这是一个十分巧妙的用法，如果结果等于0说明，括号数量是合法的。
[..."(())()(()())"].reduce((a,i)=> i === '(' ? a+1 : a-1 , 0);
第三十三问：map、filter、every、some 如何使用？
map(): 创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。其中原始数组不会发生改变。
// 返回numbers的平方根
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt); // [1, 2, 3]
filter(): 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
// 筛选排除所有较小的值
function isBigEnough(element) {
return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); // filtered is [12, 130, 44]
-
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
-
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
第三十四问：数组有多少种遍历方式，各自的效率如何？
第三十五问：如何实现数组乱序？
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专题之乱序
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;
}
第三十六问：你知道多少种数组去重的方法吗？
- 解法一：使用双重
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;
}
- 使用
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;
}
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
reduce配合includes
function unique(arr){
let uniqueArr = arr.reduce((acc,cur)=>{
if(!acc.includes(cur)){
acc.push(cur);
}
return acc;
},[]) // []作为回调函数的第一个参数的初始值
return uniqueArr
}
第三十七问：你知道类数组如何转化为数组吗？
Array.prototype.slice.call()
const arrayLike = {
0: '111',
1: '222',
length: 2
}
console.log(Array.prototype.slice.call(arrayLike)) // ["1", "2"]
Array.from()
Array.from 是 ES6 新增的方法，它可以将**类数组对象和可遍历(iterable)**转变为真正的数组。
const arrayLike = {
0: '1',
1: '2',
length: 2
}
console.log(Array.from(arrayLike)) // ["1", "2"]
(...)扩展运算符
扩展运算符调用的是遍历器接口，如果一个对象没有部署此接口就无法完成转换。
上面咱们自己写的普通类数组就无法使用…运算符。
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]