Анализ использования обещания Nodejs

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

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

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

Обещание - это объект с методом «.Then ()», который представляет результат операции, которая еще не может быть известна. Независимо от того, кто обращается к этому объекту, он может использовать метод «.Then ()», чтобы добавить обратный вызов, чтобы дождаться напоминания о том, чтобы ждать операции, чтобы получить успешный результат или сбой.

Так почему же преимущества выполняют это лучше, чем обратные вызовы? Стандартный режим обратного вызова требует, чтобы мы предоставили функции обратного вызова одновременно при обработке запросов:

 request (url, function (ошибка, ответ) {// Обработка успеха или ошибки.}); doSomethingElse ();

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

 QuerythedAtabase (запрос, функция (ошибка, результат) {request (url, function (ошибка, ответ) {dosomethingElse (ответ, функция (ошибка, результат) {doAnotherthing (result, function (ошибка, результат) {recept (oreverurl, function (ошибка, ответ) {...});});});});});});});});

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

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

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

var promise = dosomethingaync ()

Обещание.

Когда это обещание разрешено, то есть после завершения асинхронного процесса, либо будет вызвано и нанесено в действие.

Следовательно, обещание имеет следующие три разных состояния:

■ В ожидании обещания - начальное состояние обещания

■ выполненная обязательства по реализации-Успешное государство реализации

■ отклонил отказ от приверженности - государство, в котором обещание не удалось

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

 readfile (function (err, data) {if (err) return console.error (err) console.log (data)})

Если наша функция Readfile возвращает обещание, то мы можем реализовать ту же логику следующим образом (выходная печать):

var promise = readfile ()

Обещание.

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

Понять обещание

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

var promise = readfile ()

var promise2 = promis.Then (readanotherfile, console.error)

Здесь тогдашний параметр readanotherfile, console.Error представляет действие, наполненное после того, как асинхронная операция будет успешной или действие, после успеха после успеха. То есть после выполнения функции readanotherfile, в противном случае неудачная запись печати неверна. Эта реализация возможна только двумя способами.

Давайте посмотрим на следующий код:

 var promise = readfile () var promise2 = promis.Then (function (data) {return readAnotherfile () // Если ReadFile преуспевает, выполнять receute readanotherfile}, function (err) {console.Error (err) // Если readfile не успешна, нопит, но все еще выполняет readanotherfile returnath Результат выполнения функции readanotherfile

Потому что затем возвращает обещание, это означает, что обещание можно потратить, цепляя серийную цепь, что может избежать ада обратного вызова:

 readfile () .then (readanotherfile) .then (dosomethingelseelse) .then (...)

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

(1) .then () всегда возвращает новое обещание. Каждый раз, когда вы называете это, не имеет значения, что делает обратный вызов, потому что .Then () уже дает вам обещание до того, как будет вызван обратный вызов. Поведение обратного вызова только влияет на реализацию обещания обещания. Если обратный вызов возвращает значение, то обещание будет использовать это значение. Если это значение является обещанием, верните значение после реализации обещания к этому значению. Если обратный вызов бросает ошибку, обещание отклонит ошибку.

(2) Обещание, возвращаемое .Then () - это новое обещание, которое отличается от тех, что называется (). Длинная цепь обещаний иногда скрывает тот факт, что, несмотря ни на что, каждый призыв .Then () даст новое обещание. Здесь вы должны отметить, что вам действительно нужно учитывать, что ваш последний вызов. Then () может представлять собой неудачу, поэтому, если вы не поймете эту неудачу, легко привести к исчезновению вашего исключения ошибки.

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

 function getTasks () {return $ http.get ('http://example.com/api/v1/tasks') .then (function (response) {return response.data;});} function getMyTasks () {return getTasks () .Then (tasks) {return filtertasks (tasks, amersmas, {ampors) {anersame). });}

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

Интересное обещание

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

 var taskspromise; Функция getTasks () {TaskPromise = TaskPromise || getTasksFromTheServer (); return taskpromise;}

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

Использование Nodejs Spearing выше - это все контент, которым я делюсь с вами. Я надеюсь, что вы можете дать вам ссылку, и я надеюсь, что вы сможете поддержать Wulin.com больше.