不，一点也不。

回调函数是JavaScript中的函数，在另一个函数执行完成后，将被调用并执行。那么它是如何发生的呢?

实际上，在JavaScript中，函数本身被视为对象，因此也被视为所有其他对象，甚至函数也可以作为参数发送给其他函数。人们能想到的最常见和最通用的用例是JavaScript中的setTimeout()函数。

承诺只是一种处理和构造异步代码的临时方法，而不是用回调来做同样的事情。

Promise在构造函数中接收两个回调:resolve和reject。承诺中的这些回调为我们提供了对错误处理和成功案例的细粒度控制。当promise执行成功时使用resolve回调，而reject回调用于处理错误情况。

没有承诺只是回调的包装

例子 你可以在node js中使用javascript原生承诺

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

承诺不是回调。promise表示异步操作的未来结果。当然，按照你的方式来写，收效甚微。但是如果你按照它们应该被使用的方式来编写它们，你可以用一种类似于同步代码的方式来编写异步代码，并且更容易遵循:

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

几乎和尝试{…} 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调用)，但你需要等待这3个调用，那该怎么办?如果没有承诺，你就必须创造出某种反击。有了承诺，使用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.
});

希望你现在能从新的角度看待承诺。

Promises允许程序员编写比使用回调更简单、更易读的代码。

在一个程序中，有一系列的步骤需要执行。

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

每一步之间通常都有信息传递。

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

其中一些步骤可能会花费(相对)较长的时间，所以有时您希望与其他事情并行执行这些步骤。一种方法是使用线程。另一个是异步编程。(这两种方法各有利弊，这里不再讨论。)这里，我们讨论的是异步编程。

在使用异步编程时，实现上述目标的简单方法是提供一个回调函数，在步骤完成时调用它。

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

这很难读懂。承诺提供了一种简化代码的方法。

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

返回的对象被称为promise，因为它代表了函数的未来结果(即承诺的结果)(可以是值或异常)。

尽管承诺很有帮助，但使用承诺还是有点复杂。这就是async和await的用武之地。在声明为async的函数中，可以使用await来代替then。

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

不可否认，这比使用回调可读性强得多。

除了其他答案，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
});

JavaScript的Promise实际上使用回调函数来确定Promise被解析或拒绝后要做什么，因此两者并没有本质上的不同。Promises背后的主要思想是采用回调——特别是在您想要执行某种操作的地方嵌套回调，但它将更易于阅读。