Qual é o propósito do nó.módulo js.exportações e como usá-las?

Pode utilizar tanto exports como module.exports para importar o código para a sua aplicação, assim:

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

O caso de uso básico que você verá (por exemplo, no código de exemplo ExpressJS) é que você define propriedades no objeto exports em A.ficheiro js que irá importar com require()

Então num exemplo simples de contagem, você poderia ter:

(contador.js):

var count = 1;

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

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

... então no seu application (web.js, ou qualquer outro .ficheiro js):

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

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

Em termos simples, você pode pensar nos ficheiros necessários como funções que devolvem um único objecto, e você pode adicionar propriedades (strings, números, arrays, funções, qualquer coisa) ao objecto que é devolvido, definindo-os em exports.

Às vezes você vai querer que o objeto retornado de uma chamada {[[8]} para ser uma função que você pode chamar, em vez de apenas um objeto com propriedades. Nesse caso, você também precisa definir module.exports, como isto: (Sayhello.js):

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

(app.js):

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

A diferença entre exportação e módulo.as exportações são melhor explicadas em esta resposta aqui .

Note que o NodeJS módulo mecanismo é baseado no CommonJS módulos que são suportados em muitas outras implementações como RequireJS, mas também Tudo, o CouchDB, Wakanda, OrientDB, ArangoDB, RingoJS, TeaJS, SilkJS, enrolar.js, ou mesmo Adobe Photoshop (via PSLib). Você pode encontrar a lista completa de implementações conhecidas Aqui.

A menos que o seu módulo use características específicas do nó ou módulo, encorajo-o vivamente a usar exports em vez de module.exports que não faz parte do CommonJS standard, e então não é suportado principalmente por outras implementações.

Outra característica específica do NodeJS é quando você atribui uma referência a um novo objecto a {[[4]} em vez de apenas adicionar propriedades e métodos a ele, como no último exemplo fornecido por Jed Watson neste tópico. Pessoalmente. desencorajar esta prática, uma vez que este quebra o suporte circular de referência do mecanismo de módulos CommonJS. Não é então suportado por todas as implementações e o exemplo Jed deve então ser escrito desta forma (ou similar) para fornecer um módulo mais universal:

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

(app.js):

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

Ou usando características do ES6

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

(app.js):

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

PS: parece que o Appcelerator também implementa CommonJS módulos, mas sem o suporte circular de referência (ver: Appcelerator e módulos CommonJS (cache e referências circulares)))

Algumas coisas que deve ter cuidado se atribuir uma referência a um novo objecto a exports e / ou modules.exports:

1. Todas as propriedades / métodos anteriormente anexados ao exports original ou module.exports estão obviamente perdidos porque o objecto exportado irá agora referenciar outro novo

Este é óbvio, mas se adicionar um método exportado no início de um módulo existente, certifique-se de que o objecto nativo exportado não está a referir outro objecto no fim

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. No caso de um dos exports ou module.exports referirem um novo valor, já não se referem ao mesmo objecto

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. Consequência complicada. Se mudar a referência para exports e module.exports, é difícil dizer qual a API que está exposta (parece que module.exports ganha)

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

O módulo.exportar a propriedade ou o objecto exportar permite a um módulo seleccionar o que deverá ser partilhado com a aplicação

Tenho um vídeo em module_export disponível aqui

Ao dividir o código do seu programa por vários ficheiros, {[[0]} é usado para publicar variáveis e funções ao consumidor de um módulo. A chamada require() no seu ficheiro de código é substituída por module.exports correspondente, carregada a partir do módulo.

Lembre - se quando escrever os módulos

• as cargas do módulo estão em cache, apenas a chamada inicial avalia o JavaScript.
É possível usar variáveis e funções locais dentro de um módulo, nem tudo precisa ser exportado.
• a module.exports object is also available as exports shorthand. Mas ao retornar uma única função, use sempre module.exports.

De acordo com: "módulos Parte 2 - módulos de Escrita".

A ligação de referência é assim:

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

As propriedades de exports ou module.exports ,tais como funções ou variáveis , serão expostas fora de

Bom exemplo:

exports.name = 'william';

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

Mau exemplo :

exports = 'william';

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

Se apenas quiser expor uma função ou variável, como esta:

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

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

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

Este módulo só expôs uma função e a propriedade do nome é privada para o exterior .

Existem alguns módulos predefinidos ou existentes no nó.js quando você baixar e instalar o nó.js like http, sys etc.

Uma vez que já estão no nó.js, quando queremos usar esses módulos nós basicamente fazemos como importar módulos , mas por quê? porque eles já estão presentes no nó.js. Importar é como tirá-los do nó.js e colocá-los no seu programa. E depois usá-los.

Considerando o seguinte: Exportações é exactamente o ao contrário, você está criando o módulo que você quer, digamos, a adição do módulo.js e colocar esse módulo no nó.js, fá-lo exportando-o.

antes de escrever alguma coisa aqui, lembra-te, módulo.exportacao.aditiontwo é o mesmo que as exportações.additionTwo

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

Cuidado com o caminho

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

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

Erro: não é possível encontrar a adição do módulo.js

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

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

Uma vez que estamos a indicar o caminho aqui, dizendo que está no directório actual ./ isto também deve ser executado com sucesso.

Um módulo encapsula o código relacionado numa única unidade de código. Ao criar um módulo, isso pode ser interpretado como movendo todas as funções relacionadas em um arquivo.

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

Só escrevemos uma função quando a utilidade do código é mais do que uma chamada.

Você pode exportar ambas as funções pelo código indicado abaixo

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

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

A intenção é:

Programação Modular é uma técnica de design de software que enfatiza separar a funcionalidade de um programa em independente, módulos intercambiáveis, de modo que cada um contenha tudo o necessário executar apenas um aspecto da funcionalidade desejada.

Wikipédia

Eu imagino que se torna difícil escrever um grande programa sem código modular / reutilizável. Em nodejs podemos criar programas modulares utilizando Definir com o que expomos e compomos o nosso programa.

Tenta este exemplo:

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!');

executar

$ node program.js

Olá, mundo!

Qual é o propósito de um sistema de módulos?

Realiza as seguintes coisas:

1. evita que os nossos ficheiros inchem para tamanhos realmente grandes. Ter arquivos com, por exemplo, 5000 linhas de código nele são geralmente muito difíceis de lidar durante o desenvolvimento.
2. Impõe a separação das preocupações.Ter o nosso código dividido em vários ficheiros permite-nos ter nomes de ficheiros apropriados para cada ficheiro. Desta forma podemos facilmente identificar o que cada módulo faz e onde encontrá-lo (assumindo que fizemos uma estrutura de diretório lógico que ainda é sua responsabilidade).

Como funciona?

NodejS utiliza o sistema de módulos CommomJS que funciona da seguinte forma:

1. se um ficheiro quiser exportar algo, tem de O declarar usando a sintaxemodule.export
2. se um ficheiro quer importar algo que tem de declarar usando a sintaxe require('file')

Exemplo:

Teste 1.js

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

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

Teste2.js

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

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

Outras coisas úteis para saber:

1. Os módulos estão a ser encontrados . Quando você está carregando o mesmo módulo em 2 arquivos diferentes, o módulo só tem que ser carregado uma vez. A segunda vez que um require() é chamado no mesmo módulo é retirado do cache.
2. Os módulos são carregados synchronous . Este comportamento é necessário, se fosse assíncrono nós não poderíamos acessar o objeto recuperado de require() imediatamente.