web-dev-qa-db-fra.com

Comment fonctionne require () dans node.js?

J'ai essayé ceci:

// mod.js
var a = 1;
this.b = 2;
exports.c = 3;

// test.js
var mod = require('./mod.js');
console.log(mod.a);    // undefined
console.log(mod.b);    // 2
console.log(mod.c);    // 3, so this === exports?

Donc, j'imagine que require () peut être implémenté comme ceci:

var require = function (file) {
    var exports = {};
    var run = function (file) {
        // include "file" here and run
    };
    run.apply(exports, [file]);
    return exports;
}

Est-ce correct? Aidez-moi à comprendre require (), ou où puis-je trouver le code source. Merci!

javascriptnode.jsthisrequireapply
70
Trantor Liu

Le code source est ici . exports/require ne sont pas des mots-clés, mais des variables globales. Votre script principal est enveloppé avant début dans une fonction qui a tous les globaux comme require, process etc dans son contexte.

Notez que tandis que module.js lui-même utilise require(), c'est une fonction require différente, et elle est définie dans le fichier appelé "node.js"

Effet secondaire de ce qui précède: il est tout à fait correct d'avoir une instruction "return" au milieu de votre module (n'appartenant à aucune fonction), "commentant" le reste du code

50
Andrey Sidorov

Andrey a montré le code source, mais si vous vous demandez également comment l'utiliser, l'explication facile et simple est ici ( http://nodejs.org/api/modules.html =).

Ce sont deux bons exemples pour moi.

//foo.js, multiple methods
var circle = require('./circle.js');
console.log( 'The area of a circle of radius 4 is ' + circle.area(4));

//circle.js
var PI = Math.PI;
exports.area = function (r) {
  return PI * r * r;
};
exports.circumference = function (r) {
  return 2 * PI * r;
};

//bar.js
var square = require('./square.js');
var mySquare = square(2);
console.log('The area of my square is ' + mySquare.area());

//square.js, single method
module.exports = function(width) {
  return {
    area: function() {
      return width * width;
    }
  };
}

Mon modèle préféré est

(function (controller) {

  controller.init = function (app) {

    app.get("/", function (req, res) {
        res.render("index", {});
    });

  };
})(module.exports);
8
Andy
var mod = require('./mod.js');

Le require est une fonction qui prend un argument appelé chemin, dans ce cas le chemin est ./mod.js

lorsque l'exigence est invoquée, une séquence de tâches se produit:

  1. appeler la fonction Module.prototype.require déclarée dans lib/module.js qui affirme que le chemin existe et était une chaîne

  2. appelez Module._load qui est une fonction dans lib/module.js qui résout le fichier via Module._resolveFilename(request, parent, isMain),

  3. la fonction Module._resolveFilename est appelée et vérifie si le module est natif (Les modules natifs sont retournés par la fonction NativeModule définie dans lib/internal/bootstrap_node.js ), si oui il renverra le module sinon il vérifie le nombre de caractères du parh (2 caractères au moins) et quelques caractères (le chemin doit commencer par ./) via la fonction Module._resolveLookupPaths définie dans définie dans lib/internal/bootstrap_node.js
  4. vérifier le répertoire qui contient le fichier
  5. Si le chemin contient une extension (dans notre exemple oui: mod.js), la fonction de nom de base définie dans lib/path.js vérifie que l'extension est " js "
  6. alors il va créer un nouveau module pour le fichier donné dans l'argument var module = new Module(filename, parent);
  7. le contenu sera compilé via la v8 via la fonction NativeModule.prototype.compile définie dans lib/internal/bootstrap_node.js
  8. le NativeModule.wrap défini dans lib/internal/bootstrap_node.js prend le contenu javascript compilé de mod.js et l'enveloppe: il l'enveloppe dans un autre code qui rend tout cela travail. Le code que vous avez écrit dans mod.js Est donc enveloppé dans une expression de fonction. cela signifie que tout ce que vous écrivez dans le nœud est exécuté en V8
  9. un module.exports est ce qui est retourné
6
Mohamed Ben HEnda