手写Promise源码，阿里、百度等大厂技术面试题汇总

最新推荐文章于 2024-05-31 10:04:55 发布
最新推荐文章于 2024-05-31 10:04:55 发布
阅读量857 收藏 16
点赞数 6
分类专栏： 2024年程序员 文章标签： 前端 javascript 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61067876/article/details/136884873
版权

// 导出

module.exports = MyPromise;

捕获错误与then链式调用其他状态

const PENDING = ‘pending’;

const FULFILLED = ‘fulfilled’;

const REJECTED = ‘rejected’;

class MyPromise {

// 捕获执行的错误

constructor(executor) {

try {

executor(this.resolve, this.reject)

} catch (e) {

this.reject(e);

}

}

status = PENDING;

value = undefined;

reason = undefined;

successCallback = [];

failCallback = [];

resolve = value => {

if (this.status !== PENDING) return;

this.status = FULFILLED;

this.value = value;

while (this.successCallback.length) this.successCallback.shift()()

}

reject = reason => {

if (this.status !== PENDING) return;

this.status = REJECTED;

this.reason = reason;

while (this.failCallback.length) this.failCallback.shift()()

}

then(successCallback, failCallback) {

let promise2 = new MyPromise((resolve, reject) => {

if (this.status === FULFILLED) {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else if (this.status === REJECTED) {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else {

this.successCallback.push(() => {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

this.failCallback.push(() => {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

}

});

return promise2;

}

}

function resolvePromise(promise2, x, resolve, reject) {

if(promise2 === x){

return reject(new TypeError(‘Chaining cycle detected for promise #’))

}

if (x instanceof MyPromise) {

x.then(resolve, reject)

} else {

resolve(x)

}

}

// 导出

module.exports = MyPromise;

// 导入

const MyPromise = require(‘./07.1-捕获错误与then链式调用其他状态’);

let promise = new MyPromise((resolve, reject) => {

// throw new Error(‘executor error’)

// resolve(‘成功’)

// reject(‘失败’)

setTimeout(() => {

resolve(‘2000’)

}, 2000)

})

promise.then(value => {

console.log(value)

// throw new Error(‘then error’)

return 123

}, reason => {

// console.log(reason.message)

return 10000

}).then(value => {

console.log(value)

})

then方法参数变为可选

const PENDING = ‘pending’;

const FULFILLED = ‘fulfilled’;

const REJECTED = ‘rejected’;

class MyPromise {

constructor(executor) {

try {

executor(this.resolve, this.reject)

} catch (e) {

this.reject(e);

}

}

status = PENDING;

value = undefined;

reason = undefined;

successCallback = [];

failCallback = [];

resolve = value => {

if (this.status !== PENDING) return;

this.status = FULFILLED;

this.value = value;

while (this.successCallback.length) this.successCallback.shift()()

}

reject = reason => {

if (this.status !== PENDING) return;

this.status = REJECTED;

this.reason = reason;

while (this.failCallback.length) this.failCallback.shift()()

}

then(successCallback, failCallback) {

successCallback = successCallback ? successCallback : value => value;

failCallback = failCallback ? failCallback : reason => { throw reason }

let promise2 = new MyPromise((resolve, reject) => {

if (this.status === FULFILLED) {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else if (this.status === REJECTED) {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else {

this.successCallback.push(() => {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

this.failCallback.push(() => {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

}

});

return promise2;

}

}

function resolvePromise(promise2, x, resolve, reject) {

if(promise2 === x){

return reject(new TypeError(‘Chaining cycle detected for promise #’))

}

if (x instanceof MyPromise) {

x.then(resolve, reject)

} else {

resolve(x)

}

}

// 导出

module.exports = MyPromise;

// 导入

const MyPromise = require(‘./08.1-then方法参数变为可选’);

let promise = new MyPromise((resolve, reject) => {

// resolve(‘成功’)

reject(‘失败’)

})

promise

.then()

.then()

.then(value => console.log(value), reason => { console.log(reason) })

Promise.all 方法的实现

  • 用来解决异步并发问题，他允许我们按照异步代码调用的顺序，得到异步代码执行的结果

  • all方法是一个静态方法，所以需要再类当中定义一个all方法，all方法前需要加上static关键字

  • 接受一个数组作为参数，数组可以填入任何值，包括普通值和promise对象

  • 数组当中值得顺序，一定是我们得到结果的顺序

  • 返回值也是一个promise对象，所以我们可以在后边链式调用then方法

  • 所有的promise状态都是成功才是成功，有一个失败就为失败

const PENDING = ‘pending’;

const FULFILLED = ‘fulfilled’;

const REJECTED = ‘rejected’;

class MyPromise {

constructor(executor) {

try {

executor(this.resolve, this.reject)

} catch (e) {

this.reject(e);

}

}

status = PENDING;

value = undefined;

reason = undefined;

successCallback = [];

failCallback = [];

resolve = value => {

if (this.status !== PENDING) return;

this.status = FULFILLED;

this.value = value;

while (this.successCallback.length) this.successCallback.shift()()

}

reject = reason => {

if (this.status !== PENDING) return;

this.status = REJECTED;

this.reason = reason;

while (this.failCallback.length) this.failCallback.shift()()

}

then(successCallback, failCallback) {

successCallback = successCallback ? successCallback : value => value;

failCallback = failCallback ? failCallback : reason => { throw reason }

let promise2 = new MyPromise((resolve, reject) => {

if (this.status === FULFILLED) {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else if (this.status === REJECTED) {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else {

this.successCallback.push(() => {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

this.failCallback.push(() => {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

}

});

return promise2;

}

// 静态方法 — 接受一个数组

static all(array) {

let result = [] // 存储Promise对象的结果

let index = 0 // 存储addData()执行次数

// 返回一个Promise对象，传递一个执行器并接受两个参数

return new MyPromise((resolve, reject) => {

/**

  • 将promise的值，放入到数组中

  • 因为内部需要使用resolve()方法，所以将该函数放入到执行器中

  • */

function addData(key, value) {

result[key] = value;

index++;

// 判断数组当中所有内容是否执行完毕

if (index === array.length) {

// 防止for循环结束直接调用resolve()时，有异步操作没执行结束！

resolve(result)

}

}

/**

  • 循环该数组内所有元素并对其进行一个判断，判断该元素是否为Promise对象

  • */

for (let i = 0; i < array.length; i++) {

// 拿到当前值

let current = array[i]

// 判断当前是是否是 MyPromise 下的一个实例

if (current instanceof MyPromise) {

// promise对象

current.then(value => addData(i, value), reason => reject(reason))

} else {

// 普通值

addData(i, array[i])

}

}

})

}

}

function resolvePromise(promise2, x, resolve, reject) {

if (promise2 === x) {

return reject(new TypeError(‘Chaining cycle detected for promise #’))

}

if (x instanceof MyPromise) {

x.then(resolve, reject)

} else {

resolve(x)

}

}

// 导出

module.exports = MyPromise;

// 导入

const MyPromise = require(‘./10.1-Promise.All方法的实现’);

function p1() {

return new MyPromise(function (resolve, reject) {

setTimeout(function () {

resolve(‘p1’)

}, 2000)

})

}

function p2() {

return new MyPromise(function (resolve, reject) {

resolve(‘p2’)

})

}

MyPromise.all([‘a’, ‘b’, p1(), p2(), ‘c’]).then(result => console.log(result))

// 11-Promise.All方法的实现.html

function p1() {

return new Promise(function (resolve, reject) {

setTimeout(function () {

resolve(‘p1’)

}, 2000)

})

}

function p2() {

return new Promise(function (resolve, reject) {

resolve(‘p2’)

})

}

promise.all([‘a’, ‘b’, p1(), p2(), ‘c’]).then(function (result) {

// result -> [‘a’, ‘b’, p1(), p2(), ‘c’]

console.log(result)

});

Promise.resolve 方法的实现

  • 将给定的值转换为Promise对象

  • 返回值是一个Promise对象

  • 返回的Promise对象当中会包裹给定的值

  • resolve内部会判断传入的值是普通值还是promise对象

  • 普通值 — 处理成promise对象

  • promise对象 — 原封不动的将promise对象作为resolve的返回值

const PENDING = ‘pending’;

const FULFILLED = ‘fulfilled’;

const REJECTED = ‘rejected’;

class MyPromise {

constructor(executor) {

try {

executor(this.resolve, this.reject)

} catch (e) {

this.reject(e);

}

}

status = PENDING;

value = undefined;

reason = undefined;

successCallback = [];

failCallback = [];

resolve = value => {

if (this.status !== PENDING) return;

this.status = FULFILLED;

this.value = value;

while (this.successCallback.length) this.successCallback.shift()()

}

reject = reason => {

if (this.status !== PENDING) return;

this.status = REJECTED;

this.reason = reason;

while (this.failCallback.length) this.failCallback.shift()()

}

then(successCallback, failCallback) {

successCallback = successCallback ? successCallback : value => value;

failCallback = failCallback ? failCallback : reason => { throw reason }

let promise2 = new MyPromise((resolve, reject) => {

if (this.status === FULFILLED) {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else if (this.status === REJECTED) {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else {

this.successCallback.push(() => {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

this.failCallback.push(() => {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

}

});

return promise2;

}

static all (array) {

let result = [];

let index = 0;

return new MyPromise((resolve, reject) => {

function addData(key, value) {

result[key] = value;

index++;

if (index === array.length) {

resolve(result)

}

}

for (let i = 0; i < array.length; i++) {

let current = array[i]

if (current instanceof MyPromise) {

current.then(value => addData(i, value), reason => reject(reason))

} else {

addData(i, array[i])

}

}

})

}

static resolve (value) {

if (value instanceof MyPromise) return value;

return new MyPromise(resolve => resolve(value))

}

}

function resolvePromise(promise2, x, resolve, reject) {

if (promise2 === x) {

return reject(new TypeError(‘Chaining cycle detected for promise #’))

}

if (x instanceof MyPromise) {

x.then(resolve, reject)

} else {

resolve(x)

}

}

// 导出

module.exports = MyPromise;

// 导入

const MyPromise = require(‘./12.1-Promise.resolve方法的实现’);

function p1() {

return new MyPromise(function (resolve, reject) {

setTimeout(function () {

resolve(‘p1’)

}, 2000)

})

}

function p2() {

return new MyPromise(function (resolve, reject) {

resolve(‘p2’)

})

}

MyPromise.resolve(100).then(value => console.log(value))

MyPromise.resolve(p1()).then(value => console.log(value))

// 13-Promise.resolve方法的实现.html

function p1() {

return new Promise(function (resolve, reject) {

resolve(‘hello’)

})

}

Promise.resolve(10).then(value => console.log(value))

Promise.resolve(p1()).then(value => console.log(value))

finally 方法的实现

  • 两个特点

  • 无论当前Promise对象的状态最终成功还是失败，finally方法当中回调函数始终都会被都会被执行一次

  • 在finally方法的后边，我们可以链式调用then方法拿到当前promise对象中返回的结果

  • finally不是一个静态方法，需要定义在MyPromise对象当中的类的原型对象身上

const PENDING = ‘pending’;

const FULFILLED = ‘fulfilled’;

const REJECTED = ‘rejected’;

class MyPromise {

constructor(executor) {

try {

executor(this.resolve, this.reject)

} catch (e) {

this.reject(e);

}

}

status = PENDING;

value = undefined;

reason = undefined;

successCallback = [];

failCallback = [];

resolve = value => {

if (this.status !== PENDING) return;

this.status = FULFILLED;

this.value = value;

while (this.successCallback.length) this.successCallback.shift()()

}

reject = reason => {

if (this.status !== PENDING) return;

this.status = REJECTED;

this.reason = reason;

while (this.failCallback.length) this.failCallback.shift()()

}

then(successCallback, failCallback) {

successCallback = successCallback ? successCallback : value => value;

failCallback = failCallback ? failCallback : reason => { throw reason }

let promise2 = new MyPromise((resolve, reject) => {

if (this.status === FULFILLED) {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else if (this.status === REJECTED) {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

} else {

this.successCallback.push(() => {

setTimeout(() => {

try {

let x = successCallback(this.value)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

this.failCallback.push(() => {

setTimeout(() => {

try {

let x = failCallback(this.reason)

resolvePromise(promise2, x, resolve, reject)

} catch (e) {

reject(e)

}

}, 0)

});

}

});

return promise2;

}

// 在类当中建立一个方法，并且接收一个回调函数作为参数，不管成功或失败，都要调用该回调函数

finally (callback) {

/**

  • 通过then方法得到当前promise对象的状态

  • 因为finally可以在后边通过链式调用then方法，所以需要返回一个promise对象

  • 刚好then方法的返回值就是promise对象，所以直接返回then即可

  • 因为then方法要得到当前promise对象的一个结果

  • 所以在then方法内需要返回成功的结果和失败的原因

  • */

return this.then(value => {

// callback();

// return value;

/**

  • 借助resolve方法判断callback()的返回值是什么

  • 如果是普通值，就转化为promise对象，然后等待这个promise对象的执行完成

  • 如果是promise对象，继续等待这个promise对象的执行完成

  • 然后再返回value

  • */

return MyPromise.resolve(callback()).then(() => value);

}, reason => {

// callback();

// throw reason;

return MyPromise.resolve(callback()).then(() => {throw reason});

})

}

static all (array) {

let result = [];

let index = 0;

return new MyPromise((resolve, reject) => {

function addData(key, value) {

result[key] = value;

index++;

if (index === array.length) {

resolve(result)

}

}

for (let i = 0; i < array.length; i++) {

let current = array[i]

if (current instanceof MyPromise) {

current.then(value => addData(i, value), reason => reject(reason))

} else {

addData(i, array[i])

}

}

})

}

static resolve (value) {

if (value instanceof MyPromise) return value;

return new MyPromise(resolve => resolve(value))

}

}

function resolvePromise(promise2, x, resolve, reject) {

if (promise2 === x) {

return reject(new TypeError(‘Chaining cycle detected for promise #’))

}

if (x instanceof MyPromise) {

x.then(resolve, reject)

} else {

resolve(x)

}

}

// 导出

module.exports = MyPromise;

// 导入

const MyPromise = require(‘./14.1-Promise.finally方法的实现’);

function p1() {

return new MyPromise(function (resolve, reject) {

setTimeout(function () {

resolve(‘p1’)

}, 2000)

})

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

img
img
img
img

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）
img

t) => {

function addData(key, value) {

result[key] = value;

index++;

if (index === array.length) {

resolve(result)

}

}

for (let i = 0; i < array.length; i++) {

let current = array[i]

if (current instanceof MyPromise) {

current.then(value => addData(i, value), reason => reject(reason))

} else {

addData(i, array[i])

}

}

})

}

static resolve (value) {

if (value instanceof MyPromise) return value;

return new MyPromise(resolve => resolve(value))

}

}

function resolvePromise(promise2, x, resolve, reject) {

if (promise2 === x) {

return reject(new TypeError(‘Chaining cycle detected for promise #’))

}

if (x instanceof MyPromise) {

x.then(resolve, reject)

} else {

resolve(x)

}

}

// 导出

module.exports = MyPromise;

// 导入

const MyPromise = require(‘./14.1-Promise.finally方法的实现’);

function p1() {

return new MyPromise(function (resolve, reject) {

setTimeout(function () {

resolve(‘p1’)

}, 2000)

})

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-Z6If28r8-1710929533849)]
[外链图片转存中…(img-3185f8e9-1710929533849)]
[外链图片转存中…(img-AjZyh4yk-1710929533849)]
[外链图片转存中…(img-sBlt046H-1710929533850)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）
[外链图片转存中…(img-YCXqFCq9-1710929533850)]

m0_61067876
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最火大厂面试题、面试技巧汇总及简历编写（附简历模版下载）
我本可以容忍阳光，如果我不曾见过太阳，然而阳光已使我荒凉，成为更新的荒凉。
02-20 1311
最近有粉丝反馈金三银四已到，准备跳槽或整体提升一下技术，有没有一些优秀的大厂面经、面试题、简历编写技巧、简历模版等资料，所以本文就统一整理一些瓶子君所知道的面试资料。大佬们的面试历程一位前...
前端面试大厂手写源码系列（上）
01-08
现在大厂基本都会要求面试者手写前端常见API的原理，以此来证明你对该知识点的理解程度。接下来，我将列举我面试时以及自认为比较重要的CSS部分、JS部分常见手写原理题！后续分享Vue全家桶、React全家桶手写原理图，...
花2万块买的教程！年末阿里百度等大厂技术面试题汇总，技术详细介绍
clhcowboy的博客
02-19 200
开头 让我们一起来看看，字节跳动的第三面，面试官都问了什么？（第一二面的题目及答案已整理，需要的可以在文末领取） 从七月中旬开始，我前前后后差不多一共投递了八十份简历，到目前为止，我参加面试的面试有十二家（收到的面试通知） 字节跳动的面试我准备了一个多星期吧，因为比较重视。 从字节跳动面试官这些问题，可以看出，第三面他们考察的一个很重要的方向就是项目架构和性能优化。 “懒洋洋”甚至跟我吐槽：“我靠，现在大厂面试java后端都这么难的吗？” 大厂面试就是难，但是大厂的待遇是真的香！最近不是都在讨论华为的工资到
2024年Web前端最全手写Promise源码(1)，面试总结+解答分享
2401_84411433的博客
05-05 778
我在成长过程中也是一路摸爬滚打，没有任何人的指点，所以走的很艰难。例如在大三的时候，如果有个学长可以阶段性的指点一二，如果有已经工作的师兄可以告诉我工作上需要什么，我应该前面的三年可以缩短一半；后来去面试bat，失败了有5、6次，每次也不知道具体是什么原因，都是靠面试回忆去猜测可能是哪方面的问题，回来学习和完善，当你真正去招人的时候，你就会知道面试记录是多么重要，面试官可以从面试记录里看到你的成长，总是去面试，总是没有成长，就会被定义为缺乏潜力。
手写Promise源码
2401_84092360的博客
04-23 520
分享一套阿里大牛整理的前端资料给大家，点击前端校招面试题精编解析大全即可免费下载try {reject(e)}, 0)try {reject(e)}, 0)} else {try {reject(e)}, 0)});});// 在类当中建立一个方法，并且接收一个回调函数作为参数，不管成功或失败，都要调用该回调函数/**通过then方法得到当前promise对象的状态。
前端面试之手写promise
叫我阿豪
12-16 265
大厂面试一般喜欢问的底层源码手写，废话不多说，直接上代码！
手写Promise源码(1)
2401_84092322的博客
04-23 669
javascript是前端必要掌握的真正算得上是编程语言的语言，学会灵活运用javascript，将对以后学习工作有非常大的帮助。掌握它最重要的首先是学习好基础知识，而后通过不断的实战来提升我们的编程技巧和逻辑思维。这一块学习是持续的，直到我们真正掌握它并且能够灵活运用它。如果最开始学习一两遍之后，发现暂时没有提升的空间，我们可以暂时放一放。继续下面的学习，javascript贯穿我们前端工作中，在之后的学习实现里也会遇到和锻炼到。真正学习起来并不难理解，关键是灵活运用。
2019大厂前端面试题
jstljspservlet的博客
10-29 1049
百度 1、请分析以下代码执行结果 [‘1’, ‘3’, ‘10’].map(parseInt); 2、请分析以下代码执行结果 var number = 10; function fn() { console.log(this.number); } var obj = { number: 2, show: function(fn) { this.number = 3; fn(); arguments...
掌握这些前端手写面试题能进大厂吗
helloworld1024fd的博客
11-18 66
函数节流是指规定一个单位时间，在这个单位时间内，只能有一次触发事件的回调函数执行，如果在同一个单位时间内某事件被触发多次，只有一次能生效。运行的字符串代码被恶意方（不怀好意的人）操控修改，您最终可能会在您的网页/扩展程序的权限下，在用户计算机上运行恶意代码。它会执行JS代码，有XSS漏洞。event bus既是node中各个模块的基石，又是前端组件通信的依赖手段之一，同时涉及了订阅-发布设计模式，是非常重要的基础。输入字符串s，以及其重复的次数，输出重复的结果，例如输入abc，2，输出abcabc。
2018年来自大厂的前端面试题
我的博客
12-30 3191
一、来源背景 面试题是来自微博@牛客网发布的真实大厂前端面经题目，我一直在收集题目长期一个一个的记录下来的，可能会有重复，但基本前端的面试大纲和需要掌握的知识都在其中了，面试题仅做学习参考，学习者阅后也要用心钻研其中的原理，重要知识需要系统学习、透彻学习，形成自己的知识链。 二、532道前端真实大厂面试题 express和koa的对比，两者中间件的原理，koa捕获异常多种情况说一下 你项目...
JS手写Promise源码
12-19
4、更好地使用第三方Promise库：手写Promise可以帮助我们更好地使用和理解第三方的Promise库，如Bluebird或q.js等。通过手动实现Promise，我们可以更好地理解这些库是如何实现Promise的，并更好地使用它
阿里百度美团面试题合集
04-13
数据结构与算法：最常见的各种排序，最好能手写 .. Java 高级：JVM 内存结构、垃圾回收器、回收算法、GC、并发编程相关(多 线程、线程池等)、NIO/BIO、各种集合类的比较优劣势(底层数据结构也要 掌握，特别是扩容等)...
「2021」高频前端面试题汇总之手写代码篇.pdf
12-14
「2021」高频前端面试题汇总之手写代码篇.pdf
记录一次前端页面崩溃的产生及处理
weixin_51123079的博客
05-30 510
记录一次前端页面崩溃的产生及处理
前端开发记录
最新发布
qq_25806839的博客
05-31 165
【代码】前端开发记录。
Vue3实战笔记（52）—Vue 3封装持仓分析饼图
山花的博客
05-30 524
接上文，封装持仓分析饼图。封装好几个组件，用于后续开发。把忧愁煮成茶，让它在心间慢慢沉淀，剩下的，便是清甜的回味。
vue 笔记03
m0_47045804的博客
05-30 869
vue挂载以后把所有内容手抄一份就叫做虚拟dom 假设你要操作dom 等一下先不要操作真实dom, 先修改我这个手抄的虚拟的DOM 改完了么？如果我们需要一个变量 这个变量的值是根据data里面某个值或者某几个值的变化而变化的时候,那么我们就需要用到vue里面的computed计算属性。data里面定义的数据无法直接互相访问 因为加载到data的时候还没有产生当前的vue对象。return 返回的结果就是当前计算属性的值。回调函数的参数就是过滤原本的值return 返回过滤的新值。
web前端三大主流框架
低调做人，低调编码，神码都是浮云
05-30 939
Web前端三大主流框架介绍：Angular、React、Vue
promise大厂面试题
10-22
在大厂的promise面试题中，常见的问题包括： 1. 说出代码执行结果 2. Promise的基本原理和用法 3. Promise的链式调用和错误处理 4. async/await的使用和原理 5. Promise.all和Promise.race的使用场景和区别 6. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值