安科网

前端杂谈：如何实现一个 Promise?

wuxj00

wuxj00

2018-12-14

关注 关注

首先, 什么是 Promise?

A promise is an object that may produce a single value some time in the future: either a resolved value, or a reason that it’s not resolved (e.g., a network error occurred). A promise may be in one of 3 possible states: fulfilled, rejected, or pending. Promise users can attach callbacks to handle the fulfilled value or the reason for rejection.

关键语句: Promise 是一个在将来某个时刻产生一个单一结果的对象. 通俗一点来说, Promise 代表了一个值, 但是这个值我们并不确定什么时候会被返回.

A promise is an object that may produce a single value some time in the future.

简单看看 Promise 的历史

  • Promise 在 1980 年代被创建出来
  • 在 1988 年正式得名: Promise
  • 已经有很多人了解到了 Promise, 但是人们还是坚持使用 node.js 中提倡的以回调函数首个参数传 error 对象的方式处理异步代码.
  • Dojo 首次大规模的使用了 Promise , 相应的 Promise/A 被提出用以规范 Promise 的实现
  • JQuery 开始使用 Promise 并真正使 Promise 广为人知
  • JQuery 没有实现部分 Promise 的功能, 这也导致了 Promie/A+ 标准的产生
  • ES6 正式引入了 Promise,并且和已有的实现了 Promise/A 规范的 library 相兼容

实现 Promise 之前, 让我们看看 Promise 有哪些规范

  1. Promise 是一个 thenable 对象, 也就是说 Promise 有一个 .then() 方法
  2. 一个 pending 状态的 Promise 可以进入 fulfilled 和 rejected 状态
  3. promise 一旦进入 fulfilled 或 rejected 状态, 不可再改变其状态
  4. 一旦 promise 改变了其状态, 它笔芯有一个值(这个值也可能是 undefined)

开始实现一个 Promise

首先, 让我们看看一段最普通的异步代码:

// 异步方法定义
var basicAsyncFunc = function(callback) {
 setTimeout(function() {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) {
 callback(null, randomNumber)
 } else {
 callback(new Error('bad luck...'))
 }
 }, 1000)
}
// 异步方法调用
basicAsyncFunc((err, result) => {
 if (err) {
 console.log(`the reason fail is: ${err}`)
 return
 }
 console.log(`success get result: ${result}`)
})

按照 Promise 的规范定义, 理想中 Promise 的调用方式为:

// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {}
// Promise 形式的异步方法调用
promiseAsyncFunc.then(
 data => {
 console.log(`success get result: ${data}`)
 },
 err => {
 console.log(`the reason fail is: ${err}`)
 }
)

按照这个理想当中的调用方式, 让我们写出第一版代码.

第一版 Promise：能保存回调方法

// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {
 var fulfillCallback
 var rejectCallback
 setTimeout(() => {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) fulfillCallback(randomNumber)
 else rejectCallback(randomNumber)
 }, 1000)
 return {
 then: function(_fulfillCallback, _rejectCallback) {
 fulfillCallback = _fulfillCallback
 rejectCallback = _rejectCallback
 }
 }
}
// Promise 形式的异步方法调用
promiseAsyncFunc().then(fulfillCallback, rejectCallback)

我们的思路是在 .then() 方法中, 将 fullfill 和 reject 结果的回调函数保存下来, 然后在异步方法中调用. 因为是异步调用, 根据 event-loop 的原理, promiseAsyncFunc().then(fulfillCallback, rejectCallback) 传入的 callback 在异步调用结束时一定是已经赋值过了.

第二版 Promise：实构造函数

当前我们的实现 Promise 中，异步逻辑代码和 Promise 的代码是杂糅在一起的，让我们将其区分开：

var promiseAsyncFunc = function() {
 var fulfillCallback
 var rejectCallback
 return {
 fulfill: function(value) {
 if (fulfillCallback && typeof fulfillCallback === 'function') {
 fulfillCallback(value)
 }
 },
 reject: function(err) {
 if (rejectCallback && typeof rejectCallback === 'function') {
 rejectCallback(err)
 }
 },
 then: function(_fulfillCallback, _rejectCallback) {
 fulfillCallback = _fulfillCallback
 rejectCallback = _rejectCallback
 }
 }
}
let ownPromise = function(asyncCall) {
 let promise = promiseAsyncFunc()
 asyncCall(promise.fulfill, promise.reject)
 return promise
}
// Promise 形式的异步方法调用
ownPromise(function(fulfill, reject) {
 setTimeout(() => {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) fulfill(randomNumber)
 else reject(randomNumber)
 }, 1000)
})

我们新定义了一个方法 ownPromise() 用于创建 Promise，并在promiseAsyncFunc() 中暴露出 fulfill 和 reject 接口方便异步代码去调用。

这里有一个问题，我们在调用 ownPromise()后得到了 promise 实例，此时我们可以直接调用 fulfill()，reject()这两个方法，而理论上我们应该只应暴露 promise 的then()方法。所以我们利用闭包将这两个方法隐藏：

var promiseAsyncFunc = function() {
 var fulfillCallback
 var rejectCallback
 return {
 fulfill: function(value) {
 if (fulfillCallback && typeof fulfillCallback === 'function') {
 fulfillCallback(value)
 }
 },
 reject: function(err) {
 if (rejectCallback && typeof rejectCallback === 'function') {
 rejectCallback(err)
 }
 },
 promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 fulfillCallback = _fulfillCallback
 rejectCallback = _rejectCallback
 }
 }
 }
}
let ownPromise = function(asyncCall) {
 let defer = promiseAsyncFunc()
 asyncCall(defer.fulfill, defer.reject)
 return defer.promise
}
// Promise 形式的异步方法调用
ownPromise(function(fulfill, reject) {
 setTimeout(() => {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) fulfill(randomNumber)
 else reject(randomNumber)
 }, 1000)
})

第三版 Promise: 支持状态管理

为了实现规范中对于 Promise 状态变化的要求, 我们需要为 Promise 加入状态管理, 这一步较为简单, 让我们看代码:

const PENDING = Symbol('pending')
const FULFILLED = Symbol('fulfilled')
const REJECTED = Symbol('rejected')
// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {
 var status = PENDING
 var fulfillCallback
 var rejectCallback
 return {
 fulfill: function(value) {
 if (status !== PENDING) return
 if (typeof fulfillCallback === 'function') {
 fulfillCallback(value)
 status = FULFILLED
 }
 },
 reject(error) {
 if (status !== PENDING) return
 if (typeof rejectCallback === 'function') {
 rejectCallback(error)
 status = REJECTED
 }
 },
 promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 fulfillCallback = _fulfillCallback
 rejectCallback = _rejectCallback
 }
 }
 }
}
let ownPromise = function(asyncCall) {
 let defer = promiseAsyncFunc()
 asyncCall(defer.fulfill, defer.reject)
 return defer.promise
}
// Promise 形式的异步方法调用
ownPromise(function(fulfill, reject) {
 setTimeout(() => {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) fulfill(randomNumber)
 else reject(randomNumber)
 }, 1000)
}).then(data => console.log(data), err => console.log(err))

这段代码中我们用到了 Symbol 来表示状态常量, 对 Symbol 不了解的同学可以看这里

为了判断 Promise 的状态, 我们加入了 fulfill 和 reject 两个方法。并在其中判断 promise 当前状态。如果不是 pending 状态则直接 return(因为 Promise 状态只可能改变一次)。

现在我们的 promise 实现了对状态控制的规范：

  • 只允许改变一次状态
  • 只能从 pending => fulfilled 或 pending => rejected

但是我们的 Promise 有一个问题: promise 的值没有被保存下来。如果 promise 在异步调用完成之后才被调用 .then()方法，则我们无法把异步调用的结果传递给回调函数。为此我们需要为 Promise 加一个 value 字段：

第四版 Promise: 保存异步调用的结果

我们为 promise 加入 value 字段，用于保存 Promise 的执行结果。

// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {
 var status = PENDING
 var fulfillCallback
 var rejectCallback
 var value
 return {
 fulfill: function(_value) {
 if (status !== PENDING) return
 value = _value
 status = FULFILLED
 if (typeof fulfillCallback === 'function') {
 fulfillCallback(value)
 }
 },
 reject(error) {
 if (status !== PENDING) return
 value = error
 status = REJECTED
 if (typeof rejectCallback === 'function') {
 rejectCallback(error)
 }
 },
 promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 fulfillCallback = _fulfillCallback
 rejectCallback = _rejectCallback
 }
 }
 }
}

这里我们又发现一个问题，如果一个 Promise 已经是fulfill或reject状态。我们再调用 then() 方法时，传入的回调方法永远不会被调用（因为 status 已经不是 pending）。

所以我们需要在 then()方法中对其状态进行判断：

// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {
 var status = PENDING
 var fulfillCallback
 var rejectCallback
 var value
 return {
 fulfill: function(_value) {
 if (status !== PENDING) return
 value = _value
 status = FULFILLED
 if (typeof fulfillCallback === 'function') {
 fulfillCallback(value)
 }
 },
 reject(error) {
 if (status !== PENDING) return
 value = error
 status = REJECTED
 if (typeof rejectCallback === 'function') {
 rejectCallback(error)
 }
 },
 promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 if (status === REJECTED) {
 _rejectCallback(value)
 return
 }
 if (status === FULFILLED) {
 _fulfillCallback(value)
 return
 }
 fulfillCallback = _fulfillCallback
 rejectCallback = _rejectCallback
 }
 }
 }
}

第五版 Promise: 支持链式调用

为了支持链式调用，.then() 方法的返回值必须是用 thenable (根据 Promise/A+ 规范, .then() 方法的返回值需要是一个新的 Promise)

为此我们加入一个工具方法 makeThenable()。如果传入的 value 本身就有 then()方法，则直接返回 value。否则返回一个有 then()方法的对象。 在该对象的 then()方法中，我们根据 promise 的状态，调用不同的回调方法生成新的 value。

function makeThenable(value， status){
 if(value && typeof value.then === 'function'){
 return value
 }
 if(status === FULFILLED){
 return {
 then: function(fulfillCallback, rejectCallback){
 return makeThenable(fulfillCallback(value), FULFILLED)
 }
 }
 }
 if(status === REJECTED) {
 return {
 then: function(fulfillCallback, rejectCallback){
 return makeThenable(rejectCallback(value), FULFILLED)
 }
 }
 }
}

有了以上的 makeThenable()方法，我们可以在 promise 的fulfill()，reject()回将 value 设置为 thenable:

var promiseAsyncFunc = function() {
 var status = PENDING
 var fulfillCallback
 var rejectCallback
 var value
 return {
 fulfill: function(_value) {
 if (status !== PENDING) return
 value = makeThenable(_value, FULFILLED) // 保证当前promise的value为 thenable
 status = FULFILLED
 if (typeof fulfillCallback === 'function') {
 value.then(fulfillCallback)
 }
 },
 reject(error) {
 if (status !== PENDING) return
 value = makeThenable(error, REJECTED) 、、 // 保证当前value为 thenable
 status = REJECTED
 if (typeof rejectCallback === 'function') {
 value.then(null, rejectCallback)
 }
 },
 promise: {
 then: function(){}
 }
 }
}

接下来让我们看 then()方法。为了返回一个新的 promise，我们首先得创建一个新的 promise。其次当前 promise 在fulfill() 或 reject()时，应该调用新的 promise 的fullfill() 或 reject()方法。所以我们在将 fulfullCallback和rejectCallback赋值给当前 promise 时，将其包装一下。代码如下：

promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 let newPromiseAsyncFunc = promiseAsyncFunc()
 let fulfillFunc = function(value) {
 newPromiseAsyncFunc.fulfill(_fulfillCallback(value))
 }
 let rejectFunc = function(err) {
 newPromiseAsyncFunc.fulfill(_rejectCallback(err))
 }
 if (status === PENDING) {
 fulfillCallback = fulfillFunc
 rejectCallback = rejectFunc
 } else {
 value.then(fulfillFunc, rejectFunc)
 }
 return newPromiseAsyncFunc.promise
 }
 }

如此，我们变得到了一个可以链式调用的 promise。让我们来测试一下：

const PENDING = Symbol('pending')
const FULFILLED = Symbol('fulfilled')
const REJECTED = Symbol('rejected')
function makeThenable(value, status) {
 if (value && typeof value.then === 'function') {
 return value
 }
 if (status === FULFILLED) {
 return {
 then: function(fulfillCallback, rejectCallback) {
 return makeThenable(fulfillCallback(value), FULFILLED)
 }
 }
 }
 if (status === REJECTED) {
 return {
 then: function(fulfillCallback, rejectCallback) {
 return makeThenable(rejectCallback(value), FULFILLED)
 }
 }
 }
}
// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {
 var status = PENDING
 var fulfillCallback
 var rejectCallback
 var value
 return {
 fulfill: function(_value) {
 if (status !== PENDING) return
 value = makeThenable(_value, FULFILLED)
 status = FULFILLED
 if (typeof fulfillCallback === 'function') {
 value.then(fulfillCallback)
 }
 },
 reject(error) {
 if (status !== PENDING) return
 value = makeThenable(error, REJECTED)
 status = REJECTED
 if (typeof rejectCallback === 'function') {
 value.then(null, rejectCallback)
 }
 },
 promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 let newPromiseAsyncFunc = promiseAsyncFunc()
 let fulfillFunc = function(value) {
 newPromiseAsyncFunc.fulfill(_fulfillCallback(value))
 }
 let rejectFunc = function(err) {
 newPromiseAsyncFunc.fulfill(_rejectCallback(err))
 }
 if (status === PENDING) {
 fulfillCallback = fulfillFunc
 rejectCallback = rejectFunc
 } else {
 value.then(fulfillFunc, rejectFunc)
 }
 return newPromiseAsyncFunc.promise
 }
 }
 }
}
let ownPromise = function(asyncCall) {
 let defer = promiseAsyncFunc()
 asyncCall(defer.fulfill, defer.reject)
 return defer.promise
}
let testChainedPromise = ownPromise(function(fulfill, reject) {
 setTimeout(() => {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) fulfill(randomNumber)
 else reject(randomNumber)
 }, 1000)
})
 .then(
 data => {
 console.log(data)
 return 'return value in then1 fulfill'
 },
 err => {
 console.log(err)
 return 'return value in then1 reject'
 }
 )
 .then(
 data => {
 console.log(data)
 return 'return value in then2 fulfill'
 },
 err => {
 console.log(err)
 return 'return value in then2 reject'
 }
 )
 .then(
 data => {
 console.log(data)
 },
 err => {
 console.log(err)
 }
 )
/**
console output:
0.9931984611850693
return value in then1 fulfill
return value in then2 fulfill
*/

第六版 Promise: Error handling

这里我们只对异步调用和fulfill 回调中抛出的 error 进行处理。

首先是异步调用部分,我们将其 try catch 起来，在发生异常时调用 reject 方法，并将异常作为参数传入。

let ownPromise = function(asyncCall) {
 let defer = promiseAsyncFunc()
 try {
 asyncCall(defer.fulfill, defer.reject)
 } catch (e) {
 defer.reject(e)
 }
 return defer.promise
}

然后是 fulfill 中可能出现的异常。我们对fulfillCallback(value)可能出现的异常进行捕获，并将异常传递给rejectCallback。

function makeThenable(value, status) {
 if (value && typeof value.then === 'function') {
 return value
 }
 if (status === FULFILLED) {
 return {
 then: function(fulfillCallback, rejectCallback) {
 try {
 let newValue = fulfillCallback(value)
 return makeThenable(newValue, FULFILLED)
 } catch (e) {
 return makeThenable(rejectCallback(e), FULFILLED)
 }
 }
 }
 }
 if (status === REJECTED) {
 return {
 then: function(fulfillCallback, rejectCallback) {
 return makeThenable(rejectCallback(value), FULFILLED)
 }
 }
 }
}

最后让我们对完整的代码进行测试：

const PENDING = Symbol('pending')
const FULFILLED = Symbol('fulfilled')
const REJECTED = Symbol('rejected')
function makeThenable(value, status) {
 if (value && typeof value.then === 'function') {
 return value
 }
 if (status === FULFILLED) {
 return {
 then: function(fulfillCallback, rejectCallback) {
 try {
 let newValue = fulfillCallback(value)
 return makeThenable(newValue, FULFILLED)
 } catch (e) {
 return makeThenable(rejectCallback(e), FULFILLED)
 }
 }
 }
 }
 if (status === REJECTED) {
 return {
 then: function(fulfillCallback, rejectCallback) {
 return makeThenable(rejectCallback(value), FULFILLED)
 }
 }
 }
}
// Promise 形式的异步方法定义
var promiseAsyncFunc = function() {
 var status = PENDING
 var fulfillCallback
 var rejectCallback
 var value
 return {
 fulfill: function(_value) {
 if (status !== PENDING) return
 value = makeThenable(_value, FULFILLED)
 status = FULFILLED
 if (typeof fulfillCallback === 'function') {
 value.then(fulfillCallback)
 }
 },
 reject(error) {
 if (status !== PENDING) return
 value = makeThenable(error, REJECTED)
 if (typeof rejectCallback === 'function') {
 value.then(null, rejectCallback)
 }
 status = REJECTED
 },
 promise: {
 then: function(_fulfillCallback, _rejectCallback) {
 let newPromiseAsyncFunc = promiseAsyncFunc()
 let fulfillFunc = function(value) {
 newPromiseAsyncFunc.fulfill(_fulfillCallback(value))
 }
 let rejectFunc = function(err) {
 newPromiseAsyncFunc.fulfill(_rejectCallback(err))
 }
 if (status === PENDING) {
 fulfillCallback = fulfillFunc
 rejectCallback = rejectFunc
 } else {
 value.then(fulfillFunc, rejectFunc)
 }
 return newPromiseAsyncFunc.promise
 }
 }
 }
}
let ownPromise = function(asyncCall) {
 let defer = promiseAsyncFunc()
 try {
 asyncCall(defer.fulfill, defer.reject)
 } catch (e) {
 defer.reject(e)
 }
 return defer.promise
}
let testChainedPromise = ownPromise(function(fulfill, reject) {
 throw Error('here is an error in asyncCall')
 setTimeout(() => {
 var randomNumber = Math.random()
 if (randomNumber > 0.5) fulfill(randomNumber)
 else reject(randomNumber)
 }, 1000)
})
 .then(
 data => {
 console.log(data)
 return 'return value in then1 fulfill'
 },
 err => {
 console.log(err.message)
 return 'return value in then1 reject'
 }
 )
 .then(
 data => {
 console.log(data)
 throw Error('here is an error in fulfill1')
 return 'return value in then2 fulfill'
 },
 err => {
 console.log(err.message)
 return 'return value in then2 reject'
 }
 )
 .then(
 data => {
 console.log(data)
 },
 err => {
 console.log(err.message)
 }
 )
// console out:
Error: here is an error in asyncCall
return value in then1 reject
Error: here is an error in fulfill1
return value in then2 reject

总结

以上就是我们对于 Promise 的一个简单的实现，实现思路主要参考了 Q-A promise library for javascript。该实现的 Promise 功能较为简陋，仅实现了部分 api/规范。

原创作者：ssthouse_hust

https://my.oschina.net/u/3413999/blog/2988091

前端杂谈：如何实现一个 Promise?

promise

wuxj00

wuxj00

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

如何将Node.js中的回调转换为Promise

在几年前，回调是 JavaScript 中实现执行异步代码的唯一方法。回调本身几乎没有什么问题，最值得注意的是“回调地狱”。在 ES6 中引入了 Promise 作为这些问题的解决方案。最后通过引入 async/await 关键字来提供更好的体验并提高了可

nmgxzm00 2020-11-10

把 Node.js 中的回调转换为 Promise

在几年前，回调是 JavaScript 中实现执行异步代码的唯一方法。回调本身几乎没有什么问题，最值得注意的是“回调地狱”。在 ES6 中引入了 Promise 作为这些问题的解决方案。最后通过引入 async/await 关键字来提供更好的体验并提高了可

xixixi 2020-11-11

处理异步事件的三种方式

在网站开发中，异步事件是项目必然需要处理的一个环节，也因为前端框架的兴起，通过框架实现的 SPA 已经是快速建构网站的标配了，一部获取数据也就成了不可或缺的一环;本文来就讲一讲 JavaScript 中异步的处理方式。首先当然要先理解一下同步及异步分别是

88254251 2020-11-01

手把手教你实现 Promise的使用方法

很多 JavaScript 的初学者都曾感受过被回调地狱支配的恐惧，直至掌握了 Promise 语法才算解脱。虽然很多语言都早已内置了 Promise ，但是 JavaScript 中真正将其发扬光大的还是 jQuery 1.5 对 $.ajax 的重构，

MarukoMa 2020-09-02

关于 JavaScript 错误处理的最完整指南(下半部)

因为使用了 Promise ，所以可以使用 then 来接收返回的内容，或者用 catch 来捕获出现的错误。除了 then 和 catch , Promise 中还有 finally 方法，这类似于try/catch 中的 finally。如果我们失败了

88234852 2020-09-15

V8 8.5 带来的三个实用新特性！

Promise.anyPromise 新增了一个 any 方法，它接收一个 Promise 数组，当数组中某一个 Promise 为 fulfilled 后，它返回的 Promise 就会被返回。如果所有输入的 Promise 都被拒绝，那么 Promi

陈旭阳 2020-08-31

改写promise并添加超时处理

我们都知道Promise.all()方法在有一个Promise reject以后，请求结果只返回第一个reject，我们进行了改写，在有请求reject时也可以获取所有结果，并给每个请求添加超时处理。const promiseTimeout = new P

whynotgonow 2020-08-19

ES6 中Promise 使用

ES6中一个非常重要和好用的特性就是Promise. Promise是异步变成的一种解决方案。我们什么时候回处理异步事件呢？一种很常见的应用场景就是网络请求。我们封装一个网络请求的函数，因为不能立即拿到结果，所有不能直接显示结果返回。所以往往我们会传入另外

前端开发Kingcean 2020-07-30

带你写出符合Promise/A+ 规范Promise的源码

Promise是前端面试中的高频问题，如果你能根据PromiseA+的规范，写出符合规范的源码，那么我想，对于面试中的Promise相关的问题，都能够给出比较完美的答案。我的建议是，对照规范多写几次实现，也许第一遍的时候，是改了多次，才能通过测试，那么需要

whynotgonow 2020-07-29

es6 Promise 对象、.then()

// resolve // 状态改成fulfilled. },=>{ // 第二个回调 成功reject

whynotgonow 2020-07-26

前端客栈 - Promise书生 （一）

“前端客栈？想必前方就是宁安城了，此地为宁安城的郊区，”书生忖道，“时间不早了，今日不如在此停顿休整一日。”进得店里，书生吩咐店小二将马匹安排妥当。店小二靠墙边站着，大概其他客人下来得早。书生找了靠角落的位置坐下，店小二随即跟来，递上食单。不到一刻钟，店小

bowean 2020-07-08

ES6 promise的应用

function moveTo{ //四个参数分别为移动的元素、移动到对应的横纵坐标点，以及要移动完之后要调用的回调函数。el.style.transform = `translate`; //产生位移。.then(function(){ //then

前端开发Kingcean 2020-07-08

回调与Promise

Promise 对象就是用于表示一个异步操作的最终状态。它的流程就是在什么状态下需要执行什么样的操作。then是Promise对象上的一个方法，它最多需要有两个参数：表示异步操作执行后的回调函数。// // cb && cb()这

88520191 2020-07-05

promise 练习

宏队列和微队列；微队列先于宏队列执行。resolve() //resolve()函数执行了才会触发then里面的回调函数，不执行resolve()then回调函数不会执行的。const first = () => new Promise((resol

前端开发Kingcean 2020-06-27

Shell

stringify。const Promise = require('bluebird'),fs = require('fs'),path = require('path');fs.readFileAsync(path.join(__dirname, 's

88481456 2020-06-18

ES6 promise对象

Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大。它由社区最早提出和实现，ES6 将其写进了语言标准，统一了用法，原生提供了Promise对象。所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束

whynotgonow 2020-06-16

每天前端学习 关于Promise和Symbol

若 要等待多个结果回来，再进行返回，则可以使用 Promise.all. console.log //[‘成功了‘, ‘success‘]. ES6新增一个数据类型 Symbol ,但不支持 new Symbol，可以返回唯一值

88520191 2020-06-13

使用Promise并发限制

Promise.all可以保证，promises数组中所有promise对象都达到resolve状态，才执行then回调。那么会出现的情况是，你在瞬间发出几十万http请求，或者堆积了无数调用栈导致内存溢出.这个时候需要我们对HTTP的连接数做限制。con

88520191 2020-06-13

ES6 Promise 先拉出来遛遛

去年6月份， ES2015正式发布，其中Promise被列为正式规范。作为ES6中最重要的特性之一，我们有必要掌握并理解透彻。本文将由浅到深，讲解Promise的基本概念与使用方法。复杂的概念先不讲，我们先简单粗暴地把Promise用一下，有个直观感受。这

89500297 2020-06-13

nodejs 几个不错的callback 以及promise 转换处理工具

nodejs 的一步调用经历了，callback -> promise -> async await（语法糖） 模式的转变

前端开发Kingcean 2020-06-11
wuxj00

wuxj00

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号