Разве обещания не являются просто обратными вызовами?

Question

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

Кажется, что все, что я делаю, это изменения:

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
          });
     });
});

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

Итак, в чем суета обещаний?

Answer 1

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

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.
});

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

Answer 2

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

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

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

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

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

• Вам не нужно знать обратные вызовы, которые будут использовать значение до завершения задачи.
• Вместо ожидания обратных вызовов в качестве аргументов для ваших функций, вы можете легко return объект Promise
• В обещании будет сохранено значение, и вы сможете прозрачно добавить обратный вызов, когда захотите. Он будет вызван, когда будет доступен результат. "Прозрачность" подразумевает, что когда у вас есть обещание и вы добавляете к нему обратный вызов, для вашего кода не имеет значения, достигнут ли результат - API и контракты одинаковы, что значительно упрощает кэширование / запоминание.
• Вы можете легко добавить несколько обратных вызовов

Обещания являются связными (монадические, если хотите):

• Если вам нужно преобразовать значение, которое представляет обещание, вы сопоставляете функцию преобразования с обещанием и получаете новое обещание, которое представляет преобразованный результат. Вы не можете синхронно получить значение, чтобы использовать его каким-либо образом, но вы можете легко отменить преобразование в контексте обещания. Нет стандартных обратных вызовов.
• Если вы хотите связать две асинхронные задачи, вы можете использовать .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 Функция создает обещание для комбинированного результата нескольких обещаний параллельного ожидания.

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

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

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

Answer 3

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

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

Как отметил oligofren, без аргументов между вызовами API вам не нужны анонимные функции-оболочки:

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

И, наконец, если вы хотите достичь сверхмассивного уровня черной дыры, можно ожидать Promises:

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

    return api3Result;
}

Answer 4

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

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

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

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

2. Инверсия контроля

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

См. Цикл событий Javascript для объяснения.

В Promises управление находится в вызывающей программе. Метод.then() может быть вызван в любое время, если мы сохраним объект обещания.

Answer 5

В дополнение к другим ответам, синтаксис 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
});

Answer 6

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

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

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

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

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

Answer 7

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

Answer 8

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

пример Вы можете использовать нативные обещания 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

Answer 9

Обзор обещаний:

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

Обещание всегда имеет 3 следующих состояния:

1. pending: начальное состояние каждого обещания, ни выполнено, ни отклонено.
2. выполнено: операция успешно завершена.
3. отклонено: операция не удалась.

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

1. Promise.prototype.then(): Когда обещание разрешено, будет вызван аргумент обратного вызова этой функции.
2. Promise.prototype.catch(): Когда обещание отклоняется, вызывается аргумент обратного вызова этой функции.

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

пример

function createProm(resolveVal, rejectVal) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() > 0.5) {
                console.log("Resolved");
                resolve(resolveVal);
            } else {
                console.log("Rejected");
                reject(rejectVal);
            }
        }, 1000);
    });
}

createProm(1, 2)
    .then((resVal) => {
        console.log(resVal);
        return resVal + 1;
    })
    .then((resVal) => {
        console.log(resVal);
        return resVal + 2;
    })
    .catch((rejectVal) => {
        console.log(rejectVal);
        return rejectVal + 1;
    })
    .then((resVal) => {
        console.log(resVal);
    })
    .finally(() => {
        console.log("Promise done");
    });

• Функция createProm создает обещания, которые разрешаются или отклоняются на основе случайного Nr через 1 секунду.
• Если обещание разрешено, первое then вызывается метод, и разрешенное значение передается в качестве аргумента обратного вызова
• Если обещание отклонено, первое catch вызывается метод, и отклоненное значение передается в качестве аргумента
• В catch а также thenметоды возвращают обещания, поэтому мы можем связать их. Они заключают любое возвращаемое значение вPromise.resolve и любое выброшенное значение (используя throw ключевое слово) в Promise.reject. Таким образом, любое возвращаемое значение преобразуется в обещание, и для этого обещания мы снова можем вызвать функцию-обработчик.
• Цепочки обещаний дают нам более точный контроль и лучший обзор, чем вложенные обратные вызовы. Например,catch обрабатывает все ошибки, которые произошли до catch обработчик.

Answer 10

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

---

В программе есть шаги, которые мы хотим делать последовательно.

      function f() {
   step_a();
   step_b();
   step_c();
   ...
}

Обычно информация передается между каждым шагом.

      function f() {
   const a = step_a(   );
   const b = step_b( a );
   const c = step_c( b );
   ...
}

Некоторые из этих шагов могут занять (относительно) много времени, поэтому иногда вы хотите выполнять их параллельно с другими делами. Один из способов сделать это — использовать потоки. Другой — асинхронное программирование. (У обоих подходов есть свои плюсы и минусы, которые здесь обсуждаться не будут.) Здесь мы говорим об асинхронном программировании.

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

      // Each of step_* calls the provided function with its return value once complete.
function f() {
   step_a(
      function( a )
         step_b(
            function( b )
               step_c(
                  ...
               )
            },
         )
      },
   )
}

Это довольно тяжело читать. Обещания предлагают способ сгладить код.

      // Each of step_* returns a promise.
function f() {
   step_a()
   .then( step_b )
   .then( step_c )
   ...
}

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

Несмотря на то, что промисы помогают, использовать промисы все же немного сложно. Вот тут-то и пригодится. В функции, объявленной какasync,awaitможно использовать вместоthen.

      // Each of step_* returns a promise.
async function f()
   const a = await step_a(   );
   const b = await step_b( a );
   const c = await step_c( b );
   ...
}

Это, несомненно, намного читабельнее, чем использование обратных вызовов.

Answer 11

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