Вот скрипка для проверки

и вместо

api(function(result){
    api2(function(result2){
        api3(function(result3){
             // do work
        });
    });
});

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

api().then(function(result){
     api2().then(function(result2){
          api3().then(function(result3){
               // do work
          });
     });
});

Так как

Так в чем же суть обещаний?

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

api().then(function(result){
    return api2();
}).then(function(result2){
    return api3();
}).then(function(result3){
     // do work
});

Конечно, не намного меньше кода, но гораздо более читабельно.

Например:

api().then(function(result){
    return api2();
}).then(function(result2){
    return api3();
}).then(function(result3){
     // do work
}).catch(function(error) {
     //handle any error that may occur before this point
});

Практически так же, как try { ... } catch.

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

api().then(function(result){
    return api2();
}).then(function(result2){
    return api3();
}).then(function(result3){
     // do work
}).catch(function(error) {
     //handle any error that may occur before this point
}).then(function() {
     //do something whether there was an error or not
     //like hiding an spinner if you were performing an AJAX request.
});

И даже лучше: что, если эти 3 вызова api, api2, api3 могут выполняться одновременно (например, если это были вызовы AJAX), но вам нужно подождать этих трех? Без обещаний вам придется создать какой-то счетчик. С обещаниями, использующими нотацию ES6, это еще один кусок пирога и довольно аккуратный:

Promise.all([api(), api2(), api3()]).then(function(result) {
    //do work. result is an array contains the values of the three fulfilled promises.
}).catch(function(error) {
    //handle the error. At least one of the promises rejected.
});

Надеюсь, вы видите Обещания в новом свете.

так как функции стрелок являются анонимными.

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

Так в чем основная идея?

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

Promises реализует шаблон наблюдателя:

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

Событие: нажмите кнопку. Очередь за событием: ( monadic , если хотите):

  • Если вам нужно преобразовать значение, которое представляет обещание, вы Какие символы допустимы для имен переменных JavaScript? функции преобразования над обещанием и получите новое обещание, которое представляет преобразованный результат. Вы не можете синхронно получить значение, чтобы использовать его каким-либо образом, но вы можете легко lift преобразования в контексте обещания. Нет стандартных обратных вызовов.
  • Если вы хотите связать две асинхронные задачи, вы можете использовать сложные .then() метод. Он будет вызывать обратный вызов с первым результатом и возвращает обещание для результата обещания, которое возвращает обратный вызов.

звуки? Время для примера кода.

var p1 = api1(); // returning a promise
var p3 = p1.then(function(api1Result) {
    var p2 = api2(); // returning a promise
    return p2; // The result of p2 …
}); // … becomes the result of p3

// So it does not make a difference whether you write
api1().then(function(api1Result) {
    return api2().then(console.log)
})
// or the flattened version
api1().then(function(api1Result) {
    return api2();
}).then(console.log)

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

api1().then(api2).then(api3).then(/* do-work-callback */);

Если просмотр кода этих методов помогает понять, , вот самая основная библиотека обещаний в несколько строк Глядя на вывод

В чем суть обещаний?

Абстракция Promise позволяет намного лучше комбинировать функции. Например, рядом с then для создания цепочки, all если вы знаете, что хотите просто массив. Я также не рекомендую обходить и переопределять Array …

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

Не говоря уже о необходимости превращать вещи в обещания.

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

В дополнение к уже установленные ответы с функциями стрелок ES6 Обещания превращаются из скромно сияющего маленького синего карлика прямо в красного гиганта. Это вот-вот рухнет в сверхновую:

api().then(result => api2()).then(result2 => api3()).then(result3 => console.log(result3))

Как является полизаполненным. , без аргументов между вызовами API вам не нужны анонимная оболочка работает вообще:

api().then(api2).then(api3).then(r3 => console.log(r3))

в новую строку абзаца, он недостаточно «силен» для переопределения текущего размера шрифта & amp ; style line-height

async function callApis() {
    let api1Result = await api();
    let api2Result = await api2(api1Result);
    let api3Result = await api3(api2Result);

    return api3Result;
}

В дополнение к другим ответам синтаксис ES2015 плавно сочетается с обещаниями, сокращая еще больше стандартного кода:

// Sequentially:
api1()
  .then(r1 => api2(r1))
  .then(r2 => api3(r2))
  .then(r3 => {
      // Done
  });

// Parallel:
Promise.all([
    api1(),
    api2(),
    api3()
]).then(([r1, r2, r3]) => {
    // Done
});

В дополнение к удивительным ответам выше, можно добавить еще 2 пункта:

1. Семантическая разница:

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

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

2. Инверсия элемента управления

(популярно в узле) Хотя это не самый простой способ, вы можете сделать это:

(90 мс против 115 мс) Цикл событий Javascript для объяснения. Атрибут

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

Обещания не являются обратными вызовами, оба являются идиомами программирования, которые облегчают асинхронное программирование. Использование асинхронного / await-стиля программирования с использованием сопрограмм или генераторов, которые возвращают обещания, может рассматриваться как третья такая идиома. Сравнение этих идиом в разных языках программирования (включая Javascript) здесь: с обещаниями.

Никакие обещания не являются просто оберткой для обратных вызовов

. Вы можете использовать собственные обещания javascript с узлом js

my cloud 9 code link : https://ide.c9.io/adx2803/native-promises-in-node

/**
* Created by dixit-lab on 20/6/16.
*/

var express = require('express');
var request = require('request');   //Simplified HTTP request client.


var app = express();

function promisify(url) {
    return new Promise(function (resolve, reject) {
    request.get(url, function (error, response, body) {
    if (!error && response.statusCode == 200) {
        resolve(body);
    }
    else {
        reject(error);
    }
    })
    });
}

//get all the albums of a user who have posted post 100
app.get('/listAlbums', function (req, res) {
//get the post with post id 100
promisify('http://jsonplaceholder.typicode.com/posts/100').then(function (result) {
var obj = JSON.parse(result);
return promisify('http://jsonplaceholder.typicode.com/users/'   obj.userId   '/albums')
})
.catch(function (e) {
    console.log(e);
})
.then(function (result) {
    res.end(result);
}
)

})


var server = app.listen(8081, function () {

var host = server.address().address
var port = server.address().port

console.log("Example app listening at http://%s:%s", host, port)

})


//run webservice on browser : http://localhost:8081/listAlbums

Нет, совсем нет.

(популярно в узле) — это просто Functions In JavaScript , который должен быть вызван и затем выполнен после завершения выполнения другой функции. Так как это происходит?

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

Вот мое решение (newUrl — ваш новый URL, который вы хотите заменить на текущий): { *} С ES6 (или с помощью Babel или Typescipt) вы можете просто сделать: — не что иное, как гораздо более импровизированный подход к обработке и структурированию асинхронного кода по сравнению с тем же самым с обратными вызовами.

По сути, таким образом вы комбинируете вещи, потому что jQuery — это фреймворк, который в основном фокусируется на HTML-элементах, вы в основном предотвращаете использование по умолчанию, но в то же время вы останавливаете распространение, чтобы всплыть.