前端面试js高频手写大全(上)



介绍

在前端面试中,手撕代码显然是不可避免的,并且占很大的一部分比重。

一般来说,如果代码写的好,即使理论知识答得不够清楚,也能有大概率通过面试。并且其实很多手写往往背后就考察了你对相关理论的认识。

编程题主要分为这几种类型:

* 算法题
* 涉及js原理的题以及ajax请求
* 业务场景题: 实现一个具有某种功能的组件
* 其他(进阶,对计算机综合知识的考察,考的相对较少):实现订阅发布者模式;分别用面向对象编程,面向过程编程,函数式编程实现把大象放进冰箱等等

其中前两种类型所占比重最大。
算法题建议养成每天刷一道leetcode的习惯,重点刷数据结构(栈,链表,队列,树),动态规划,DFS,BFS

本文主要涵盖了第二种类型的各种重点手写。

建议优先掌握

  • instanceof (考察对原型链的理解)

  • new (对创建对象实例过程的理解)

  • call&apply&bind (对this指向的理解)

  • 手写promise (对异步的理解)

  • 手写原生ajax (对ajax原理和http请求方式的理解,重点是get和post请求的实现)

  • 事件订阅发布 (高频考点)

  • 其他:数组,字符串的api的实现,难度相对较低。只要了解数组,字符串的常用方法的用法,现场就能写出来个大概。(ps:笔者认为数组的reduce方法比较难,这块有余力可以单独看一些,即使面试没让你实现reduce,写其他题时用上它也是很加分的)


话不多说,直接开始

1. 手写instanceof

instanceof作用:

判断一个实例是否是其父类或者祖先类型的实例。

instanceof 在查找的过程中会遍历左边变量的原型链,直到找到右边变量的 prototype查找失败,返回 false

 let myInstanceof = (target,origin) => {
    while(target) {
        if(target.__proto__===origin.prototype) {
           return true
        }
        target = target.__proto__
    }
    return false
}
let a = [1,2,3]
console.log(myInstanceof(a,Array));  // true
console.log(myInstanceof(a,Object));  // true

2. 实现数组的map方法

数组的map() 方法会返回一个新的数组,这个新数组中的每个元素对应原数组中的对应位置元素调用一次提供的函数后的返回值。

用法:

const a = [1, 2, 3, 4];
const b = array1.map(x => x * 2);
console.log(b);   // Array [2, 4, 6, 8]

实现前,我们先看一下map方法的参数有哪些
image.png
map方法有两个参数,一个是操作数组元素的方法fn,一个是this指向(可选),其中使用fn时可以获取三个参数,实现时记得不要漏掉,这样才算完整实现嘛

原生实现:

    // 实现
    Array.prototype.myMap = function(fn, thisValue) {
           let res = []
           thisValue = thisValue||[]
           let arr = this
           for(let i=0; i<arr.length; i++) {
               res.push(fn.call(thisValue, arr[i],i,arr))   // 参数分别为this指向,当前数组项,当前索引,当前数组
          }
           return res
      }
       // 使用
       const a = [1,2,3];
       const b = a.myMap((a,index)=> {
               return a+1;
          }
      )
       console.log(b)   // 输出 [2, 3, 4]

3. reduce实现数组的map方法

利用数组内置的reduce方法实现map方法,考察对reduce原理的掌握

Array.prototype.myMap = function(fn,thisValue){
    var res = [];
    thisValue = thisValue||[];
    this.reduce(function(pre,cur,index,arr){
        return res.push(fn.call(thisValue,cur,index,arr));
    },[]);
    return res;
}

var arr = [2,3,1,5];
arr.myMap(function(item,index,arr){
console.log(item,index,arr);
})

4. 手写数组的reduce方法

reduce() 方法接收一个函数作为累加器,数组中的每个值(从左到右)开始缩减,最终为一个值,是ES5中新增的又一个数组逐项处理方法

参数:

  • callback(一个在数组中每一项上调用的函数,接受四个函数:)

    • previousValue(上一次调用回调函数时的返回值,或者初始值)

    • currentValue(当前正在处理的数组元素)

    • currentIndex(当前正在处理的数组元素下标)

    • array(调用reduce()方法的数组)

  • initialValue(可选的初始值。作为第一次调用回调函数时传给previousValue的值)

 function reduce(arr, cb, initialValue){
    var num = initValue == undefined? num = arr[0]: initValue;
    var i = initValue == undefined? 1: 0
    for (i; i< arr.length; i++){
       num = cb(num,arr[i],i)
    }
    return num
}

function fn(result, currentValue, index){
    return result + currentValue
}

var arr = [2,3,4,5]
var b = reduce(arr, fn,10)
var c = reduce(arr, fn)
console.log(b)   // 24

5. 数组扁平化

数组扁平化就是把多维数组转化成一维数组

1. es6提供的新方法 flat(depth)

let a = [1,[2,3]]; 
a.flat(); // [1,2,3]
a.flat(1); //[1,2,3]

其实还有一种更简单的办法,无需知道数组的维度,直接将目标数组变成1维数组。 depth的值设置为Infinity。

let a = [1,[2,3,[4,[5]]]]; 
a.flat(Infinity); // [1,2,3,4,5] a是4维数组

2. 利用cancat

function flatten(arr) {
    var res = [];
    for (let i = 0, length = arr.length; i < length; i++) {
    if (Array.isArray(arr[i])) {
    res = res.concat(flatten(arr[i])); //concat 并不会改变原数组
    //res.push(...flatten(arr[i])); //或者用扩展运算符
    } else {
        res.push(arr[i]);
      }
    }
    return res;
}
let arr1 = [1, 2,[3,1],[2,3,4,[2,3,4]]]
flatten(arr1); //[1, 2, 3, 1, 2, 3, 4, 2, 3, 4]

补充:指定deep的flat

只需每次递归时将当前deep-1,若大于0,则可以继续展开

     function flat(arr, deep) {
       let res = []
       for(let i in arr) {
           if(Array.isArray(arr[i])&&deep) {
               res = res.concat(flat(arr[i],deep-1))
          } else {
               res.push(arr[i])
          }
      }
       return res
  }
   console.log(flat([12,[1,2,3],3,[2,4,[4,[3,4],2]]],1));

6. 函数柯里化

用的这里的方法 https://juejin.im/post/684490...

柯里化的定义:接收一部分参数,返回一个函数接收剩余参数,接收足够参数后,执行原函数。

当柯里化函数接收到足够参数后,就会执行原函数,如何去确定何时达到足够的参数呢?

有两种思路:

  1. 通过函数的 length 属性,获取函数的形参个数,形参的个数就是所需的参数个数

  2. 在调用柯里化工具函数时,手动指定所需的参数个数

将这两点结合一下,实现一个简单 curry 函数:

/**
* 将函数柯里化
* @param fn   待柯里化的原函数
* @param len   所需的参数个数,默认为原函数的形参个数
*/
function curry(fn,len = fn.length) {
return _curry.call(this,fn,len)
}

/**
* 中转函数
* @param fn   待柯里化的原函数
* @param len   所需的参数个数
* @param args 已接收的参数列表
*/
function _curry(fn,len,...args) {
   return function (...params) {
        let _args = [...args,...params];
        if(_args.length >= len){
            return fn.apply(this,_args);
        }else{
         return _curry.call(this,fn,len,..._args)
        }
  }
}

我们来验证一下:

let _fn = curry(function(a,b,c,d,e){
console.log(a,b,c,d,e)
});

_fn(1,2,3,4,5);     // print: 1,2,3,4,5
_fn(1)(2)(3,4,5);   // print: 1,2,3,4,5
_fn(1,2)(3,4)(5);   // print: 1,2,3,4,5
_fn(1)(2)(3)(4)(5); // print: 1,2,3,4,5

我们常用的工具库 lodash 也提供了 curry 方法,并且增加了非常好玩的 placeholder 功能,通过占位符的方式来改变传入参数的顺序。

比如说,我们传入一个占位符,本次调用传递的参数略过占位符, 占位符所在的位置由下次调用的参数来填充,比如这样:

直接看一下官网的例子:

image.png

接下来我们来思考,如何实现占位符的功能。

对于 lodash 的 curry 函数来说,curry 函数挂载在 lodash 对象上,所以将 lodash 对象当做默认占位符来使用。

而我们的自己实现的 curry 函数,本身并没有挂载在任何对象上,所以将 curry 函数当做默认占位符

使用占位符,目的是改变参数传递的顺序,所以在 curry 函数实现中,每次需要记录是否使用了占位符,并且记录占位符所代表的参数位置。

直接上代码:

/**
* @param fn           待柯里化的函数
* @param length       需要的参数个数,默认为函数的形参个数
* @param holder       占位符,默认当前柯里化函数
* @return {Function}   柯里化后的函数
*/
function curry(fn,length = fn.length,holder = curry){
return _curry.call(this,fn,length,holder,[],[])
}
/**
* 中转函数
* @param fn           柯里化的原函数
* @param length       原函数需要的参数个数
* @param holder       接收的占位符
* @param args         已接收的参数列表
* @param holders       已接收的占位符位置列表
* @return {Function}   继续柯里化的函数 或 最终结果
*/
function _curry(fn,length,holder,args,holders){
return function(..._args){
//将参数复制一份,避免多次操作同一函数导致参数混乱
let params = args.slice();
//将占位符位置列表复制一份,新增加的占位符增加至此
let _holders = holders.slice();
//循环入参,追加参数 或 替换占位符
_args.forEach((arg,i)=>{
//真实参数 之前存在占位符 将占位符替换为真实参数
if (arg !== holder && holders.length) {
    let index = holders.shift();
    _holders.splice(_holders.indexOf(index),1);
    params[index] = arg;
}
//真实参数 之前不存在占位符 将参数追加到参数列表中
else if(arg !== holder && !holders.length){
    params.push(arg);
}
//传入的是占位符,之前不存在占位符 记录占位符的位置
else if(arg === holder && !holders.length){
    params.push(arg);
    _holders.push(params.length - 1);
}
//传入的是占位符,之前存在占位符 删除原占位符位置
else if(arg === holder && holders.length){
   holders.shift();
}
});
// params 中前 length 条记录中不包含占位符,执行函数
if(params.length >= length && params.slice(0,length).every(i=>i!==holder)){
return fn.apply(this,params);
}else{
return _curry.call(this,fn,length,holder,params,_holders)
}
}
}

验证一下:;

let fn = function(a, b, c, d, e) {
console.log([a, b, c, d, e]);
}

let _ = {}; // 定义占位符
let _fn = curry(fn,5,_); // 将函数柯里化,指定所需的参数个数,指定所需的占位符

_fn(1, 2, 3, 4, 5);                 // print: 1,2,3,4,5
_fn(_, 2, 3, 4, 5)(1);             // print: 1,2,3,4,5
_fn(1, _, 3, 4, 5)(2);             // print: 1,2,3,4,5
_fn(1, _, 3)(_, 4,_)(2)(5);         // print: 1,2,3,4,5
_fn(1, _, _, 4)(_, 3)(2)(5);       // print: 1,2,3,4,5
_fn(_, 2)(_, _, 4)(1)(3)(5);       // print: 1,2,3,4,5

至此,我们已经完整实现了一个 curry 函数~~

7. 浅拷贝和深拷贝的实现

深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。

浅拷贝和深拷贝的区别:

浅拷贝:创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值,如果属性是引用类型,拷贝的就是内存地址,如果其中一个对象改变了引用类型的属性,就会影响到另一个对象。

深拷贝:将一个对象从内存中完整的复制一份出来,从堆内存中开辟一个新区域存放。这样更改拷贝值就不影响旧的对象

浅拷贝实现:

方法一:

function shallowCopy(target, origin){
   for(let item in origin) target[item] = origin[item];
   return target;
}

其他方法(内置api):

  1. Object.assign

var obj={a:1,b:[1,2,3],c:function(){console.log('i am c')}}
var tar={};
Object.assign(tar,obj);

当然这个方法只适合于对象类型,如果是数组可以使用slice和concat方法

  1. Array.prototype.slice

var arr=[1,2,[3,4]];
var newArr=arr.slice(0);
  1. Array.prototype.concat

var arr=[1,2,[3,4]];
var newArr=arr.concat();

测试同上(assign用对象测试、slice concat用数组测试),结合浅拷贝深拷贝的概念来理解效果更佳

深拷贝实现:

方法一:

转为json格式再解析
const a = JSON.parse(JSON.stringify(b))

方法二:

// 实现深拷贝  递归
function deepCopy(newObj,oldObj){
    for(var k in oldObj){
        let item=oldObj[k]
        // 判断是数组、对象、简单类型?
        if(item instanceof Array){
            newObj[k]=[]
            deepCopy(newObj[k],item)
        }else if(item instanceof Object){
            newObj[k]={}
            deepCopy(newObj[k],item)
        }else{  //简单数据类型,直接赋值
            newObj[k]=item
        }
    }
}
(未完待续……)

作者:晚起的虫儿

来源:https://segmentfault.com/a/1190000038910420







0 个评论

要回复文章请先登录注册