Cuál es el propósito de Node.módulo js.exportaciones y cómo se utiliza?

Esto ya ha sido contestado, pero quería añadir algunas aclaraciones...

Puede usar tanto exports como module.exports para importar código a su aplicación de la siguiente manera:

var mycode = require('./path/to/mycode');

El caso de uso básico que verá (por ejemplo, en el código de ejemplo de ExpressJS) es que establece propiedades en el objeto exports en a .archivo js que luego importa usando require()

Así que en un simple ejemplo de conteo, usted podría tener:

(counter.js):

var count = 1;

exports.increment = function() {
    count++;
};

exports.getCount = function() {
    return count;
};

... luego en su aplicación (web.js, o realmente cualquier otro .archivo js):

var counting = require('./counter.js');

console.log(counting.getCount()); // 1
counting.increment();
console.log(counting.getCount()); // 2

En términos simples, puede pensar en los archivos requeridos como funciones que devuelven un solo objeto, y puede agregar propiedades (cadenas, números, matrices, funciones, cualquier cosa) al objeto que se devuelve configurándolos en exports.

A veces querrá que el objeto devuelto de una llamada require() sea una función que pueda llamar, en lugar de solo un objeto con propiedades. En ese caso, también debe establecer module.exports, como esto:

(sayhello.js):

module.exports = exports = function() {
    console.log("Hello World!");
};

(app.js):

var sayHello = require('./sayhello.js');
sayHello(); // "Hello World!"

La diferencia entre las exportaciones y el módulo.las exportaciones se explican mejor en esta respuesta aquí.

Tenga en cuenta que el NodeJS módulo mecanismo se basa en CommonJS los módulos que son compatibles en muchas otras implementaciones como RequireJS, pero también SproutCore, CouchDB, Wakanda, OrientDB, ArangoDB, RingoJS, TeaJS, SilkJS, curl.js , o incluso Adobe Photoshop (a través de PSLib). Puede encontrar la lista completa de implementaciones conocidas aquí.

A menos que su módulo utilice características específicas de nodo o módulo, le recomiendo encarecidamente que use exports en lugar de module.exports que no es parte del estándar CommonJS, y luego no es soportado por otras implementaciones.

Otra característica específica de NodeJS es cuando asigna una referencia a un nuevo objeto a exports en lugar de simplemente agregarle propiedades y métodos como en el último ejemplo proporcionado por Jed Watson en este hilo. Yo personalmente desaconsejar esta práctica ya que este rompe el soporte de referencia circular del mecanismo de módulos CommonJS. Entonces no es compatible con todas las implementaciones y el ejemplo Jed debe escribirse de esta manera (o similar) para proporcionar un módulo más universal:

(sayhello.js):

exports.run = function() {
    console.log("Hello World!");
}

(app.js):

var sayHello = require('./sayhello');
sayHello.run(); // "Hello World!"

O usando características de ES6

(sayhello.js):

Object.assign(exports, {
    // Put all your public API here
    sayhello() {
        console.log("Hello World!");
    }
});

(app.js):

const { sayHello } = require('./sayhello');
sayHello(); // "Hello World!"

PD: Parece que Appcelerator también implementa CommonJS módulos, pero sin el soporte de referencia circular (ver: Módulos Appcelerator y CommonJS (caching y referencias circulares))

Algunas cosas que debe tener cuidado si asigna una referencia a un nuevo objeto a exports y / o modules.exports:

1. Todas las propiedades/métodos previamente adjuntos al exports o module.exports original, por supuesto, se pierden porque el objeto exportado ahora hará referencia a otro nuevo

Este es obvio, pero si agrega un método exportado al principio de un módulo existente, asegúrese de que el objeto exportado nativo no haga referencia a otro objeto en el end

exports.method1 = function () {}; // exposed to the original exported object
exports.method2 = function () {}; // exposed to the original exported object

module.exports.method3 = function () {}; // exposed with method1 & method2

var otherAPI = {
    // some properties and/or methods
}

exports = otherAPI; // replace the original API (works also with module.exports)

2. En caso de que uno de exports o module.exports haga referencia a un nuevo valor, ya no hacen referencia al mismo objeto

exports = function AConstructor() {}; // override the original exported object
exports.method2 = function () {}; // exposed to the new exported object

// method added to the original exports object which not exposed any more
module.exports.method3 = function () {}; 

3. Consecuencia difícil. Si cambia la referencia a exports y module.exports, es difícil decir qué API está expuesta (parece que module.exports gana)

// override the original exported object
module.exports = function AConstructor() {};

// try to override the original exported object
// but module.exports will be exposed instead
exports = function AnotherConstructor() {}; 

El módulo.la propiedad exports o el objeto exports permite a un módulo seleccionar lo que debe compartirse con la aplicación

Tengo un video sobre module_export disponible aquí

Al dividir el código del programa en varios archivos, module.exports se utiliza para publicar variables y funciones al consumidor de un módulo. La llamada require() en su archivo fuente se reemplaza con el module.exports correspondiente cargado desde el módulo.

Recordar al escribir módulos

• Las cargas del módulo se almacenan en caché, solo la llamada inicial evalúa JavaScript.
• Es posible usar variables y funciones locales dentro de un módulo, no todo necesita ser exportado.
• El module.exports object también está disponible como exports abreviado. Pero cuando devuelva una función única, utilice siempre module.exports.

De acuerdo con: "Módulos Parte 2 - Módulos de escritura".

El enlace de referencia es así:

exports = module.exports = function(){
    //....
}

Las propiedades de exports o module.exports, como funciones o variables, se expondrán fuera de

Hay algo que debes prestar más atención : no exportes override.

¿Por qué ?

Porque exporta solo la referencia del módulo.exportaciones, puede agregar las propiedades a las exportaciones , pero si anula las exportaciones, el enlace de referencia se romperá .

Buen ejemplo:

exports.name = 'william';

exports.getName = function(){
   console.log(this.name);
}

Mal ejemplo :

exports = 'william';

exports = function(){
     //...
}

Si solo desea exponer solo una función o variable , como esta:

// test.js
var name = 'william';

module.exports = function(){
    console.log(name);
}   

// index.js
var test = require('./test');
test();

Este módulo solo expuso una función y la propiedad de name es privada para el exterior .

Hay algunos módulos predeterminados o existentes en node.js al descargar e instalar node.js like http, sys etc.

Ya que ya están en el nodo.js, cuando queremos usar estos módulos básicamente hacemos como importar módulos, pero ¿por qué? porque ya están presentes en el nodo.js. Importarlos es como tomarlos del nodo.js y ponerlos en su programa. Y luego usarlas.

Considerando Exportaciones es exactamente el al contrario, está creando el módulo que desea, digamos la adición del módulo.js y poner ese módulo en el nodo.js, lo haces exportándolo.

Antes de escribir algo aquí, recuerde, módulo.exportación.additionTwo es lo mismo que exportaciones.Otros dos

Huh, así que esa es la razón, nos gusta{[11]]}

exports.additionTwo = function(x)
{return x+2;};

Tenga cuidado con el camino

Digamos que ha creado una adición.módulo js,

exports.additionTwo = function(x){
return x + 2;
};

Cuando se ejecuta esto en tu NODO.Símbolo del sistema JS:

node
var run = require('addition.js');

Esto se equivocará diciendo

Error: No se puede encontrar la adición del módulo.js

Esto se debe al nodo.el proceso js no puede agregar.js ya que no mencionamos el camino. Por lo tanto, tenemos puede establecer la ruta mediante el uso de NODE_PATH

set NODE_PATH = path/to/your/additon.js

Ahora, esto debe ejecutarse con éxito sin ningún error!!

Una cosa más, también puede ejecutar la adición.archivo js al no establecer el NODE_PATH, vuelva a su comando nodejs prompt:

node
var run = require('./addition.js');

Dado que estamos proporcionando la ruta aquí diciendo que está en el directorio actual ./ esto también debería ejecutarse con éxito.

Un módulo encapsula código relacionado en una sola unidad de código. Al crear un módulo, esto se puede interpretar como mover todas las funciones relacionadas a un archivo.

Supongamos que hay un archivo Hello.js que incluyen dos funciones

sayHelloInEnglish = function() {
  return "Hello";
};
sayHelloInSpanish = function() {
  return "Hola";
};

Escribimos una función solo cuando la utilidad del código es más de una llamada.

Supongamos que queremos aumentar la utilidad de la función a un archivo diferente, por ejemplo, World.js, en este caso la exportación de un archivo entra en la imagen que se puede obtener por módulo.exportación.

Solo puede exportar tanto la función por el código dado a continuación

var anyVariable={
 sayHelloInEnglish = function() {
      return "Hello";
    };
  sayHelloInSpanish = function() {
      return "Hola";
    }; 
}
module.export=anyVariable;

Ahora solo necesita requerir el nombre del archivo en World.js inorder para utilizar esas funciones

var world= require("./hello.js");

La intención es:

La programación modular es una técnica de diseño de software que enfatiza separar la funcionalidad de un programa en independiente, módulos intercambiables, de modo que cada uno contenga todo lo necesario ejecutar solo un aspecto de la funcionalidad deseada.

Wikipedia

Me imagino que se hace difícil escribir programas grandes sin código modular / reutilizable. En nodejs podemos crear programas modulares utilizando module.exports definiendo lo que exponemos y componemos nuestro programa con require.

Prueba este ejemplo:

FileLog.js

function log(string) { require('fs').appendFileSync('log.txt',string); }

module.exports = log;

StdoutLog.js

function log(string) { console.log(string); }

module.exports = log;

Programa.js

const log = require('./stdoutLog.js')

log('hello world!');

ejecutar

Node programa de nodos.js

Hola mundo!

Ahora intenta intercambiar ./ stdoutLog.js for ./ fileLog.js .

¿Cuál es el propósito de un sistema de módulos?

Logra las siguientes cosas:

1. Evita que nuestros archivos se hinchen a tamaños realmente grandes. Tener archivos con, por ejemplo, 5000 líneas de código en él suele ser muy difícil de tratar durante el desarrollo.
2. Impone la separación de preocupaciones. Tener nuestro código dividido en varios archivos nos permite tener nombres de archivo apropiados para cada archivo. De esta manera podemos identificar fácilmente lo que cada módulo lo hace y dónde encontrarlo (asumiendo que hicimos una estructura de directorios lógicos que sigue siendo su responsabilidad).

Tener módulos hace que sea más fácil encontrar ciertas partes del código, lo que hace que nuestro código sea más mantenible.

¿Cómo funciona?

NodejS utiliza el sistema de módulos CommomJS que funciona de la siguiente manera:

1. Si un archivo quiere exportar algo tiene que declararlo usando la sintaxis module.export
2. Si un archivo quiere importa algo que tiene que declarar usando require('file') sintaxis

Ejemplo:

Test1.js

const test2 = require('./test2');    // returns the module.exports object of a file

test2.Func1(); // logs func1
test2.Func2(); // logs func2

Test2.js

module.exports.Func1 = () => {console.log('func1')};

exports.Func2 = () => {console.log('func2')};

Otras cosas útiles para saber:

1. Los módulos se están almacenando en caché. Cuando está cargando el mismo módulo en 2 archivos diferentes, el módulo solo tiene que cargarse una vez. La segunda vez que se llama a require() en el mismo módulo, se extrae de la caché.
2. Los módulos se cargan en síncrono . Este comportamiento es necesario, si era asíncrono no podríamos acceder al objeto recuperado de require() de inmediato.