¿Cómo funciona require() en node.js?

Question

yo probamos este:

// 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? 

imagen Así que que requieren() se puede implementar como esto:

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

¿Es eso cierto? Ayúdame a comprender require(), o dónde puedo encontrar el código fuente. ¡Gracias!

Answer 1

El código fuente es here. exports/require no son palabras clave, sino variables globales. Su secuencia de comandos principal es wrapped antes de start en una función que tiene todos los globales como require, process etc. en su contexto.

Nótese que si bien module.js en sí es el uso de require(), que es una función de diferentes requieren, y es defined en el archivo llamado "Node.js"

Efecto secundario de arriba: No hay ningún problema para tener "retorno "declaración en el medio de su módulo (que no pertenece a ninguna función), efectivamente" comentar "el resto del código

Answer 2

La fuente está disponible aquí al lado de las descargas: http://nodejs.org/ Las exportaciones/requieren son palabras clave, no creo que estén codificadas en javascript directamente. El nodo está codificado en C++, javascript es solo un shell de scripts alrededor del núcleo de C++.

Answer 3

Andrey mostró el código fuente, pero si también se pregunta cómo usarlo, la explicación fácil y simple está aquí (http://nodejs.org/api/modules.html).

Estos fueron dos buenos ejemplos para mí.

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

Mi patrón favorito es

(function (controller) { 

    controller.init = function (app) { 

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

    }; 
})(module.exports); 

Answer 4

var mod = require('./mod.js'); 

El requiere es una función que toma un argumento llamado camino, en este caso el camino es ./mod.js

cuando la necesita es invocado, se han producido una secuencia de tareas:

1. llamada Module.prototype.require función declarada en lib/module.js el que afirman que existe la ruta y fue una cadena

2. llamada Module._load que es una función de lib/module.js que resuelve el archivo a través de Module._resolveFilename(request, parent, isMain),

3. la función Module._resolveFilename se llama y cheques si el módulo es nativo (los módulos nativos son devueltos por la función NativeModule definida en lib/internal/bootstrap_node.js), en caso afirmativo, devolverá el módulo, de lo contrario, verificará el número de caracteres del parh (mínimo 2 caracteres) y algunos caracteres (la ruta debe comenzar por ./) través Module._resolveLookupPaths función definida en define en lib/internal/bootstrap_node.js
4. cheque el directorio que contiene el archivo
5. Si la ruta contiene una extensión (en nuestro ejemplo: yes mod.js), la función definida en nombre base lib/path.js comprueba que la extensión es "js"
6. continuación, se creará un nuevo módulo para el archivo dado en el argumento var module = new Module(filename, parent);
7. el contenido será com apilados a través de la 8 a través de la función NativeModule.prototype.compile definido en lib/internal/bootstrap_node.js
8. la NativeModule.wrap definido en lib/internal/bootstrap_node.js toma el contenido JavaScript compilado de mod.js y lo envuelve: Se envuelve en algún otro código que hace todo este trabajo. Así que el código que ha escrito en mod.js está envuelto en una expresión de función. eso significa que todo lo que escriba en el nodo se ejecuta en V8
9. A es lo que se volvió