Dans Node.js suis-je créer un nouvel objet lors de “Besoin”?

Donc, ce que je ne suis pas sûr, c'est que. si dans ModuleA, j'ai:

var mongoose = require('mongoose');
mongoose.connect(pathA);

Et dans ModuleB, j'ai:

var mongoose = require('mongoose');
mongoose.connect(pathB);

Et dans le programme principal, j'ai:

var mA = require('./moduleA.js'), 
mB = require('./moduleB.js');

Donc, lorsque j'exécute le programme principal, je pense que je vais créer deux mangouste "instances"; une connexion à pathA et une connexion à pathB, est ce que le droit?

Aussi, dans le Module B, avant de me connecter à pathB, est-il connecté à pathA ou rien?

Grâce.

InformationsquelleAutor murvinlai | 2011-04-26

16

J'ai juste fait quelques tests avec la dernière nœud V0.4.6. J'ai confirmé le suivant:
1. La variable retournée à partir de "besoin" est un singleton.
2. Les modifications ultérieures changent les données du module obligatoire parmi tous les autres modules de l'inclure.
3. Mangouste de la connexion est un peu bizarre. Même si vous vous déconnectez et de définir un nouveau chemin de connexion, il utilise encore l'ancien chemin de connexion.
Donc, ce que je veux dire par la au-dessus des points 1 et 2 est:

Si vous avez un Module Maître:
```
var myStr = 'ABC';
module.exports.appendStr = function(data) {
    myStr += ' ' + data;    
};
module.exports.output = function() {
    console.log("Output: " + myStr);
};
```
Et si vous disposez de deux autres modules:

Module Un
```
var mc = require('./moduleMaster.js');
var ma = function() {mc.appendStr(' MA '); };
ma.prototype.output = function() {
  mc.output();
}
module.exports.create = function() {
    return new ma();
};

module.exports._class = ma;
```
Module B
```
var mc = require('./moduleMaster.js');
var mb = function() {mc.appendStr(' MB '); };
ma.prototype.output = function() {
  mc.output();
}
module.exports.create = function() {
    return new mb();
};

module.exports._class = mb;
```
Maintenant, lorsque vous exécutez un script de test qui nécessite à la fois Un Module et le Module B, instancier et de sortie:
```
mTestA.output();
mTestB.output();
```
Vous obtiendrez le résultat suivant:
```
ABC MA
ABC MA MB
```
au lieu de
```
ABC MA
ABC MB
```
Par conséquent, il est un singleton. et pas seulement locale au module.

InformationsquelleAutor murvinlai
3

Je suis tombé sur ce post, et alors que l'on a accepté la réponse montre que c'est un Singleton, ma réponse à la question initiale "Dans Node.js suis-je créer un nouvel objet lors de “Besoin”?" est "ça dépend".

murvinlai 's réponse/logique détient toujours vrai à travers les dernières versions de Nœud ( v0.10.18 de cette écriture ), mais si vous avez votre fichier de configuration de cette façon. Par exemple, et je suis en train d'utiliser un plus prolixe exemple, pour éviter toute confusion, si vous aviez la suite de "l'Utilisateur" dans le code User.js ( structuré différent de murvinlai 's réponse )
```
/**
 * User Model
 */
function modelUser() {
    var User  = {
        /**
         * User::_id
         *
         * @var integer
         */
        "_id" : null,

        /**
         * Set id
         *
         * @param integer id
         * @return User
         */
        "setId" : function(id)
        {
            User._id = id; 
            return User;
        },

        /**
         * Get id
         *
         * @return integer
         */
        "getId" : function()
        {
            return User._id;
        },

    }

    return User;

}
exports.modelUser = modelUser;
```
Maintenant, si vous avez pris le code ci-dessus, vous pouvez constater que dans de nombreux cas, sans modification, vous n'auriez pas le Singleton question. C'est à dire avec:
```
var user1 = require("./application/models/User.js").modelUser(); //In one module
var user2 = require("./application/models/User.js").modelUser(); //In another module

user1.setId(1);

console.log(user1.getId());
console.log(user2.getId());
```
Vous obtenez 1, null. En outre, et je ne suis même pas sûr que vous besoin de cela, mais vous pouvez utiliser le nouvel opérateur sur le besoin ( puisque c'est essentiellement juste de retour d'une fonction ). C'est à dire avec:
```
var user1 = new require("./application/models/User.js").modelUser(); //In one module
var user2 = new require("./application/models/User.js").modelUser(); //In another module

user1.setId(1);

console.log(user1.getId());
console.log(user2.getId());
```
Et vous obtenez le même résultat.

Encore une fois, la question d'origine était un peu large ( ant les problèmes peuvent avoir été finalement avec la mangouste ( comme mentionné dans le n ° 3 de murvinlai 's réponse ), mais le ci-dessus est un exemple d'une autre manière de faire les choses pour donner un véritable objet de chacun des require()'s. Maintenant, vous pouvez vouloir penser avant de le faire comme il ya des moments où vous voulez que le Singleton ( disons pour stocker les valeurs mises en cache dans un ORM/Mapper ), mais en clôture êtes-vous de la création d'un nouvel objet, ça dépend..
- Bon point. Il est important de mentionner que cette approche de création d'objets en Javascript est plus lent que d'utiliser le "prototype" approche V8 ne peut pas distinguer entre les deux instances différentes de la même "classe". Plus de détails ici: thenodeway.io/posts/conception-custom-types
InformationsquelleAutor conrad10781

Vous devez vous connecter pour publier un commentaire.