用于奇异控制流的 ES6 Promise 模式

ES6 Promise 很棒。到目前为止，调整我的想法很容易 回调习惯用法。我发现它自然地鼓励更多的模块化代码，并且 当然错误处理更加清晰。

但有几次我遇到了看起来不像（？）的心流情况 可以很容易地从节点返回到承诺（也许就是这样，但也许我只是对答案视而不见）。由于承诺是不可知的 关于下一个操作（或者如果有的话），它似乎很难使用 API 的 Promise 不仅接受回调，还接受return them.

我想到的最常见的例子是“done”回调。它出现在数据库连接之类的东西中，表示“将连接返回到池”，但我也看到它出现在很多其他地方。

function getSomeStupidConnection(cb) {
    var conn = /* ... */;
    var iNeedToBeToldWhenIAmDone = function() { /* ... */ };

    cb(conn, iNeedToBeToldWhenIAmDone);
}

getSomeStupidConnection(function(conn, done) {
    /* ... */

    conn.doLotsOfStuff(function(soMuchStuff) {

        /* stuff! so much fun! */

        /* okay conn go away I’m tired */

        done();
    });
});

像这样的流程反转显然不是您希望在 API 中出现的内容 首先，但它就在那里，有时你无法真正避免它。和 回调，您可以将“稍后调用”内部回调传递给原始“外部” 打回来。它并不完全导致关注点的彻底分离，但在 至少它既快速又简单。

是否有适合这种情况的基于 Promise 的方法？一种说法是， “这是解析值——但是当链完成时，也执行此操作”？我 怀疑没有什么与我刚才描述的完全相符，因为它 确实不可能说一条链“完成”了，但也许我遗漏了一些 让你接近它而不弄乱的模式......

编辑：根据到目前为止的反馈，我意识到根本没有办法将这样的 API 包装在真正的 Promise 中，因为您返回的 Promise 将永远无法告诉您有关任何后续链式 Promise 的信息。但是你can假装。问题在于，结果相当脆弱。它必须假设唯一的then需要连接对象的是紧随其后的对象。承诺的使用者需要了解这是一次性连接，否则这一点并不明显。因此，我在实践中并不推荐它，但出于好奇，这里有一个隐藏了的解决方案done同时表现为（并最终成为）承诺链：

/* jshint node: true, esnext: true */
'use strict';

// Assume this comes from an external library. It returns a connection and a
// callback to signal that you are finished with the connection.

function getConnectionExternal(cb) {
    let connection = 'Received connection.';
    let done = () => console.log('Done was called.');

    cb(null, connection, done);
}

// Our promisey wrapper for the above

function getConnection() {
    let _done;

    let promise = new Promise((resolve, reject) => {
        getConnectionExternal((err, connection, done) => {

            if (err) return reject(err);

            _done = (val) => {
                done();
                return val;
            };

            resolve(connection);
        });
    });

    let _then = promise.then.bind(promise);

    promise.then = (handler) => _then(handler).then(_done, _done);

    return promise;
}

// Test it out

getConnection()
    .then(connection => {
        console.log(connection);

        return new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log('Finished using connection!');
                resolve('This should be after connection closes.');
            }, 200);
        });
    })
    .then(msg => console.log(msg))
    .catch(err => console.error(err));

控制台打印：

• 已收到连接。
• 使用连接完毕！
• 完成被称为。
• 这应该是在连接关闭之后。

详细阐述 Bergi 的解决方案，这称为处置器模式。它以多种形式存在于多种语言中——with在Python中，using在 C# 中和try(){与 Java 中的资源。有些语言通过析构函数以这种方式本地处理作用域中的资源，例如 C#。

一般的想法是用一个范围来封装一个值的生命周期。在你的情况下是数据库连接。这比打电话要整洁得多done在回调中，因为更容易忘记调用done这会留下打开的连接和资源泄漏。同步地它看起来像：

function scope(cb){
     try{ 
         var conn = getConnection(...);
         return cb(conn);
     } finally {
         conn.release();
     }
}

承诺版本并没有太大不同：

function conn(data){
    var _connection;
    return getConnection().then(function(connection){
        _connection = connection; // keep a reference
        return data(_connection); // pass it to the function
    }).then(function(val){
         // release and forward
         _connection.release(); // if release is async - chain
         return val; 
    }, function(err){
         _connection.release();
         throw err; // forward error
    });
});

哪个会使用：

conn(function(db){
    return db.query("SELECT * FROM ...");
}).then(function(result){ // handle result
    // connection is released here
});