在ES6 + babel中使用bluebird承诺导入类(构造函数)

Promisify imported class (constructor) with bluebird in ES6 + babel

本文关键字：导入 承诺 构造函数 bluebird ES6 babel      更新时间：2023-09-26

假设我创建或拥有一个node.js库lib.js 

export class C {
    constructor(value, callback) {
        callback(false, `Hello ${value}`);
    }
    task(value, callback) {
        callback(false, "returned " + value);
    }
}

重要的部分是类的构造函数需要接受回调，因为它进行数据库连接和文件I/O。如果我现在导入并使用库回调样式，一切都很好(参见下面的c1)。

我真的很想承诺我使用的库使对象构造更方便(实际上它是一大堆类和方法)。

然而，我找不到一种方法来new类正确地承诺安全很好。

import Promise from 'bluebird';
import * as lib from './lib';

Promise.promisifyAll(lib);

// old style -- works as expected
const c1 = new lib.C("c1", (e, v) => {
    console.log(c1, e, v); 
});

// assuming c1 got initialized, .task() also works
c1.task("t1", console.log);
c1.taskAsync("t2").then(() => console.log("also works"));

// But how to do this properly with promises?
const c2 = new lib.C("c2"); c2.then(console.log); // clearly doesn't work, lack of callback
const c3 = new lib.CAsync("c3"); c3.then(console.log); // "cannot read property apply of undefined"
const c4 = ???

我该如何做得最好?更改库签名不是一个好选择，创建工厂方法似乎也很难看。

我对此有强烈的感觉，所以我将从它开始:不要在构造函数中做IO，将IO和构造函数绑定在一起是一个坏主意。

也就是说，如果您必须这样做，因为库超出了您的控制范围，并且可以接受失去以同步方式构建对象的能力，则可以: 
export class C {
    constructor(value, callback) {
        callback(false, `Hello ${value}`);
    }
    task(value, callback) {
        callback(false, "returned " + value);
    }
}

承诺时:

import Promise from 'bluebird';
import * as lib from './lib';

Promise.promisifyAll(lib);
var old = lib.C; // reference the constructor
lib.C = function(value){ // override it
  o; // object we'll later return, populate in promise constructor
  var p = new Promise(function(resolve, reject){ 
    // the promise constructor is always sync, so the following works
    o = new old(value, function(err, data) {
      if(err) return reject(err);
      resolve(data);   
    });
  }); 
  // THIS IS THE IMPORTANT PART
  o.then = p.then.bind(p); // make the object a thenable, 
  return o
};

这将让你同时使用返回值和承诺，承诺将只有一个then，所以你可能想要Promise.resolve它得到一个"真正的"承诺，而不是一个对象的属性和一个承诺。

var o = new lib.C(); // get object
o.then(function(data){
    // access data
});

这可以被提取成一个模式:

 function promisifyConstructor(cons){
   return function(...args) => { // new constructor function
     let o;
     let p = new Promise((resolve, reject) => {
         // delegate arguments
        o = new cons(...args, (err, data) => err ? reject(err) : resolve(data));
     });
     o.then = p.then.bind(p);
     return o;
   }
 }

您不能直接承诺构造函数(我知道)，但您可以通过工厂方法轻松解决这个问题:

function createC(value) {
  return new Promise(function (res, rej) {
    var c = new C(value, function (err, val) {
      if (err) {
        rej(err);
      } else {
        res(val); // or res(c) if you prefer
      }
    });
  });
}

我认为没有比这更漂亮的方法了，一个构造良好的工厂不应该太丑。您可以将工厂泛化为采用该形式的任何构造函数，但这样您就接近了完全的DI，并且可能值得寻找一个承诺友好的DI库。

相关文章：