Implement Promise library using Js

This time I will bring you the use of Js to implement the Promise library. What are the precautions for using Js to implement the Promise library? The following is a practical case, let's take a look.

Preface

ECMAScript is the international standard for the JavaScript language, and JavaScript is the implementation of ECMAScript. The goal of ES6 is to enable the JavaScript language to be used to write large and complex applications and become an enterprise-level development language.

Concept

ES6 natively provides Promise objects.

The so-called Promise is an object used to deliver messages for asynchronous operations. It represents an event (usually an asynchronous operation) whose result is not known until the future, and this event provides a unified API for further processing.

Three questions to think about

When I first started writing the front-end, I often used callback to handle asynchronous requests, which is simple and convenient. Later, as I wrote, I abandoned callbacks and started using promises to deal with asynchronous issues. Promise is indeed more beautiful to write, but due to the lack of deep understanding of its internal structure, every time when encountering some complex situations, it is always not easy to use promise, and debugging takes a long time.

So, in this article, I will take you to start from scratch and write a basically usable promise by hand. After I write it down, you will have a clear understanding of what promise is and its internal structure, and you will be able to use promise in complex scenarios in the future.

Moreover, in order to test whether everyone has really fully mastered promises, I will give a few practice questions related to promises at the end of the article. Although they are said to be exercises, they are actually abstractions of real scenarios that you will encounter in your projects. Mastering them proficiently can help you improve your front-end skills.

The three practice questions are given in advance. You can skip reading the content below and roughly conceive in your mind how you will solve them:

• promise array Chain call?

• How to control concurrency with promises?

• How to do asynchronous caching with promise?

The above three thinking questions actually have little to do with whether you use promises or not, but if you don't deeply understand promises, it is really not that easy to solve these three problems.

What is Promise

Back to the text, what is Promise? To put it bluntly, a promise is a container that stores the result of an event (usually an asynchronous operation) that will end in the future.

First of all, ES6 stipulates that the Promise object is a constructor used to generate Promise instances. Then, this constructor accepts a function (executor) as a parameter, and the two parameters of the function are resolve and reject. Finally, after the Promise instance is generated, you can use the then method to specify the callback functions (onFulfilled and onRejected) for the resolved state and rejected state respectively.

The specific usage method is expressed in code like this:

const promise = new Promise(function(resolve, reject) {
 // ... some code
 if (/* 异步操作成功 */){
 resolve(value);
 } else {
 reject(error);
 }
});
promise.then(function(value) {
 // success
}, function(error) {
 // failure
});

After understanding this, we can boldly start constructing our own promise, and we give it a name: CutePromise

Implement a Promise: CutePromise

We directly use ES6 classes to create our CutePromise. If you are not familiar with ES6 syntax, you can Read my other two articles introducing the core syntax of ES6 before coming back. Master the core content of ES6/ES2015 in 30 minutes (Part 1), Master the core content of ES6/ES2015 in 30 minutes (Part 2)

class CutePromise {
 // executor是我们实例化CutePromise时传入的参数函数，它接受两个参数，分别是resolve和reject。
 // resolve和reject我们将会定义在constructor当中，供executor在执行的时候调用
 constructor(executor) {
 const resolve = () => {}
 const reject = () => {}
 executor(resolve, reject)
 }
 // 为实例提供一个then的方法，接收两个参数函数，
 // 第一个参数函数必传，它会在promise已成功(fulfilled)以后被调用
 // 第二个参数非必传，它会在promise已失败(rejected)以后被调用
 then(onFulfilled, onRejected) {}
}

After creating our CutePromise, let’s figure out a key point: the state of the Promise object.

The Promise object controls asynchronous operations through its own state. A Promise instance has three states:

• Asynchronous operation is pending (pending)

• Asynchronous operation is successful (fulfilled)

• Asynchronous operation failed (rejected)

Among the above three states, fulfilled and rejected together are called resolved (finalized). There are only two paths for switching status: the first is from pending=>fulfilled, and the other is from pending=>rejected. Once the status is switched, it cannot be changed.

Now let’s add status to CutePromise. The approximate process is:

首先，实例化初始过程中，我们先将状态设为PENDING，然后当executor执行resolve的时候，将状态更改为FULFILLED，当executor执行reject的时候将状态更改为REJECTED。同时更新实例的value。

constructor(executor) {
 ...
 this.state = 'PENDING';
 ...
 const resolve = (result) => {
  this.state = 'FULFILLED';
  this.value = result;
 }
 const reject = (error) => {
  this.state = 'REJECTED';
  this.value = error;
 }
 ...
}

再来看下我们的then函数。then函数的两个参数，onFulfilled表示当promise异步操作成功时调用的函数，onRejected表示当promise异步操作失败时调用的函数。假如我们调用then的时候，promise已经执行完成了（当任务是个同步任务时），我们可以直接根据实例的状态来执行相应的函数。假如promise的状态还是PENDING, 那我们就将onFulfilled和onRejected直接存储到chained这个变量当中，等promise执行完再调用。

constructor(executor) {
 ...
 this.state = 'PENDING';
 
 // chained用来储存promise执行完成以后，需要被依次调用的一系列函数
 this.chained = [];
 const resolve = (result) => {
  this.state = 'FULFILLED';
  this.value = result;
  
  // promise已经执行成功了，可以依次调用.then()函数里的onFulfilled函数了
  for (const { onFulfilled } of this.chained) {
   onFulfilled(res);
  }
 }
 ...
}
then(onFulfilled, onRejected) {
 if (this.state === 'FULFILLED') {
 onFulfilled(this.value);
 } else if (this.state === 'REJECTED') {
 onRejected(this.value);
 } else {
 this.$chained.push({ onFulfilled, onRejected });
 }
}

这样我们就完成了一个CutePromise的创建，下面是完整代码，大家可以复制代码到控制台测试一下：

class CutePromise {
 constructor(executor) {
 if (typeof executor !== 'function') {
  throw new Error('Executor must be a function');
 }
 this.state = 'PENDING';
 this.chained = [];
 const resolve = res => {
  if (this.state !== 'PENDING') {
  return;
  }
  this.state = 'FULFILLED';
  this.internalValue = res;
  for (const { onFulfilled } of this.chained) {
  onFulfilled(res);
  }
 };
 const reject = err => {
  if (this.state !== 'PENDING') {
  return;
  }
  this.state = 'REJECTED';
  this.internalValue = err;
  for (const { onRejected } of this.chained) {
  onRejected(err);
  }
 };
 try {
  executor(resolve, reject);
 } catch (err) {
  reject(err);
 }
 }
 
 then(onFulfilled, onRejected) {
 if (this.state === 'FULFILLED') {
  onFulfilled(this.internalValue);
 } else if (this.$state === 'REJECTED') {
  onRejected(this.internalValue);
 } else {
  this.chained.push({ onFulfilled, onRejected });
 }
 }
}

提供一下测试代码：

let p = new CutePromise(resolve => {
 setTimeout(() => resolve('Hello'), 100);
});
p.then(res => console.log(res));
p = new CutePromise((resolve, reject) => {
 setTimeout(() => reject(new Error('woops')), 100);
});
p.then(() => {}, err => console.log('Async error:', err.stack));
p = new CutePromise(() => { throw new Error('woops'); });
p.then(() => {}, err => console.log('Sync error:', err.stack));

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

JS实现输入框内灰色文字提示

路径中＃号怎样除去

The above is the detailed content of Implement Promise library using Js. For more information, please follow other related articles on the PHP Chinese website!