Понимание обещаний в Node.js

Из того, что я понял, есть три способа вызова асинхронного кода:

1. События, например request.on("event", callback);
2. Обратные вызовы, например fs.open(path, flags, mode, callback);
3. обещания

Я нашел библиотеку обещаний узлов, но не получил ее.

Может ли кто-нибудь объяснить, что это за обещания и почему я должен их использовать?

Кроме того, почему он был удален из Node.js?

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

Крутая вещь в обещаниях - вы можете объединить их в цепочки зависимостей (выполнять Promise C только после завершения Promise A и Promise B).

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

Поскольку этот вопрос по-прежнему имеет много точек зрения (как и у меня), я хотел бы отметить, что:

1. узел-обещание выглядит довольно мертвым для меня (последний коммит был около 1 года назад) и почти не содержит тестов.
2. Модуль futures выглядит очень раздутым и плохо документирован (и я думаю, что соглашения об именах просто плохие)
3. Наилучшим путем кажется использование структуры q , которая является активной и хорошо документированной.

Обещание - это «вещь», которая представляет, так сказать, «возможные» результаты операции. Здесь следует отметить, что он абстрагирует детали того, когда что-то происходит, и позволяет вам сосредоточиться на том, что должно произойти после того, как что-то произойдет. Это приведет к чистому, поддерживаемому коду, где вместо обратного вызова внутри обратного вызова внутри обратного вызова ваш код будет выглядеть примерно так:

 var request = new Promise(function(resolve, reject) {
   //do an ajax call here. or a database request or whatever.
   //depending on its results, either call resolve(value) or reject(error)
   //where value is the thing which the operation's successful execution returns and
   //error is the thing which the operation's failure returns.
 });

 request.then(function successHandler(result) {
   //do something with the result
 }, function failureHandler(error) {
  //handle
 });

Спецификация обещаний гласит, что обещание

then

Метод должен возвращать новое обещание, которое выполняется, когда заданный обратный вызов successHandler или failHandler завершен. Это означает, что вы можете связывать воедино обещания, когда у вас есть набор асинхронных задач, которые необходимо выполнить, и вы можете быть уверены, что последовательность операций гарантирована, как если бы вы использовали обратные вызовы. Таким образом, вместо передачи обратного вызова внутри обратного вызова внутри обратного вызова, код с связанными обещаниями выглядит так:

var doStuff = firstAsyncFunction(url) {
                return new Promise(function(resolve, reject) {
                       $.ajax({
                        url: url,
                        success: function(data) {
                            resolve(data);
                        },
                        error: function(err) {
                             reject(err); 
                        } 
                  });
               };
doStuff
  .then(secondAsyncFunction) //returns a promise
  .then(thirdAsyncFunction); //returns a promise

Чтобы узнать больше об обещаниях и о том, почему они очень крутые, загляните в блог Доменика: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/

Это новое руководство по обещаниям от автора PouchDB , вероятно, лучшее, что я когда-либо видел. Он мудро охватывает классические ошибки новичка, показывая вам правильные шаблоны использования и даже несколько анти-шаблонов, которые все еще широко используются - даже в других уроках !!

• http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

Наслаждайтесь!

PS Я не ответил на некоторые другие части этого вопроса, так как они были хорошо освещены другими.

У Майка Таулти есть серия видеороликов , каждое из которых длится менее десяти минут, и описывает, как работает библиотека WinJS Promise.

Эти видео довольно информативны, и Майку удается продемонстрировать всю мощь API Promise с помощью нескольких удачно выбранных примеров кода.

var twitterUrl = "http://search.twitter.com/search.json?q=windows";
var promise = WinJS.xhr({ url: twitterUrl });

 promise = promise.then(
     function (xhr) {
     },
     function (xhr) {
         // handle error
     });

Отношение к тому, как обрабатываются исключения, особенно хорошо.

Несмотря на ссылки на WinJs, это серия видеофильмов общего интереса, потому что API Promise в целом схожи во многих своих реализациях.

RSVP - это легкая реализация Promise, которая проходит тестовый набор Promise / A +. Мне очень нравится API, потому что он похож по стилю на интерфейс WinJS.

Обновление апрель 2014

Кстати, библиотека WinJS теперь с открытым исходным кодом .

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

Библиотека bluebird реализует обещания и дает вам отличные длинные трассировки стека, очень быстро и предупреждает о необнаруженных ошибках. Он также работает быстрее и использует меньше памяти, чем другие библиотеки обещаний, согласно http://bluebirdjs.com/docs/benchmarks.html

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

Обещание - это просто объект, представляющий результат асинхронной операции. Обещание может быть в любом из следующих 3 состояний:

pending :: Это начальное состояние, означает, что обещание не выполнено и не отклонено.

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

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

1. Функция executor :: executor определяет асинхронную операцию, которая должна быть выполнена и результат которой представлен обещанием. Он начинает выполнение, как только объект обещания инициализируется.

2. resolv: resolv - это параметры, передаваемые функции executor, и в случае успешного выполнения executor это разрешение вызывается с передачей результата.

3. reject :: reject - это еще один параметр, переданный функции executor, и он используется, когда функция executor завершается с ошибкой. Причина отказа может быть передана в отказ.

Поэтому всякий раз, когда мы создаем объект обещания, мы должны предоставлять Executor, Resolve и Reject.

Ссылка :: Обещания

Я также недавно смотрел на обещания в node.js. На сегодняшний день, кажется, путь when.js - путь из-за его скорости и использования ресурсов, но документация по q.js дала мне намного лучшее понимание. Так что используйте when.js, а не документы q.js, чтобы понять предмет.

Из файла q.js на github:

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

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

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

1. Создание обещания:

Конструктор обещания принимает функцию, называемую исполнителем, которая имеет два параметра: разрешение и отклонение.

function example(){
   return new Promise (function(resolve , reject){   //return promise object
      if(success){
         resolve('success');  //onFullfiled
      }else{
         reject('error');     //onRejected
      }
   })
}

2. Обработка обещаний:

Объект Promise имеет 3 метода для обработки объектов обещаний: -

1.Promise.prototype.catch (onRejected)

2.Promise.prototype.then (onFullfiled)

3.Promise.prototype.finally (onFullfiled, onRejected)

example.then((data) =>{
  //handles resolved data
  console.log(data); //prints success     
}).catch((err) => {
  //handles rejected error 
  console.log(err);  //prints error
})