javascript - 非同期コンストラクター

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.

私は3つのオプションを目にしますが、それぞれが普通ではないように見えます。

1つは、コンストラクターにコールバックを追加します。

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

2つ目は、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);
});

または3つ、コンストラクターをブロックします。

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)

しかし、私はこれまでにこれが行われたのを見たことがありません。

他にどのようなオプションがありますか？

score 29 · Accepted Answer

更新2：非同期ファクトリメソッドを使用した更新された例を次に示します。注意：ブラウザで実行する場合は、ノード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

promiseを使用した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
});

score 11 · Accepted Answer

Nodeでのブロックを回避する必要があることを考えると、イベントまたはコールバックの使用はそれほど奇妙ではありません^（1）。

Twoを少し編集するだけで、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コアノード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ファイルの読み取りにそれほど時間はかからないはずです。もしそうなら、おそらくデータのためにストレージシステムの変更が必要です。

score 4 · Accepted Answer

私は非同期コンストラクターを開発しました：

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

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

asyncはpromiseを返します
矢印関数は「this」をそのまま渡します
newを実行すると、別の何かを返すことができます（この変数には、まだ新しい空のオブジェクトがあります。newなしで関数を呼び出すと、元のthisが取得されます。たとえば、window、global、またはその保持オブジェクトなど）。
awaitを使用して、呼び出された非同期関数の戻り値を返すことができます。
通常のコードでawaitを使用するには、呼び出しを非同期の無名関数でラップする必要があります。これは即座に呼び出されます。（呼び出された関数はpromiseを返し、コードは続行します）

私の最初の反復は次のとおりです。

多分コールバックを追加するだけ

匿名の非同期関数を呼び出してから、コールバックを呼び出します。

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

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

私の2回目の反復は次のとおりです。

コールバックの代わりに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){

});

score 3 · Accepted Answer

あなたができることの1つは、すべての核をプリロードすることです（おそらく非効率的です。それがどれだけのデータであるかはわかりません）。もう1つは、プリロードがオプションでない場合に推奨するもので、ロードされた核を保存するためのキャッシュを使用したコールバックが含まれます。そのアプローチは次のとおりです。

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

score 2 · Accepted Answer

これは悪いコードデザインです。

主な問題は、インスタンスのコールバックでまだ「リターン」が実行されていないことです。これが私が意味することです

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

score 1 · Accepted Answer

非同期部分を流暢な方法に抽出します。慣例により、私はそれらを一緒に呼びます。

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

new FooBar()たとえば、静的ファクトリアプローチラッピングを試しましたFooBar.create()が、継承ではうまく機能しませんでした。に拡張FooBarした場合でもFooBarChild、FooBarChild.create()を返しますFooBar。一方、私のアプローチでnew FooBarChild().create()はaが返さFooBarChildれ、で継承チェーンを設定するのは簡単create()です。

score -1 · Accepted Answer

nsynjsを介して、非同期関数を使用してコンストラクター関数を同期的に実行できます。説明する例を次に示します。

index.js（メインアプリロジック）：

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-コールバックを使用した低速関数のラッパー）：

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にあります。

javascript - 非同期コンストラクター

7 に答える 7

Related

Reference