Объектно-ориентированный JavaScript - обещания

JavaScript частично является объектно-ориентированным языком.

Чтобы изучить JavaScript, нам нужно изучить объектно-ориентированные части JavaScript.

В этой статье мы рассмотрим обещания JavaScript.

Обещания

Обещание - это альтернатива обратным вызовам.

Обещания позволяют нам получать результаты вызовов асинхронных функций.

Обещания проще, чем обратные вызовы, и дают нам более читаемый код.

Они могут взять на себя несколько состояний.

Обещание может быть отложено, что означает, что результат еще не готов.

Это исходное состояние.

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

В случае ошибки результат отклоняется.

Когда ожидающее обещание выполнено или отклонено, выполняются связанные обратные вызовы, поставленные в очередь then.

Это лучше, чем асинхронные обратные вызовы.

Если у нас есть много асинхронных функций, которые мы хотим запустить, нам придется многократно их вкладывать.

Например, мы пишем:

asyncFunction(arg, result => {
  asyncFunction(arg, result => {
    //...
  })
})

чтобы запустить асинхронную функцию более одного раза.

Если нам придется делать это больше, тогда будет больше вложенности, и будет труднее читать.

Если asyncFunction является обещанием, мы можем просто вызвать then с помощью обратного вызова.

И выполняется обратный вызов с обещанием:

asyncFunction(arg)
  .then(result => {
    //...
  });

Мы просто продолжаем вызывать then, пока не вызовем все необходимые нам обещания:

asyncFunction(arg)
  .then(result => {
    //...
    return asyncFunction(argB);
  })
  .then(result => {
    //...
  })

Обратный вызов then возвращает обещание, поэтому мы можем продолжать вызывать then, пока не закончим.

Чтобы поймать ошибки обещания, мы можем вызвать метод catch с обратным вызовом.

Например, мы можем написать:

readFileWithPromises('text.json')
  .then(text => {
    //...
  })
  .catch(error => {
    console.error(error)
  })

Создание обещаний

Мы можем создавать обещания с помощью конструктора Promise.

Например, мы можем написать:

const p = new Promise(
  (resolve, reject) => {
    if (...) {
      resolve(value);
    } else {
      reject(reason);
    }
  });

Мы передали обратный вызов с параметрами resolve и reject, которые являются функциями.

resolve выполнил обещание с заданной стоимостью.

reject отклоняет обещание со значением.

Мы можем использовать than с then и catch, как мы делали с предыдущими примерами:

p
  .then(result => {
    //...
  })
  .catch(error => {
    //...
  })

Когда мы выдаем ошибку в then обратном вызове, он также будет перехвачен с catch, если он вызывается после then, вызывающего ошибку:

readFilePromise('file.txt')
  .then(() => {
    throw new Error()
  })
  .catch(error => {
    'Something went wrong'
  });

Promise.all ()

Promise.all позволяет нам запускать массив обещаний параллельно и возвращает обещание, которое преобразуется в массив всех обещаний в массиве.

Если все они выполнены, то в параметре обратного вызова then будет возвращен массив результатов обещаний.

Например, мы можем написать:

Promise.all([
    p1(),
    p2()
  ])
  .then(([r1, r2]) => {
    //
  })
  .catch(err => {
    console.log(err)
    ''
  })

Мы вызываем Promise с p1 и p2, которые возвращают обещания.

Тогда r1 и r2 - это результаты.

catch обнаруживает ошибку в любом из обещаний, если какое-либо из них отклонено.

Заключение

Мы можем создавать обещания с помощью конструктора Promise.

Promise.all запускает многополюсные обещания параллельно и возвращает обещание, которое преобразуется в массив всех результатов.

Понравилась эта статья? Если да, то получите больше похожего контента, подписавшись на наш канал YouTube в Decoded!