ES6 — Организуйте использование промисов

ECMAScript 6

Определение обещаний

Pormise — это решение для асинхронного программирования на JS, написанное в соответствии со стандартом языка ES6 и предоставляющее собственные объекты Promise.

Обещание — это просто контейнер, в котором хранится результат события, которое завершится в будущем. Промис — это объект, из которого можно получить сообщения об асинхронных операциях.Промис предоставляет унифицированный API, и различные асинхронные операции могут обрабатываться одинаково.

Обещания имеют следующие две характеристики:

  1. На состояние объекта не влияет внешний мир. Есть три состояния: заполнение (выполняется), выполнено (успех), отклонено (неудача). Только результат асинхронной операции может определить текущее состояние, и никакая другая операция не может изменить это состояние.

  2. Однажды состояние изменилось, оно больше не изменится, и этот результат можно получить в любой момент. Три состояния — только от заполнения до выполненного или от заполнения до отклонения. Состояние изменяется только с заполнения на выполнено или отражено, два изменения.

С помощью объекта Promise асинхронные операции могут быть выражены в процессе синхронных операций, избегая уровней вложенных функций обратного вызова. Кроме того, объекты Promise предоставляют единый интерфейс, упрощающий управление асинхронными операциями.

Недостатки обещаний

  1. Обещание нельзя отменить, оно будет выполнено сразу после создания и не может быть отменено на полпути.

  2. Если функция обратного вызова не установлена, ошибка, выданная внутри промиса, не будет отражена снаружи.

  3. Когда он находится в состоянии ожидания, невозможно узнать, на каком этапе он находится в данный момент (только что запущен или вот-вот завершится).

Основное использование Promise

const promise = new Promise((resolve, reject) => {
  let status = true;
  if (status) {
    resolve('操作成功!');
  } else {
    reject('操作失败!');
  }
});

promise.then(res => {
  console.log('成功结果：' + res);
}, error => {
  console.log('失败结果：' + error);
  
});

В ES6 объект Promise — это конструктор, который генерирует экземпляр Promise. Конструктор Promise принимает функцию в качестве параметра и принимает два параметра: разрешение и отклонение.

Среди них функция разрешения состоит в том, чтобы изменить состояние промиса с заполнения на выполненное, а функция отклонения — изменить состояние промиса с заполнения на отклонено.

После создания экземпляра Promise можно использовать метод then для указания функций обратного вызова для состояния выполнения и состояния отклонения соответственно.

Метод then принимает два параметра: первая функция обратного вызова вызывается при выполнении изменения состояния, а вторая функция обратного вызова вызывается при отражении изменения состояния. Второй параметр является необязательным и не должен предоставляться.

const promise = new Promise((resolve, reject) => {
  console.log('new Promise()');
  resolve();
});

promise.then(() => {
  console.log('resolve()');
});

console.log('End');

Выше приведен простой способ написания пары промисов Давайте посмотрим, как выводится приведенный выше пример.

// 执行结果
new Promise()
End
resolve()

В приведенном выше примере, поскольку объект Promise является синхронным, он выводится первым, а метод then является асинхронным, поэтому он выводится позже.

Синтаксический сахар для Promise тогда

Экземпляр Promise имеет метод then, который определен в объекте-прототипе Promise.prototype. Ее функция Как упоминалось ранее, первая функция обратного вызова вызывается, когда изменение состояния выполнено, а вторая функция обратного вызова (необязательная) вызывается, когда изменение состояния отклонено.

new Promise((resolve, reject) => {
  resolve('王小端Coder');
}).then(res => {
  console.log(res); // 王小端Coder
});

Основной метод записи вызова метода then, вы можете написать метод обратного вызова для выполнения обратного вызова после успеха. Метод then возвращает новый экземпляр Promise, поэтому мы можем использовать цепочный метод записи, то есть вызывать метод then после метода then.

new Promise((resolve, reject) => {
  resolve('王小端Coder');
}).then(res => res).then(res => {
  console.log(res); // 王小端Coder
});

С цепочкой вы можете указать набор функций обратного вызова, которые будут вызываться по порядку. В это время предыдущая функция обратного вызова может возвращать объект Promise (то есть происходит асинхронная операция), в это время последняя функция обратного вызова будет ждать изменения состояния объекта Promise перед вызовом.

Синтаксический перехват сахара для Promise

catch — это функция обратного вызова, используемая для указания произошедшей ошибки.

new Promise((resolve, reject) => {
  reject('失败');
}).catch(error => {
  console.log(error); // 失败
});

Когда состояние экземпляра Promise изменится на отклоненное состояние или операция завершится ошибкой и выдаст ошибку исключения, она будет перехвачена методом catch. Таким образом, метод reject в экземпляре Promise эквивалентен выдаче ошибки. Если состояние промиса стало разрешенным, выдача ошибки недействительна.

new Promise((resolve, reject) => {
  reject('失败');
  throw new Error('抛出异常'); // 这行无效
}).catch(error => {
  console.log(error); // 失败
});

Метод наконец-то обещания

Метод finally используется для указания действия, которое будет выполняться независимо от конечного состояния объекта Promis. Этот метод является стандартным, представленным в ES2018.

new Promise((resolve, reject) => {
  resolve();
}).then(res => {
  console.log('success');
}).catch(error => {
  console.log('error');
}).finally(() =>{
  console.log('finally');
})

Обещание всего метода

Метод Promise.all используется для переноса нескольких экземпляров Promise в новый экземпляр Promise. В методе all можно передать несколько объектов Promise.Когда все состояния объекта Promise возвращаются к выполненному, будет возвращено выполненное, в противном случае будет возвращено отклоненное.

const promise1 = new Promise((resolve, reject) => {
  resolve();
})
const promise2 = new Promise((resolve, reject) => {
  resolve();
})
const promise3 = new Promise((resolve, reject) => {
  resolve();
})

const promiseAll = Promise.all([promise1, promise2, promise3]).then(res => {
  console.log('all');
})

Метод гонки Promise

Метод Promise.race также заключает несколько экземпляров Promise в новый экземпляр Promise. Несколько объектов Promise могут быть переданы в качестве параметров.Если экземпляр экземпляра red сначала изменит состояние, то соответственно изменится состояние гонки.

const promise1 = new Promise((resolve, reject) => {
  reject();
})
const promise2 = new Promise((resolve, reject) => {
  resolve();
})
const promise3 = new Promise((resolve, reject) => {
  reject();
})

const promiseRace = Promise.race([promise1, promise2, promise3]).then(res => {
  console.log('race then');
}).catch(error => {
  console.log('race catch');
})

Обещание закончилось! Всем спасибо за указание на недостатки.


Категории