Asynchroner Konstruktor

Wie kann ich am besten umgehen einer situation wie der folgenden?

Ich habe einen Konstruktor, der eine Weile dauert, um abzuschließen.

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.

Sehe ich drei Optionen, von denen jeder scheint sich von den gewöhnlichen.

Einefügen Sie eine callback-Funktion an den Konstruktor.

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

Zweiverwenden Sie EventEmitter ausstrahlen 'geladen' event.

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

Oder dreiblockieren Sie den Konstruktor.

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)

Aber ich habe nicht gesehen, alle dies getan haben, bevor.

Welche anderen Möglichkeiten habe ich?

InformationsquelleAutor der Frage Luke Burns | 2012-08-08

Angesichts der Notwendigkeit, zu vermeiden, blockiert bei Knoten, die Verwendung von events und callbacks ist nicht so seltsam,⁽¹⁾.

Mit einem leichten Bearbeiten von Zwei, könnte man zusammenfassen mit:

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.
}

...

Obwohl, wie die fs.readFile in deinem Beispiel, den core-APIs Knoten (mindestens) oft nach dem Muster von statischen Funktionen, die freizulegen, die Instanz, wenn die Daten bereit sind:

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) Es sollte nicht sehr lange dauern, zu Lesen, dass ein JSON-Datei. Wenn es ist, vielleicht eine änderung im storage-system ist in-Reihenfolge der Daten an.

InformationsquelleAutor der Antwort Jonathan Lonowski

Update 2:
Hier ist ein Aktuelles Beispiel über eine asynchrone factory-Methode. N. B. dies erfordert die Knoten 8 oder Babel, wenn in einem browser laufen.

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

Update:
Den code unten hab von Ihnen positiv bewertet werden, ein paar mal. Allerdings finde ich diesen Ansatz über eine statische Methode viel besser:
https://stackoverflow.com/a/24686979/2124586

ES6-version mit verspricht

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

InformationsquelleAutor der Antwort tim

Eine Sache, die Sie tun können, ist preload alle Kerne (vielleicht ineffizient, ich weiß nicht, wie viel Daten es sich handelt). Die anderen, die ich empfehlen würde, wenn Vergleichsseiten ist keine option, das würde einen Rückruf mit einem cache zu speichern geladenen Kerne. Hier ist das Konzept:

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

InformationsquelleAutor der Antwort Will

Dies ist ein schlechtes code-design.

Das Hauptproblem ist in der callback-Ihr Beispiel ist es nicht noch ausführen des "zurück", das ist, was ich meine

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

So, die guten code-design, ist der explizite Aufruf der "init" - Methode (oder in deinem Fall "load_nucleus") nach instanziert die Klasse

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

InformationsquelleAutor der Antwort Simone Sanfratello

0

Habe ich entwickelt einen asynchronen Konstruktor:
```
function Myclass(){
 return (async () => {
     ... code here ...
     return this;
 })();
}

(async function() { 
 let s=await new Myclass();
 console.log("s",s)
})();
```
- async gibt ein Versprechen
- Pfeil-Funktionen, pass 'dies' so wie Sie ist
- ist es möglich, einen Rückgabewert als Ergebnis erwarten, als die Rückkehr des namens async-Funktion.
- es ist möglich, Rückkehr etwas anderes, wenn dabei neue.
- zu verwenden, erwarten Sie in den normalen code, müssen wickeln Sie die Aufrufe mit einer async-anonyme Funktion, die aufgerufen wird, sofort. (die aufgerufene Funktion gibt Versprechen und code weiter)
mein 1. iteration war:

vielleicht fügen Sie einfach einen Rückruf

Anruf einer anonymen async-Funktion,
dann rufen Sie die callback.
```
function Myclass(cb){
 var asynccode=(async () => { 
     await this.something1();
     console.log(this.result)
 })();

 if(cb)
    asynccode.then(cb.bind(this))
}
```
mein 2. iteration war:

versuchen wir mit einem Versprechen statt einer callback.
Ich dachte mir: seltsam, ein Versprechen der Rückkehr ein Versprechen, und es funktionierte. .. so, die nächste version ist nur ein Versprechen.
```
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)
})();
```
callback-basiert für die alten javascript -
```
function Myclass(cb){
 var that=this;
 var cb_wrap=function(data){that.data=data;cb(that)}
 getdata(cb_wrap)
}

new Myclass(function(s){

});
```
InformationsquelleAutor der Antwort Shimon Doodkin

-1

Können Sie laufen Konstruktor-Funktion mit asynchronen Funktionen synchron über nsynjs. Hier ist ein Beispiel zur Verdeutlichung:

index.js (Haupt-app-Logik):

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 (definition der Klasse mit langsamen Konstruktor):

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-bewusst wrapper um die langsamen Funktionen mit callbacks):

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;

Vollständigen Satz von Dateien für dieses Beispiel könnte hier gefunden werden: https://github.com/amaksr/nsynjs/tree/master/examples/node-async-constructor

InformationsquelleAutor der Antwort amaksr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.