Promise value как получить

Значение промиса, как получить

Ранее мы видели, как мы можем передать результат асинхронной операции из функции обещания наружу:

Теперь получить это значение. Функция then() объекта Promise используется для получения результата операции обещания:

Первый параметр функции, onFulfilled, представляет функцию, которая выполняется, когда обещание успешно завершается и получает данные. передается в resolve() в качестве параметра.

Второй параметр функции, onRejected, представляет собой функцию, которая выполняется при возникновении ошибки и принимает данные, переданные в reject() в качестве параметра.

Функция

then() также возвращает объект Promise.

Итак, давайте получим передаваемые данные:

Итак, параметр value здесь будет представлять строку «Hello, world!» , который передается для разрешения («Hello world!»). В результате вывод консоли будет выглядеть так:

В то же время нам вообще не нужно передавать какое-либо значение в resolve(). Асинхронная операция может просто выполняться и не передавать никаких результатов наружу.

В этом случае функция обещания вычисляет сумму чисел x и y и выводит результат на консоль.

Promise.resolve

Иногда вы просто хотите вернуть что-то ценное из обещания. Для этого вы можете использовать метод Promise.resolve(). Этому методу передается возвращаемое значение обещания. Метод Promise.resolve() возвращает промис:

Определите промис с помощью функции

Часто промис определяется с помощью функции, которая возвращает объект промиса. Например:

Здесь функция sum() принимает два числа и возвращает обещание, инкапсулирующее сумму этих чисел. После расчет, сумма чисел передается в resolve(), или мы можем получить ее с помощью метода then(). Определение промиса с помощью функции, с одной стороны, позволяет нам передавать разные значения при вызове функции. А с другой стороны работать с результатом этой функции как с промисом и настраивать обработку полученного значения для каждого конкретного вызова.

Результат программы:

А что если у нас есть такой же принцип обработки значения, полученного от асинхронной функции?

В этом случае логика обработки будет повторяться. Но поскольку метод then() также возвращает объект Promise, мы можем сделать что-то вроде этого:

Гибкая конфигурация функций

Что, если мы хотим, чтобы у программиста был выбор? Вы можете определить свой собственный драйвер, если хотите, а если нет, то будет использоваться драйвер по умолчанию. В этом случае мы можем определить функцию-обработчик как параметр функции и, если он не передан, установить обработчик по умолчанию:

Source

Promise

Резюме

Объект Обещание используется для ленивой и асинхронной оценки.

Пример интерактивности

Синтаксис

Параметры

Описание

Интерфейс Обещание (обещание) — это контейнер для значения, в настоящее время неизвестного, когда было создано обещание. Он позволяет обрабатывать результаты асинхронных операций так, как если бы они были синхронными: вместо конечного результата асинхронного метода возвращается своего рода обещание (буквальный перевод слова «обещание»), что получает результат в какой-то момент в будущем.

Промис может находиться в трех состояниях:

  • pending : исходное состояние, ни выполнено, ни отклонено.
  • успешно : Операция успешно завершена.
  • отклонено : Операция завершилась с ошибкой.

После создания обещание в ожидает и затем может быть выполнено ( выполнено) и возвращается результат (значение) или отклонено ( отклонено), возвращает причину отклонения. В обоих случаях контроллер, прикрепленный к промису, вызывается методом then. (Если обещание уже было выполнено или отклонено при назначении обработчика, обработчик все равно будет вызван, т. е. асинхронное выполнение обещания и назначение обработчика не произойдет в «состоянии гонки», подобно событиям в DOM.) 4> ;

Поскольку функции Promise.prototype.then() и Promise.prototype.catch() возвращают обещание, их можно вызывать в цепочке для создания соединения .

Примечание: считается, что обещание находится в состоянии выполнено) , когда оно выполнено или отклонено, т.е. для любых других условий, а не ожиданий (это только оборот речи, а не фактическое состояние обещания). Вы также можете увидеть, что выражение разрешается с помощью ; то есть обещание завершилось или «заблокировано» в ожидании выполнения другого обещания. В статье «Состояния и пункты назначения» содержится более подробное описание терминологии.

Читайте также:  Two worlds 2 южные врата как открыть

Свойства

Методы

Создать обещание

Объект обещания создается с использованием ключевого слова new и его конструктора. Конструктор Promise принимает именованную функцию в качестве аргумента. «исполнитель» ( исполнительная функция ). Эта функция должна иметь две функции обратного вызова в качестве параметров. Первая (разрешить) вызывается при успешном завершении асинхронной операции и возвращает результат ее выполнения в виде значения. Второй обратный вызов (отклонение) вызывается при сбое операции и возвращает значение, указывающее причину сбоя, чаще всего объект ошибки.

Чтобы сделать функцию функцией обещания, просто верните в нее объект Promise:

Источник

Обещание JavaScript с примерами

В этой статье мы рассмотрим, что такое промисы, как они работают, зачем нужны и различные примеры их использования.

Что такое обещание?

По умолчанию JavaScript выполняется последовательно (в одном потоке, синхронно). То есть каждая последующая операция ждет завершения предыдущей.

Достаточно часто на сайте встречаются задачи, которые необходимо выполнить и которые занимают значительное количество времени. Если они реализованы с использованием синхронного кода, это может привести к блокировке страниц (то есть с ними нельзя взаимодействовать в течение определенного периода времени). Следовательно, при использовании такого сайта возможен негативный пользовательский опыт, и таких сценариев, конечно, лучше избегать.

Чтобы этого избежать, следует использовать асинхронный код. В отличие от синхронного, он работает в фоновом режиме и не блокирует основной поток. Эти. код после его выполнения немедленно, не дожидаясь его завершения.

Можно написать асинхронный код на JavaScript несколькими способами: обратные вызовы, промисы и ключевые слова async/await.

В этой статье мы рассмотрим, как это сделать с обещанием.

Промис (promises, промисы) — это специальный объект и набор методов в JavaScript для удобного написания асинхронного кода.

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

Давайте начнем изучать промисы на примере из реальной жизни.

Допустим, папа обещает дать вам 100 долларов, если вы хорошо или отлично сдадите завтрашний тест.

В настоящее время он приостановлен, потому что вы не знаете, какой рейтинг вы получите, и, следовательно, не знаете, получите ли вы бонус в размере 100 долларов.

Но как только вы получите контроль над оценкой, обещание заканчивается. В зависимости от того, добились ли вы успеха или нет, также будет зависеть, получите ли вы 100 долларов или нет.

В JavaScript этот пример реализован с использованием обещания, подобного этому:

Теперь давайте посмотрим, как все это работает, и начнем с создания обещания.

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

Процесс написания обещания начинается с его создания. Это делается с помощью конструктора, то есть с помощью new Promise() :

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

Обещание заканчивается, когда вызывается resolve() или cancel().

Функция разрешения() обычно вызывается в той точке кода, где асинхронная операция должна завершиться успешно. И функция reject() должна дать сбой.

Устанавливает, что обещание может находиться в

Промисы начинаются с состояния ожидания ( статус: «ожидание» ). Он говорит, что это еще не было сделано (результат не определен).

Обещание завершается, когда вызывается resolve() или reject(). При этом его статус меняется на выполненный (статус: «удовлетворен») или отклоненный (статус: «отклонен»).

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

Если проверка на соответствие верна, обещание будет успешно выполнено в течение 5 секунд путем вызова функции resolve(). И поскольку промис выполнен успешно, будет вызван метод then().

Читайте также:  Геншин импакт как получить полуночный нефрит

Если значение константы прохождения теста изменено на false, обещание не будет выполнено через 5 секунд из-за вызова функции reject(). И так как в этом случае обещание завершилось ошибкой, вызывается функция catch().

Методы обещаний

Каждое обещание имеет определенный набор методов, которые мы можем использовать:

  • затем — done, когда обещание было выполнено успешно (после вызова функции resolve());
  • catch — вызывается, если обещание не выполняется (после вызова aject() );
  • finally — выполняется в любом случае после завершения промиса, вне зависимости от конечного состояния.

Пример использования всех трех методов:

При этом then() позволяет обрабатывать не только успех, но и ошибку. Для этого необходимо передать функцию вторым аргументом.

Второй аргумент является необязательным, и в этом случае он ответит только в случае успеха:

Чтобы получить значение обещания в методах then() и catch(), как указано выше, вы должны перейти к функции разрешения() и разочарованного().

Цепочка промисов

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

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

Пример строки обещания:

  • Сначала выполняется первое обещание, которое выполняется через 3 секунды со значением 2;
  • затем выполняется метод then(), который выводит в консоль значение переменной value, равное аргументу, переданному в resolve(), и в результате возвращает новое обещание; как и предыдущий, успешно завершится через 3 секунды со значением * 2 ;
  • затем выполняется еще один then(), он выполняет те же действия, что и предыдущий then() ;
  • затем выполняет финальную функцию then(), которая просто выводит значение параметра value на консоль.

Promise.all() и Promise.race()

Promise.all() и Promise.race() являются статическими методами Promise, содержащими ряд обещаний. как ввод вернуть новое обещание.

В случае Promice.all() промис заканчивается, когда заканчиваются все промисы в массиве.

При использовании Promise.race() обещание заканчивается, когда выполняется первое обещание в массиве.

Задачи

1. Следующий асинхронный код, реализованный с использованием callback-функций, необходимо переписать с промисами:

2. Написать функцию, которая может выполнять несколько действий с задержкой .

3. Перепишите код для динамической загрузки скриптов в заданном порядке с использованием промисов:

Источник

Промисы

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

Чтобы расслабиться, вы обещаете прислать им сингл, когда он выйдет. Вы даете фанатам список, на который нужно подписаться. Вы можете оставить свой адрес электронной почты там, чтобы получить песню, как только она будет выпущена. И даже больше, если что-то пойдет не так, например, студия загорелась, а трек не вышел, они тоже получат об этом уведомление.

Все довольны! Вы счастливы, что фанаты вас больше не беспокоят, и фанатам больше не нужно беспокоиться о том, что они пропустят новый сингл.

Это реальная аналогия ситуаций, с которыми мы часто сталкиваемся в программировании:

  1. Существует «сборочный» код, который делает что-то, что требует времени. Например, загрузка данных по сети. В нашей аналогии это «певец».
  2. Существует «потребляющий» код, который хочет получить результат «создания» кода, когда он будет готов. Может потребоваться для более чем одной функции. Они есть эти «поклонники».
  3. Промис — это специальный объект в JavaScript, который объединяет теги «создать» и «использовать». В наших терминах аналогией является «список подписки». Код «создания» может выполняться столько времени, сколько потребуется для получения результата, а обещание делает результат доступным для кода подписки, когда результат будет готов.

Эта аналогия не совсем точна, потому что объект Promise в JavaScript намного сложнее, чем простой список подписки: он имеет дополнительные функции и ограничения. Но для начала эта аналогия хороша.

Читайте также:  250000 на развитие бизнеса от соцзащиты как получить через госуслуги

Синтаксис создания промиса:

Функция, передаваемая новому промису, называется executor (executor). Когда обещание создано, оно будет автоматически выполнено. Он должен содержать код «создания», который в конечном итоге создаст результат. С точки зрения нашей аналогии: исполнитель — это «певец».

Его аргументы разрешения и отклонения являются обратными вызовами, предоставляемыми самим JavaScript. Наш код находится только внутри исполнителя.

Когда вы получите результат, сейчас или позже, не имеет значения, вы должны вызвать один из этих коллбэков:

  • resolve(value) — если операция завершено успешно с результатом на значение .
  • reject (ошибка) — если произошла ошибка, ошибка является объектом ошибки.

Таким образом, исполнитель запускается автоматически, должен выполнить работу, а затем вызвать разрешение или отклонение.

Объект обещания, возвращаемый новым конструктором обещаний, имеет внутренние свойства:

  • статус («статус»): сначала «ожидание» («ожидание»), затем оно меняется на «успешно» («успешно завершено») вызовом resolve или «отклонено» («выполнено с ошибкой») вызовом reject .
  • результат («результат») — изначально не определено, затем изменяется на значение при вызове resolve(value) или на ошибку при вызове reject(error).

Так что исполнитель в итоге поставит пешку в одно из двух состояний:

Посмотрим, как «поклонники» узнают об этих изменениях позже.

Вот пример конструктора Promise и простого исполнителя с кодом, который выдает результат с задержкой (через setTimeout):

При выполнении старого кода мы можем заметить две вещи:

  1. Функция-исполнитель выполняется немедленно при вызове нового промиса.
  2. Исполнитель получает два аргумента: resolve и reject — это встроенные функции JavaScript, поэтому нам не нужно их писать. Нам просто нужно убедиться, что артист позвонит одному из них, когда будет готов.

После секунды «обработки» исполнитель вызывает метод resolve(«done») для передачи результата:

Это был пример успешно выполненной задачи, что приводит к «успешно выполненному» обещанию.

А теперь пример исполнителя, сообщающего, что задача выполнена с ошибкой:

Подводя итог, исполнитель выполняет задачу (что обычно требует времени), затем вызывает разрешение или отклонение для изменить состояние соответствующего обещания.

Обещания: как успешные, так и отклоненные обещания будут называться «выполненными», в отличие от оригинала «ожидающее» обещание.

Исполнитель должен что-то вызвать — так что либо: разрешить, либо отклонить. Статус залога можно изменить только один раз.

Все следующие запросы разрешения и отклонения будут игнорироваться:

Идея состоит в том, что задача, выполняемая исполнителем, может иметь только один результат: попадание или ошибка.

Также обратите внимание, что функция разрешения/отклонения принимает только один аргумент (или ни одного). Все остальные аргументы будут игнорироваться.

В случае, если что-то пойдет не так, мы должны вызвать reject. Это можно сделать с любым типом аргумента (точно так же, как и с разрешением), но рекомендуется использовать объект Error (или объект, унаследованный от него). почему это? Мы скоро поймем.

Обычно исполнитель делает что-то асинхронное, а потом вызывает resolve/reject, т.е. через какое-то время. Но это не обязательно, можно сразу вызватьsolve или reject:

Такое может случиться, например, когда мы начали выполнять задачу, но сразу увидели, что она уже сделана и результат закэширован.

Это нормальная ситуация. Сразу же получаем успешно выполненный промис.

Свойства состояния и результата являются внутренними свойствами объекта Promise, и у нас нет к ним прямого доступа. Для обработки результата нужно использовать методы .then/.catch/.finally, о которых пойдет речь далее.

Потребители: затем поймать, наконец

Объект Promise служит связующим звеном между функциями-исполнителями («создателем» или «исполнителем кода») и потребителями («поклонниками»), которые получает результат или ошибку. Функции-потребители могут быть зарегистрированы (подписаны). методы .then, .catch и .finally.

Наиболее важным и основным методом является .then .

Первый аргумент метода .then — это функция, которая выполняется, когда промис переходит в состояние «успешно» и получает результат.

Второй аргумент .then — это функция, которая выполняется, когда промис переходит в состояние «сбой» и получает ошибку.

Например, вот ответ на успешное обещание:

Источник

Поделиться с друзьями
Решатор