Asynchrone constructeur

Compte tenu de la nécessité d'éviter tout blocage dans le Nœud, l'utilisation d'événements ou de rappels n'est pas étrange⁽¹⁾.

Avec une légère modification de Deux, vous pouvez le fusionner avec Celui-ci:

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

...

Si, comme le fs.readFile dans votre exemple, le Nœud de base Api (au moins) souvent suivi le modèle des fonctions statiques qui exposent l'instance lorsque les données sont prêtes:

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) Il ne devrait pas prendre très longtemps pour lire un fichier JSON. Si elle l'est, peut-être un changement dans le système de stockage pour les données.

Une chose que vous pourriez faire est de précharger toutes les noyaux (peut-être inefficace; je ne sais pas combien de données il est). L'autre, que je recommande si préchargement n'est pas une option, impliquerait un rappel avec un cache pour enregistrer chargé des noyaux. Ici, c'est que l'approche:

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

C'est une mauvaise conception du code.

Le principal problème est dans la fonction de rappel de votre exemple, il n'est pas toujours exécuter le "retour", c'est ce que je veux dire

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

Ainsi, le code de qualité de conception est d'appeler explicitement la "init" de la méthode (ou, dans votre cas, "load_nucleus") après avoir instancié la classe

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

Vous pouvez exécuter la fonction de constructeur avec async fonctions de manière synchrone via nsynjs. Voici un exemple pour illustrer:

index.js (principales de la logique d'application):

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 (définition de la classe, avec une lente constructeur):

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-conscient wrapper autour de ralentir les fonctions 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;

Jeu complet de fichiers pour cet exemple peut être trouvé ici: https://github.com/amaksr/nsynjs/tree/master/examples/node-async-constructor