每日消息!学会JavaScript手写代码秘籍14道常用api

原文：https://juejin.cn/post/7124163407577612302

愿意花更多的时间、倾注更多的精力来跟大家一起努力。

目录

apply

async await

(资料图片)

bind

call

concurrent-request

debounce

deep-copy

event-bus

继承

instanceof

new

object-create

promise

throttle

参与

apply

为函数绑定执行上下文

原理：将函数设置为执行上下文的一个方法，然后调用执行上下文的方法

tx 指定的函数执行上下文

args 剩余参数组成的数组

any 返回函数的执行结果

// 为函数绑定执行上下文// 原理：将函数设置为执行上下文的一个方法，然后调用执行上下文的方法// ctx 指定的函数执行上下文// args 剩余参数组成的数组// any 返回函数的执行结果Function.prototype.myApply = function (ctx, args) { // fn.myApply(ctx, [arg1, arg2]) // this是正在执行的函数 const fn = this // 保证 ctx[key] 的唯一性，避免和用户设置的 context[key] 冲突 const key = Symbol() // 将执行函数设置到指定的上下文对象上 ctx[key] = fn // 执行函数 const res = ctx[key](...args) // 删除上下文上的 fn 方法 delete ctx[key] // 返回函数的执行结果 return res}复制代码

async await

async await 是 Generator 的语法糖，其本质是 Generator + 自动执行器

Generator 函数

执行 generator 函数，拿到 yield 表达式的执行结果 => { next: () => void }

自动执行器

{ value: any, done: boolean }

说明 yield 后面跟的是 Promise 实例

// async await 是 Generator 的语法糖，其本质是 Generator + 自动执行器// Generator 函数module.exports = function asyncAwait(generatorFn) { // 执行 generator 函数，拿到 yield 表达式的执行结果 => { next: () => void } const yieldExpRet = generatorFn() // 自动执行器 function autoActuator() {  // { value: any, done: boolean }  const ret = yieldExpRet.next()  if (!ret.done) {   if (object.prototype.toString.call(ret?.value?.then) === "[object Function]") {    // 说明 yield 后面跟的是 Promise 实例    ret.value.then(() => {     autoActuator()    })   } else {    // 同步    autoActuator()   }  } } autoActuator()}复制代码

bind

为函数绑定执行上下文

原理：将函数设置为执行上下文的一个方法，然后调用执行上下文上的方法

ctx 指定的函数执行上下文

args 剩余参数组成的数组

fn.myBind(ctx, [arg1, arg2])

this是正在执行的函数

保证 ctx[key] 的唯一性，避免和用户设置的 context[key] 冲突

将执行函数设置到指定的上下文对象上

返回一个可执行函数

bind 方法支持预设一部分参数，剩下的参数通过返回的函数设置，具有柯里化的作用

执行函数

// 为函数绑定执行上下文// 原理：将函数设置为执行上下文的一个方法，然后调用执行上下文上的方法// ctx 指定的函数执行上下文// args 剩余参数组成的数组Function.prototype.myBind = function (ctx, ...args) { // fn.myBind(ctx, [arg1, arg2]) // this是正在执行的函数 const fn = this // 保证 ctx[key] 的唯一性，避免和用户设置的 context[key] 冲突 const key = Symbol() // 将执行函数设置到指定的上下文对象上 ctx[key] = fn // 返回一个可执行函数 // bind 方法支持预设一部分参数，剩下的参数通过返回的函数设置，具有柯里化的作用 return function(...otherArgs) {  // 执行函数  return ctx[key](...args, ...otherArgs) }}复制代码

call

为函数绑定指定上下文

原理：将函数设置为执行上下文的一个方法，然后调用执行上下文上的方法

ctx 指定的函数执行上下文

args 剩余参数组成的数组

any 返回函数的执行结果

fn.myCall(ctx, arg1, arg2)

this是正在执行的函数

保证 ctx[key] 的唯一性，避免和用户设置的 context[key] 冲突

将执行函数设置到指定的上下文对象上

执行函数

删除上下文上的fn方法

返回函数的执行结果

// 为函数绑定指定上下文// 原理：将函数设置为执行上下文的一个方法，然后调用执行上下文上的方法// ctx 指定的函数执行上下文// args 剩余参数组成的数组// any 返回函数的执行结果Function.prototype.myCall = function (ctx, ...args) { // fn.myCall(ctx, arg1, arg2) // this是正在执行的函数 const fn = this // 保证 ctx[key] 的唯一性，避免和用户设置的 context[key] 冲突 const key = Symbol() // 将执行函数设置到指定的上下文对象上 ctx[key] = fn // 执行函数 const res = ctx[key](...args) // 删除上下文上的fn方法 delete ctx[key] // 返回函数的执行结果 return res}复制代码

concurrent-request

并发请求，控制请求并发数

taskQueues 一个个请求任务组成的数组

concurrentNum 请求的并发数

存放所有任务的执行结果

开始先发送指定数量的并发请求

当每个请求完成后再递归的调用自身，发送任务队列的下一个请求

递归终止条件(任务队列为空)

从任务队列中弹出一个任务

执行任务

当任务完成后递归调用 req, 发送队列中的下一个请求

并将任务结果 push 进结果数组中

// 并发请求，控制请求并发数// taskQueues 一个个请求任务组成的数组// concurrentNum 请求的并发数module.exports = function concurrentRequest(taskQueues = [], concurrentNum = 1) { return new Promise(resolve => {  // 存放所有任务的执行结果  const taskRet = []  // 开始先发送指定数量的并发请求  while (concurrentNum > 0) {   req()   concurrentNum--  }  // 当每个请求完成后再递归的调用自身，发送任务队列的下一个请求  function req() {   // 递归终止条件(任务队列为空)   if (!taskQueues.length) return Promise.allSettled(taskRet).then(res => {    resolve(res)   })   // 从任务队列中弹出一个任务   const task = taskQueues.shift()   // 执行任务   const ret = task()   // 当任务完成后递归调用 req, 发送队列中的下一个请求   res.then(() => {    req()   })   // 并将任务结果 push 进结果数组中   taskRet.push(ret)  } })}复制代码

debounce

防抖

原理：事件被触发 wait 毫秒后执行回调fn, 如果在wait期间再次触发事件，则重新计时

fn 事件触发后的回调函数

wait 延迟时间，wait 毫秒后执行fn

返回经过包装后的事件处理函数

定时器，这里用到了闭包

返回经过包装后的事件处理函数

如果 timer 为不为空，则说明在 wait 时间内已经触发过该事件了，而且事件处理函数仍未被调用

说明在wait事件内事件被重复触发了，则需要进行防抖处理，即清除之前的定时器，这样上一次事件触发后的回调就不会被执行

定时器也会重新设置

通过定时器来实现事件触发后在 wait 毫秒后执行事件处理函数

需要给回调绑定上下文this，即触发事件的目标对象

// 防抖// 原理：事件被触发 wait 毫秒后执行回调fn, 如果在wait期间再次触发事件，则重新计时// fn 事件触发后的回调函数// wait 延迟时间，wait 毫秒后执行fn// 返回经过包装后的事件处理函数function debounce(fn, wait = 50) { // 定时器，这里用到了闭包 let timer = null // 返回经过包装后的事件处理函数 return function(...args) {  // 如果 timer 为不为空，则说明在 wait 时间内已经触发过该事件了，而且事件处理函数仍未被调用  // 说明在wait事件内事件被重复触发了，则需要进行防抖处理，即清除之前的定时器，这样上一次事件触发后的回调就不会被执行  // 定时器也会重新设置  if (timer) {   clearTimeout(timer)  }  // 通过定时器来实现事件触发后在 wait 毫秒后执行事件处理函数  timer = setTimeout(() => {   // 需要给回调绑定上下文this，即触发事件的目标对象   fn.apply(this, args)   timer = null  }, wait) }}复制代码

deep-copy

深拷贝

src 原数据

返回拷贝后的数据

拷贝原始值，直接返回原始值本身

解决循环引用的问题

拷贝数组

拷贝 Map 对象

拷贝函数

拷贝对象

判断数据是否为原始值类型(Number, Boolean，String，Symbol ，BigInt ，Null ，Undefined)

Number,Boolean,String,Symbol,BigInt,Null,Undefined,Object,Array,Function,Date...

// 深拷贝// src 原数据// 返回拷贝后的数据module.exports = function deepCopy(src, cache = new WeakMap()) { // 拷贝原始值，直接返回原始值本身 if (isPrimitiveType(src)) return src // 解决循环引用的问题 if (cache.has(src)) return src cache.set(src, true) // 拷贝数组 if (isArray(src)) {  const ret = []  for (let i = 0, len = src.length; i < len; i++) {   ret.push(deepCopy(src[i], cache))  }  return ret } // 拷贝 Map 对象 if (isMap(src)) {  const ret = new Map()  src.forEach((value, key) => {   ret.set(key, deepCopy(value, cache))  })  return ret } // 拷贝函数 if (isFunction(src)) {  copyFunction(src) } // 拷贝对象 if (isObject(src)) {  // 获取对象上的所有key  const keys = [...Object.keys(src), ...Object.getOwnPropertySymbols(src)]  const ret = {}  // 遍历所有的key，递归调用 deepCopy 拷贝 obj[key] 的值  keys.forEach(item => {   ret[item] = deepCopy(src[item], cache)  })  // 返回拷贝后的对象  return ret }}// 判断数据是否为原始值类型(Number, Boolean，String，Symbol ，BigInt ，Null ，Undefined)function isPrimitiveType(data) { const primitiveType = ["Number", "Boolean", "String", "Symbol", "BigInt", "Null", "Undefined"] return primitiveType.includes(getDataType(data))}// 判断数据是否为Object类型function isObject(data) { return getDataType(data) === "Object"}// 判断数据是否为函数function isFunction(data) { return getDataType(data) === "Function"}// 判断数据是否为数组function isArray(data) { return getDataType(data) === "Array"}// 判断数据是否为Mapfunction isMap(data) { return getDataType(data) === "Map"}// 获取数据类型// Number,Boolean,String,Symbol,BigInt,Null,Undefined,Object,Array,Function,Date...function getDataType(data) { return Object.prototype.toString.apply(data).slice(8, -1)}// 拷贝函数function copyFunction(src) { const fnName = src.name let srcStr = src.toString() // 匹配function fnName, 比如 function fnName() {} const fnDecExp = new RegExp(`function (${fnName})?`) // 切除匹配内容，srcStr = (xxx) {} 或 (xxx) => {} srcStr = srcStr.replace(fnDecExp, "") // 匹配函数参数 const argsExg = /\((.*)\)/ let args = argsExg.exec(srcStr) // 函数体 const fnBody = srcStr.replace(argsExg, "").trim() // { return "test" } => return "test" const fnBodyCode = /^{(.*)}$/.exec(fnBody) // 得到了函数的名称，参数，函数体，重新声明函数 return new Function(...args[1].split(","), fnBodyCode[1])}复制代码

event-bus

Event bus

发布订阅设计模式的应用，node.js 的基础模块，也是前端组件通信的一种手段，比如Vue的on和on和emit

以事件名为key，事件处理函数组成的数组为value

监听事件

eventName 事件名

cb 事件处理函数

// Event bus// 发布订阅设计模式的应用，node.js 的基础模块，也是前端组件通信的一种手段，比如Vue的$on和$emitfunction EventBus() { // 以事件名为key，事件处理函数组成的数组为value this.events = {}}module.exports = EventBus// 监听事件// eventName 事件名// cb 事件处理函数EventBus.prototype.$on = function(eventName, cb) { if (!Array.isArray(cb)) {  cb = [cb] } this.events[eventName] = (this.events[eventName] || []).concat(cb)}EventBus.prototype.$emit = function(eventName, ...args) { this.events[eventName].foEach(fn => {  fn.apply(this, args) })}复制代码

继承

JavaScript 的继承方式有很多，比如简单的基于 Object.create 实现的继承，每种方式或多或少都有些缺陷

这种缺陷是语言层面导致的，避免不了，即使是 class 语法（糖）。

组合式继承，class 语法糖的本质

在this上继承父类的属性

继承父类的方法

恢复子类的构造函数，上面一行会将 Child.prototype.constructor 改为 Parent.prototype.constructor

// JavaScript 的继承方式有很多，比如简单的基于 Object.create 实现的继承，每种方式或多或少都有些缺陷，// 这种缺陷是语言层面导致的，避免不了，即使是 class 语法（糖）。// 组合式继承，class 语法糖的本质function Parent(...args) { this.name = "Parent name" this.args = args}Parent.prototype.parentFn = function() { console.log("name = ", this.name) console.log("args = ", this.args)}function Chid(args1,args2) { // 在this上继承父类的属性 Parent.call(this, args1, args2) this.childName = "child name"}// 继承父类的方法Child.prototype = Object.create(Parent.prototype)// 恢复子类的构造函数，上面一行会将 Child.prototype.constructor 改为 Parent.prototype.constructorChild.prototype.constructor = Childmodule.exports = Child复制代码

instanceof

instanceof运算符

定义：判断对象是否属于某个构造函数的实例

原理：判断构造函数的原型对象是否出现在对象的原型链上

// instanceof运算符// 定义：判断对象是否属于某个构造函数的实例// 原理：判断构造函数的原型对象是否出现在对象的原型链上module.exports = function customINstanceof (ins, constructor) { const proto = Object.getPrototypeOf(ins) if (proto === constructor.prototype) return true if (!proto) return false return customINstanceof(proto, constructor)}复制代码

new

new 运算符

作用：负责实例化一个类（构造函数）

1.创建一个构造函数原型对象为原型的对象

2.以第一步的对象为上下文执行构造函数

3.返回值，如果函数有返回值，则返回函数的返回值，否则返回第一步创建的对象。

// new 运算符// 作用：负责实例化一个类（构造函数）// 原理：// 1.创建一个构造函数原型对象为原型的对象// 2.以第一步的对象为上下文执行构造函数// 3.返回值，如果函数有返回值，则返回函数的返回值，否则返回第一步创建的对象。// Function 构造函数// Array 构造函数的其他参数组成的数组// 对象实例module.exports = function newOperator(constructor, ...args) { const ins = Object.create(constructor.prototype) const res = constructor.apply(ins, args) return res || ins}复制代码

object-create

proto 新对象的原型对象

props Object.defineProperties 的第二个参数，要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符：数据描述符和访问器描述符

// Object.create// proto 新对象的原型对象// props Object.defineProperties 的第二个参数，要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符：数据描述符和访问器描述符Object.myCreate = function(proto, props) { if (typeof proto !== "object") {  console.error("Object prototype may only be an Object or null")  return } // 创建的空对象 const obj = {} // 设置原型对象 Object.setPrototypeOf(obj, proto) // 设置对象的初始数据 if (props) {  Object.defineProperties(obj, props) } return obj}复制代码

promise

Promise，解决了回调地狱的问题

executor 同步执行

promise 状态不可逆

then 回调必须在 promise 状态改变后执行

promise 链式调用，后一个回调的参数是前一个回调的返回值

实例化 Promise 时 executor 被同步执行

// Promise，解决了回调地狱的问题// executor 同步执行// promise 状态不可逆// then 回调必须在 promise 状态改变后执行// promise 链式调用，后一个回调的参数是前一个回调的返回值// 实例化 Promise 时 executor 被同步执行function MyPromise(executor) { // 缓存this实例 const _self = this this.status = "pending" this.value = undefined this.reason = undefined this.fulfilledCb = () => {} this.rejectedCb = () => {} function resolve(value) {  setTimeout(() => {   // 状态不可逆   if (_self.status === "pending") {    _self.status = "fulfilled"    _self.value = value    _self.fulfilledCb(value)   }  }) } function reject(errMsg) {  setTimeout(() => {   // 状态不可逆   if (_self.status === "pending") {    _self.status = "rejected"    _self.reason = errMsg    _self.rejectedCb(errMsg)   }  }) } try {  executor(resolve, reject) } catch (err) {  reject(err) }}MyPromise.prototype.then = function(fulfilledCb, rejectedCb) { const _self = this return new MyPromise((resolve, reject) => {  _self.fulfilledCb = function (value) {   resolve(fulfilledCb(value))  }  _self.rejectedCb = function (reason) {   reject(rejectedCb(reason))  } })}MyPromise.race = function (promiseArr) { return new MyPromise((resolve, reject) => {  for (let i = 0, len = promiseArr.length; i < len; i++) {   const p = promiseArr[i]   p.then(resolve, reject)  } })}MyPromise.all = function (promiseArr) { return new MyPromise((resolve, reject) => {  const len = promiseArr.length  const result = []  for (let i = 0; i < len; i++) {   const p = promiseArr[i]   p.then((res) => {    result.push(res)    if (result.length === len) {     resolve(result)    }   }, (errMsg) => {    reject(errMsg)   })  } })}module.exports = MyPromise复制代码

throttle

节流

原理：事件被频繁触发时，事件回调函数会按照固定频率执行，比如1s 执行一次，只有上个事件回调被执行之后下一个事件回调才会执行

事件回调函数

wait 事件回调的执行频率，每wait毫秒执行一次

// 节流// 原理：事件被频繁触发时，事件回调函数会按照固定频率执行，比如1s 执行一次，只有上个事件回调被执行之后下一个事件回调才会执行// 事件回调函数// wait 事件回调的执行频率，每wait毫秒执行一次function throttle(fn, wait = 500) { let timer = null return function(...args) {  if (timer) return  timer = setTimeout(() => {   fn.apply(this, args)   timer = null  }, wait) }}复制代码

go!go!go!

关键词： 构造函数 事件处理 任务队列