Question

我如何才能最好地处理以下情况？

我有一个构造函数需要一段时间才能完成。

var Element = function Element(name){
   this.name = name;
   this.nucleus = {};

   this.load_nucleus(name); // This might take a second.
}

var oxygen = new Element('oxygen');
console.log(oxygen.nucleus); // Returns {}, because load_nucleus hasn't finished.

我看到三个选项，每个选项都与众不同。

一个，向构造函数添加回调。

var Element = function Element(name, fn){
   this.name = name;
   this.nucleus = {};

   this.load_nucleus(name, function(){
      fn(); // Now continue.
   });
}

Element.prototype.load_nucleus(name, fn){
   fs.readFile(name+'.json', function(err, data) {
      this.nucleus = JSON.parse(data); 
      fn();
   });
}

var oxygen = new Element('oxygen', function(){  
   console.log(oxygen.nucleus);
});

两个，使用EventEmitter发出'已加载'事件。

var Element = function Element(name){
   this.name = name;
   this.nucleus = {};

   this.load_nucleus(name); // This might take a second.
}

Element.prototype.load_nucleus(name){
   var self = this;
   fs.readFile(name+'.json', function(err, data) {
      self.nucleus = JSON.parse(data); 
      self.emit('loaded');
   });
}

util.inherits(Element, events.EventEmitter);

var oxygen = new Element('oxygen');
oxygen.once('loaded', function(){
   console.log(this.nucleus);
});

或三个，阻止构造函数。

var Element = function Element(name){
   this.name = name;
   this.nucleus = {};

   this.load_nucleus(name); // This might take a second.
}

Element.prototype.load_nucleus(name, fn){
   this.nucleus = JSON.parse(fs.readFileSync(name+'.json'));
}

var oxygen = new Element('oxygen');
console.log(oxygen.nucleus)

但我之前没有见过这些。

我还有其他选择吗？

Answer 1

更新2：这是使用异步工厂方法的更新示例。注：如果在浏览器中运行，则需要Node 8或Babel。

class Element {
    constructor(nucleus){
        this.nucleus = nucleus;
    }

    static async createElement(){
        const nucleus = await this.loadNucleus();
        return new Element(nucleus);
    }

    static async loadNucleus(){
        // do something async here and return it
        return 10;
    }
}

async function main(){
    const element = await Element.createElement();
    // use your element
}

main();

更新：下面的代码被投票了几次。但是我发现这种方法使用静态方法更好： https://stackoverflow.com/a/24686979/2124586

使用承诺的ES6版本

class Element{
    constructor(){
        this.some_property = 5;
        this.nucleus;

        return new Promise((resolve) => {
            this.load_nucleus().then((nucleus) => {
                this.nucleus = nucleus;
                resolve(this);
            });
        });
    }

    load_nucleus(){
        return new Promise((resolve) => {
            setTimeout(() => resolve(10), 1000)
        });
    }
}

//Usage
new Element().then(function(instance){
    // do stuff with your instance
});

Answer 2

鉴于必须避免在Node中阻塞，事件或回调的使用并不那么奇怪^（1）。

稍微编辑一下，你可以将它与One合并：

var Element = function Element(name, fn){
    this.name = name;
    this.nucleus = {};

    if (fn) this.on('loaded', fn);

    this.load_nucleus(name); // This might take a second.
}

...

虽然，与示例中的fs.readFile一样，核心Node API（至少）通常遵循静态函数的模式，这些函数在数据准备好时公开实例：

var Element = function Element(name, nucleus) {
    this.name = name;
    this.nucleus = nucleus;
};

Element.create = function (name, fn) {
    fs.readFile(name+'.json', function(err, data) {
        var nucleus = err ? null : JSON.parse(data);
        fn(err, new Element(name, nucleus));
    });
};

Element.create('oxygen', function (err, elem) {
    if (!err) {
        console.log(elem.name, elem.nucleus);
    }
});

（1）读取JSON文件不需要很长时间。如果是，也许存储系统的变化是为了数据。

Answer 3

你可以做的一件事是预加载所有原子核（可能效率低下;我不知道它有多少数据）。另一个，我建议如果预加载不是一个选项，将涉及一个带缓存的回调来保存加载的核。这是方法：

Element.nuclei = {};

Element.prototype.load_nucleus = function(name, fn){
   if ( name in Element.nuclei ) {
       this.nucleus = Element.nuclei[name];
       return fn();
   }
   fs.readFile(name+'.json', function(err, data) {
      this.nucleus = Element.nuclei[name] = JSON.parse(data); 
      fn();
   });
}

Answer 4

我开发了一个异步构造函数：

function Myclass(){
 return (async () => {
     ... code here ...
     return this;
 })();
}

(async function() { 
 let s=await new Myclass();
 console.log("s",s)
})();

async returns a promise
arrow functions pass 'this' as is
在做new时可以返回别的东西（你仍然在这个变量中得到一个新的空对象。如果你在没有new的情况下调用该函数。你得到原始的。就像window或global或它的hold对象）。
可以使用await返回被调用异步函数的返回值。
在正常代码中使用await，需要使用异步匿名函数来包装调用，即可立即调用。（被调用的函数返回promise并且代码继续）

我的第一次迭代是：

可能只是添加一个回调

调用匿名异步函数，然后调用回调。

function Myclass(cb){
 var asynccode=(async () => { 
     await this.something1();
     console.log(this.result)
 })();

 if(cb)
    asynccode.then(cb.bind(this))
}

我的第二次迭代是：

让我们尝试使用promise而不是回调。我心想：奇怪的是，一个承诺会回来，但它确实有效。 ..所以下一个版本只是一个承诺。

function Myclass(){
 this.result=false;
 var asynccode=(async () => {
     await new Promise (resolve => setTimeout (()=>{this.result="ok";resolve()}, 1000))
     console.log(this.result)
     return this;
 })();
 return asynccode;
}


(async function() { 
 let s=await new Myclass();
 console.log("s",s)
})();

基于回调的旧javascript

function Myclass(cb){
 var that=this;
 var cb_wrap=function(data){that.data=data;cb(that)}
 getdata(cb_wrap)
}

new Myclass(function(s){

});

Answer 5

这是一个糟糕的代码设计。

主要问题是回调你的实例它还没有执行“返回”，这就是我的意思

var MyClass = function(cb) {
  doAsync(function(err) {
    cb(err)
  }

  return {
    method1: function() { },
    method2: function() { }
  }
}

var _my = new MyClass(function(err) {
  console.log('instance', _my) // < _my is still undefined
  // _my.method1() can't run any methods from _my instance
})
_my.method1() // < it run the function, but it's not yet inited

因此，良好的代码设计是在实例化类

后显式调用“init”方法（或在您的情况下为“load_nucleus”）

var MyClass = function() {
  return {
    init: function(cb) {
      doAsync(function(err) {
        cb(err)
      }
    },
    method1: function() { },
    method2: function() { }
  }
}

var _my = new MyClass()
_my.init(function(err) { 
   if(err) {
     console.error('init error', err)
     return
   } 
   console.log('inited')
  // _my.method1()
})

Answer 6

我将异步部分提取出一个流畅的方法。按惯例，我一起叫他们。

＆＃13;

class FooBar {
  constructor() {
    this.foo = "foo";
  }
  
  async create() {
    this.bar = await bar();

    return this;
  }
}

async function bar() {
  return "bar";
}

async function main() {
  const foobar = await new FooBar().create(); // two-part constructor
  console.log(foobar.foo, foobar.bar);
}

main(); // foo bar

＆＃13;

我尝试了一种包装new FooBar()的静态工厂方法，例如FooBar.create()，但它在继承方面表现不佳。如果您将FooBar延伸到FooBarChild，FooBarChild.create()仍会返回FooBar。鉴于我的方法new FooBarChild().create()将返回FooBarChild，并且可以轻松地使用create()设置继承链。

Answer 7

您可以通过nsynjs同步运行具有异步功能的构造函数。这是一个例子来说明：

index.js（主app逻辑）：

var nsynjs = require('nsynjs');
var modules = {
    MyObject: require('./MyObject')
};

function synchronousApp(modules) {
    try {
        var myObjectInstance1 = new modules.MyObject('data1.json');
        var myObjectInstance2 = new modules.MyObject('data2.json');

        console.log(myObjectInstance1.getData());
        console.log(myObjectInstance2.getData());
    }
    catch (e) {
        console.log("Error",e);
    }
}

nsynjs.run(synchronousApp,null,modules,function () {
        console.log('done');
});

MyObject.js（使用慢速构造函数的类定义）：

var nsynjs = require('nsynjs');

var synchronousCode = function (wrappers) {
    var config;

    // constructor of MyObject
    var MyObject = function(fileName) {
        this.data = JSON.parse(wrappers.readFile(nsynjsCtx, fileName).data);
    };
    MyObject.prototype.getData = function () {
        return this.data;
    };
    return MyObject;
};

var wrappers = require('./wrappers');
nsynjs.run(synchronousCode,{},wrappers,function (m) {
    module.exports = m;
});

wrappers.js（使用回调的慢函数的nsynjs-aware包装器）：

var fs=require('fs');
exports.readFile = function (ctx,name) {
    var res={};
    fs.readFile( name, "utf8", function( error , configText ){
        if( error ) res.error = error;
        res.data = configText;
        ctx.resume(error);
    } );
    return res;
};
exports.readFile.nsynjsHasCallback = true;

此示例的完整文件集可在此处找到：https://github.com/amaksr/nsynjs/tree/master/examples/node-async-constructor

异步构造函数

7 个答案: