弁言

毛病明白经心组织起来的异步代码还不如运用一团乱麻的回调函数。

在处置惩罚异步的题目上，回调基本上能够胜任，不过这都是建立在一切正常运转的基础上。

然则适得其反，回调遭到掌握反转的影响，把掌握权交给了第三方，这类掌握转移致使了一系列的信托题目（回调挪用过早、回调挪用过晚、回调不被挪用、回调挪用次数过少或过量等题目）。同时，基于回调的异步表达又是无序性的，回调地狱的运用，让我们准确明白代码的难度加大。

函数确实能够躲避以上的题目，然则，毋庸置疑，这会再次加大代码的明白难度。
与其交给不信托的第三方，倒不如转交给一个位于我们和第三方间的可托托的中介机制，这里就是我们要说的 Promise。

回调的转变

怎样把回调交给 Promise， 实在很简单。
运用 Promise 后我们就无需再体贴大部分的信托题目和无序性。由于 Promise 机制已为我们处置惩罚好了，我们不需要写些特定逻辑来处理一些信托题目和并发带来的竞态题目，只需我们根据 Promise 范例准确实行即可。如今，以 setTimeout 代表异步操纵来举行 Promise 革新。

// callback async
const callback_async = (x = Date.now(), callback) => {
    // do something now
    console.log('callback_async:初始时候戳', x)
    setTimeout(() => {
        // do something in the future
        let interval = Date.now() - x
        callback && callback(`callback_async:在${interval}毫秒后异步完成`)
    }, 1000)
}
callback_async(undefined, res => {
    console.log('callback_async:', res)
})

在 Promise 中我们依旧能够看到回调的身影，只是回调作为参数通报的位置发生了变化。我们不再把回调交给第三方，而是让 Promise 从第三方猎取某些数据，然后回调作为参数通报进去。

const promise_async = (x = Date.now()) => {
    return new Promise(resolve => {
        // do something now
        console.log('promise_async:初始时候戳', x)
        setTimeout(() => {
            // do something in the future
            let interval = Date.now() - x
            resolve(`promise_async:在${interval}毫秒后异步完成`)
        }, 1000)
    })
}
promise_async(undefined).then(res => {
    console.log(res)
})

差别之前的把回调直接传给第三方的做法，此次是靠着 Promise 这个中心机制来替异步使命治理着回调。

毛病的处置惩罚

运用 Promise 后，怎样就会好了许多呢？起首说说在毛病的处置惩罚上。
JavaScript 代码在实行的过程当中若碰到毛病就不会实行下去的。作为传入第三方的回调（同步回调或异步回调），假如在此之前就已报错了，回调压根不会实行。在这类情况下，能经由过程回调捕获毛病，也是很有意义的。我们很自然地想到了 try...catch , 不过在异步回调中，回调函数的实行栈与原函数分离开，致使外部是没法捉住非常。不过没紧要，我们就多捕获一遍。

在此，我们就用“error-first作风”模仿一下。

// callback async
const callback_async = (x = Date.now(), callback) => {
    try {
        console.log('callback_async:初始时候戳', x)
        // do something now
        // throw 'callback-outer: error'
        setTimeout(() => {
            try {
                // do something in the future
                // throw 'callback-inner: error'
                let interval = Date.now() - x
                callback && callback(null, `callback_async:在${interval}毫秒后异步完成`)
            } catch (error) {
                callback(error)
            }
        }, 1000)
    } catch (error) {
        callback(error)
    }
}
callback_async(undefined, (error, res) => {
    error?console.log('asyncError:', error):console.log('async:', res)
})

顺次解开解释 throw ... ，我们就能够成功地捕获到毛病或非常。但同时也发明，关于一个不停嵌套的异步回调，就回调地狱那样，我们会为每个异步回调做 try...catch 的毛病处置惩罚，这会使原有的代码越发杂沓。

“荣幸”的是，Promise 已为我们处置惩罚好了这个题目。关于毛病或非常，我们只需要注册 rejected 或 catch 的回调即可。不过 Promise 也存在着和上面雷同的题目，没法捕获离开上下文环境的毛病或非常，我们只能收到手动 reject。

const promise_async = (x = Date.now()) => {
    return new Promise((resolve, reject) => {
        // do something now
        // throw 'promise-outer: error'
        console.log('promise_async:初始时候戳', x)
        setTimeout(() => {
            try {
                // do something in the future
                // throw 'promise-inner: error'
                let interval = Date.now() - x
                resolve(`promise_async:在${interval}毫秒后异步完成`)
            } catch (error) {
                reject(error)
            }
        }, 1000)
    })
}
promise_async(undefined).catch(error => {
    console.log(error)
})

关于多个异步使命，Promise 依然能够很好的处置惩罚毛病，由于 Promise 运用的 this-then-that 的流程掌握，默许处置惩罚函数只是把毛病从新抛出，这使得毛病能够继承沿着Promise链流传下去，直到显式的 rejected 或 catch 捕获毛病。

Promise化

Promise 带来的优点远远不止这些。一旦 Promise 决定， 它就永久坚持这个状况，这个 Promise 的 .then(...) 注册的回调就会被自动挪用，且只会被挪用一次。这也算处理了回调挪用过少、过量及不被挪用的题目。纵然不能处理，但也能够在此基础上再做处置惩罚。你如果问为何，我只能说人家就是干这个的，作为一个可托托的中心协商机制。

说到一旦决定就不能转变，这个很主要么，是的，真的很主要。
在基于回调情势的异步处置惩罚中，JavaScript 代码实行后会一向走下去，碰到回调就直接实行了。然则 Promise 决定后，能够一向保留着这个效果，经由过程 .then(..) 情势增加的回调函数，甚至在异步操纵完成以后才增加的回调函数，都邑被实行挪用。这也是上一个 Promise 里的毛病只能在 Promise 链的下一个回调里捕获的缘由。

知道了 Promise 的优点，也知道了基于回调情势的异步处置惩罚体式格局，我们就能够尝试把“error-first作风”的回调 Promise 化。

// Promise Wrap
var promise_wrap = function(fn){
    return function() {
        let args = Array.from(arguments);
        return new Promise((resolve, reject) => {
            fn.apply(null, args.concat((error, value) => {
                error ? reject(error): resolve(value)
            }))
        })
    }
}

在这里我们能够看到，为了一致处置惩罚如今和未来，我们把它们都变成了未来，即一切的操纵都成了异步，同步回调也变成了异步回调。

JavaScript 非常毛病也是云云，在 Promise 建立过程当中或检察决定效果过程当中涌现的非常毛病，这个非常毛病被捕获都邑变成异步行动。如许做减少了由函数递次不确定性（竞态前提）带来的诸多题目。

坚持扁平化

从回调情势跨到 Promise，总会不小心保留着本来的作风，比方嵌套。
Promise 链式编程最好坚持扁平化，不然不就变成另一个回调地狱了？关键是还没有返回或停止 Promise 链。

// parallel Promise
var parallel_promise = (x = Date.now()) => {
    Promise.resolve().then(() => {
        new Promise(resolve => {
            setTimeout(() => {
                let interval = Date.now() - x;
                resolve(`parallel-inner:在${interval}毫秒后完成`)
            }, 3000)
        }).then(res => {
            console.log(res)
        })
    }).then(res => {
        let interval = Date.now() - x;
        console.log(`parallel-outer:在${interval}毫秒后完成; res: ${res}`)
    })
}
parallel_promise(undefined)

从上面的实行效果能够看出，parallel-outer 并非在 parallel-inner 后实行。这是没有准确将 Promise 相连接的效果。

实际上，这里就是两个自力合作的 Promise（同时在实行异步使命而不是一个接着一个）。同时我们也会注意到外层 then(...) 注册回调中 res 为 undefined，由于关于没有任何显式的决定，这个值就是 undefined。

// serial Promise
var serial_promise = (x = Date.now()) => {
    Promise.resolve().then(() => {
        return new Promise(resolve => {
            setTimeout(() => {
                let interval = Date.now() - x;
                resolve(`serial-1:在${interval}毫秒后完成`)
            }, 3000)
        }).then(res => {
            console.log(res)
            return res
        })
    }).then(res => {
        let interval = Date.now() - x;
        console.log(`serial-2:在${interval}毫秒后完成; res: ${res}`)
    })
}
serial_promise(undefined)

所以说，

一个好的履历法则是老是返回或停止Promise链，而且一旦获得一个新的Promise，返回它。

小结

用 Promise 来表达异步和治理并发无疑是种提高，它在顺序的递次性和可托托性上供应了本身的处理计划。它不是回调的替代品，只是帮着异步使命治理回调的可托托的中心机制。

相关于直接粗犷的回调，Promise 并不会带来性能上的提拔，然则它会让我们的顺序越发硬朗，也使得代码越发简约，越发相符我们有序的头脑体式格局。

固然，Promise 也有本身的局限性。在并发 Promise.race(...) 上，我们只需第一个决定即可。当涌现第一个决定的 Promise 时，别的的 Promise 就没有必要举行下去了。然则，我们没把法停止。

在毛病处置惩罚上，Promise 链中毛病老是由下一个 Promise 捕获。假如毛病发生在末了一个 Promise 呢？另有，关于嵌套的 Promise，内部 Promise 已举行了毛病处置惩罚，然则外部 Promise 却捕获不到，如许真的好么？

Promise 恢复了可托托性，但我们还想让异步流程的表达作风更切近同步的情势，链式挪用不说不好，只是我们带着同步操纵的惯性。还好，ES6、ES7已给出了计划。