Mimo, że odpowiedź na pytanie została już dawno przyjęta, chcę się podzielić moimi 2 centami: {]}

Możesz sobie wyobrazić, że na samym początku pliku jest coś takiego (tylko dla wyjaśnienia):

var module = new Module(...);
var exports = module.exports;

Więc cokolwiek zrobisz, pamiętaj, że module.exports A NIE exports zostaną zwrócone z twojego modułu, gdy będziesz go potrzebować z innego miejsca.

Więc kiedy robisz coś takiego:

exports.a = function() {
    console.log("a");
}
exports.b = function() {
    console.log("b");
}

Dodajesz 2 funkcji " a " i " b " do obiektu, na którym modułeksportuje również punkty, więc typeof wynik zwracany będzie object : { a: [Function], b: [Function] }

Oczywiście jest to ten sam wynik, który uzyskasz, jeśli użyjesz module.exports w tym przykładzie zamiast exports.

To jest przypadek, gdzie chcesz swój moduł.eksportowanie zachowuje się jak kontener wyeksportowanych wartości. Podczas gdy, jeśli chcesz wyeksportować tylko funkcję konstruktora, jest coś, co powinieneś wiedzieć o użyciu module.exports lub exports; (pamiętaj znowu ten moduł.eksport zostanie zwrócony, gdy czegoś potrzebujesz, a nie eksportu).

module.exports = function Something() {
    console.log('bla bla');
}

Teraz typeof zwracający wynik to 'function' i możesz go zażądać i natychmiast wywołać jak:
var x = require('./file1.js')(); ponieważ nadpisujesz zwracany wynik jako funkcję.

Jednak używając exports nie możesz użyć czegoś takiego jak:

exports = function Something() {
    console.log('bla bla');
}
var x = require('./file1.js')(); //Error: require is not a function

Ponieważ z exports, odniesienie nie "wskazuje" już na obiekt, gdzie module.exports wskazuje, więc nie ma związku między exports a module.exports już nie. W tym przypadku moduł.eksport nadal wskazuje na pusty obiekt {}, który zostanie zwrócony.

Przyjęta odpowiedź z innego tematu również powinna pomóc: czy Javascript przechodzi przez odniesienie?

Zasadniczo odpowiedź leży w tym, co naprawdę się dzieje, gdy moduł jest wymagany przez require oświadczenie. Zakładając, że jest to pierwszy raz, gdy moduł jest wymagany.

Na przykład:

var x = require('file1.js');

Zawartość pliku1.js:

module.exports = '123';

Po wykonaniu powyższej instrukcji tworzony jest obiekt Module. Jego funkcja konstruktora to:

function Module(id, parent) {
    this.id = id;
    this.exports = {};
    this.parent = parent;
    if (parent && parent.children) {
        parent.children.push(this);
    }

    this.filename = null;
    this.loaded = false;
    this.children = [];
}

Jak widać każdy obiekt modułu ma właściwość o nazwie exports. To jest to, co jest ostatecznie zwracane w ramach require.

Kolejnym krokiem require jest zawinięcie zawartości pliku1.js do funkcji anonimowej jak poniżej:

(function (exports, require, module, __filename, __dirname) { 
    //contents from file1.js
    module.exports = '123;
});

I ta anonimowa funkcja jest wywoływana w następujący sposób, module tutaj odnosi się do obiektu Module utworzonego wcześniej.

(function (exports, require, module, __filename, __dirname) { 
    //contents from file1.js
    module.exports = '123;
}) (module.exports,require, module, "path_to_file1.js","directory of the file1.js");

Jak widzimy wewnątrz funkcji, exports argument formalny odnosi się do module.exports. W istocie jest to wygoda zapewniona programiście modułów.

Jednak tę wygodę należy zachować ostrożność. W każdym przypadku, jeśli próba przypisania nowego obiektu do eksportu zapewnia, że robimy to w ten sposób.

exports = module.exports = {};

Jeśli zrobimy to w następujący sposób niewłaściwy sposób, module.exports nadal będzie wskazywać na obiekt utworzony jako część instancji modułu.

exports = {};

Jako wynik dodawanie czegokolwiek do powyższego obiektu exports nie będzie miało wpływu na moduł.eksportuje obiekt i nic nie zostanie wyeksportowane lub zwrócone w ramach require.

Początkowo module.exports=exports, a funkcja require zwraca obiekt module.exports.

Jeśli dodamy właściwość do obiektu, powiedzmy exports.a=1, to moduł.eksport i eksport nadal odnoszą się do tego samego obiektu. Jeśli więc wywołamy require i przypiszemy moduł do zmiennej, wtedy zmienna ma właściwość a i jej wartość wynosi 1;

Ale jeśli nadpisujemy jeden z nich, na przykład exports=function(){}, to są Inne teraz: exports odnosi się do nowego obiektu i moduł.eksport odnosi się do oryginalnego obiektu. A jeśli potrzebujemy pliku, nie zwróci on nowego obiektu, ponieważ moduł.eksport nie odnosi się do nowego obiektu.

Dla mnie, będę dodawać nową właściwość, lub nadpisywać obie z nich do nowego obiektu. Po prostu obejście jednego nie jest w porządku. I pamiętaj, że to prawdziwy szef.

exports i module.exports są takie same, chyba że przeniesiesz exports do swojego modułu.

Najprostszym sposobem myślenia o tym jest myślenie, że ta linia jest domyślnie na górze każdego modułu.

var exports = module.exports = {};

Jeśli w Twoim module zmienisz exports, to zmienisz go w swoim module i nie będzie już równy module.exports. Dlatego, jeśli chcesz wyeksportować funkcję, musisz wykonać:

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

Gdybyś po prostu przypisał swoje function() { ... } do exports, przypisałbyś exports do nie dłuższy punkt do module.exports.

Jeśli nie chcesz odwoływać się do swojej funkcji przez module.exports za każdym razem, możesz to zrobić:

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

Zauważ, że module.exports jest najbardziej lewym argumentem.

Dołączanie właściwości do exports nie jest tym samym, ponieważ nie przypisujesz go ponownie. Dlatego to działa

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

JavaScript przekazuje obiekty przez kopię referencji

To subtelna różnica w sposobie przekazywania obiektów przez odniesienie w JavaScript.

exports i module.exports oba wskazują na ten sam obiekt. {[1] } jest zmienną, a {[2] } jest atrybutem obiektu modułu.

Powiedzmy, że piszę coś takiego:

exports = {a:1};
module.exports = {b:12};

exports i module.exports Teraz wskaż różne obiekty. Modyfikowanie eksportu nie modyfikuje już modułu.eksport.

Gdy funkcja importu inspects module.exports it gets {b:12}

Po prostu robię jakiś test, okazuje się, że w kodzie modułu nodejsa powinno być coś takiego:

var module.exports = {};
var exports = module.exports;

Więc:

1:

exports = function(){}; // this will not work! as it make the exports to some other pointer
module.exports = function(){}; // it works! cause finally nodejs make the module.exports to export.

2:

exports.abc = function(){}; // works!
exports.efg = function(){}; // works!

3: ale, podczas gdy w tym przypadku

module.exports = function(){}; // from now on we have to using module.exports to attach more stuff to exports.
module.exports.a = 'value a'; // works
exports.b = 'value b'; // the b will nerver be seen cause of the first line of code we have do it before (or later)

Oto dobry opis napisany o modułach węzła w node.js w akcji książka z publikacji Manning .
To, co ostatecznie zostanie wyeksportowane do Twojej aplikacji, to moduł .eksport.
eksport jest ustawiony up po prostu jako globalne odniesienie do modułu .eksport , który początkowo definiowany jest jako pusty obiekt, do którego można dodać właściwości. Więc eksport.myFunc jest tylko skrótem dla modułu.eksport.myFunc .

W rezultacie, jeśli exports jest ustawiony na cokolwiek innego, łamie referencję pomiędzy Moduł.wywóz i wywóz . Ponieważ Moduł.eksport jest tym, co naprawdę dostaje eksportowane, exports nie będzie już działać zgodnie z oczekiwaniami-nie odwołuje się do modułu .eksport Jeśli chcesz utrzymać ten link, możesz utworzyć Moduł.eksport odniesienie eksport ponownie w następujący sposób:

module.exports = exports = db;

Przeszedłem kilka testów i myślę, że to może rzucić trochę światła na ten temat...

app.js:

var ...
  , routes = require('./routes')
  ...;
...
console.log('@routes', routes);
...

Wersje /routes/index.js:

exports = function fn(){}; // outputs "@routes {}"

exports.fn = function fn(){};  // outputs "@routes { fn: [Function: fn] }"

module.exports = function fn(){};  // outputs "@routes function fn(){}"

module.exports.fn = function fn(){};  // outputs "@routes { fn: [Function: fn] }"

Dodałem nawet nowe pliki:

./routes/index.js:

module.exports = require('./not-index.js');
module.exports = require('./user.js');

./routes/not-index.js:

exports = function fn(){};

./routes/user.js:

exports = function user(){};

Otrzymujemy wyjście " @ routes {}"

./routes/index.js:

module.exports.fn = require('./not-index.js');
module.exports.user = require('./user.js');

./routes/not-index.js:

exports = function fn(){};

./routes/user.js:

exports = function user(){};

Otrzymujemy wyjście "@ routes { FN: {}, user: {}} "

./routes/index.js:

module.exports.fn = require('./not-index.js');
module.exports.user = require('./user.js');

./routes/not-index.js:

exports.fn = function fn(){};

./routes/user.js:

exports.user = function user(){};

Otrzymujemy wyjście " @ routes { user: [Function: user] }" Jeśli zmienimy user.js na { ThisLoadedLast: [Function: ThisLoadedLast] }, otrzymamy wyjście "@routes { ThisLoadedLast: [Function: ThisLoadedLast] }".

Ale jeśli zmodyfikujemy ./routes/index.js...

./routes/index.js:

module.exports.fn = require('./not-index.js');
module.exports.ThisLoadedLast = require('./user.js');

./routes/not-index.js:

exports.fn = function fn(){};

./routes/user.js:

exports.ThisLoadedLast = function ThisLoadedLast(){};

... otrzymujemy "@routes { FN: { FN: [Function: fn] }, ThisLoadedLast: { ThisLoadedLast: [Function: ThisLoadedLast]}} "

Więc sugerowałbym zawsze używać module.exports w swoich definicjach modułu.

Nie do końca rozumiem o co chodzi wewnętrznie z Node, ale proszę o komentarz jeśli można zrobić więcej sensu tego, jak jestem pewien, że to pomaga.

-- szczęśliwe kodowanie

To pokazuje, jak require() działa w najprostszej formie, wyciągniętej z wymownego JavaScript

Problem Moduł nie może bezpośrednio eksportować wartości innej niż obiekt exports, np. funkcji. Na przykład, moduł może chcieć wyeksportować tylko konstruktor typu obiektu, który definiuje. W tej chwili nie może tego zrobić, ponieważ require zawsze używa obiektu exports, który tworzy jako wyeksportowaną wartość.

Rozwiązanie Dostarczyć moduły z Inna zmienna, module, która jest obiektem posiadającym właściwość exports. Ta właściwość początkowo wskazuje na pusty obiekt utworzony przez require, ale może zostać nadpisana inną wartością w celu wyeksportowania czegoś innego.

function require(name) {
  if (name in require.cache)
    return require.cache[name];
  var code = new Function("exports, module", readFile(name));
  var exports = {}, module = {exports: exports};
  code(exports, module);
  require.cache[name] = module.exports;
  return module.exports;
}
require.cache = Object.create(null);

Oto wynik

console.log("module:");
console.log(module);

console.log("exports:");
console.log(exports);

console.log("module.exports:");
console.log(module.exports);

Także:

if(module.exports === exports){
    console.log("YES");
}else{
    console.log("NO");
}

//YES

Uwaga: Specyfikacja CommonJS pozwala tylko na użycie zmiennej exports do ujawnienia członków publicznych. Dlatego nazwany wzór eksportu jest jedynym, który jest naprawdę zgodny ze specyfikacją CommonJS. Wykorzystanie modułu.exports jest rozszerzeniem dostarczanym przez węzeł.js do obsługi szerszego zakresu wzorców definicji modułów.

var a = {},md={};

/ / Po pierwsze,eksport i moduł.eksportuje ten sam pusty obiekt

exp = a;//exports =a;
md.exp = a;//module.exports = a;

exp.attr = "change";

console.log(md.exp);//{attr:"change"}

/ / Jeśli wskazujesz exp na inny obiekt zamiast wskazywać jego właściwość na inny obiekt. Md.exp będzie pustym obiektem {}

var a ={},md={};
exp =a;
md.exp =a;

exp = function(){ console.log('Do nothing...'); };

console.log(md.exp); //{}

Z docs

Zmienna exports jest dostępna w zakresie poziomu plików modułu i jest przypisana do wartości modułu.eksportuje przed analizą modułu.

Pozwala na skróty, tak że moduł.eksport.f = ... można pisać zwięźle jako eksport.f = .... należy jednak pamiętać, że jak każda zmienna, jeśli nowa wartość jest przypisana do eksportu, nie jest już powiązana z modułem."eksport": {]}

jest to tylko zmienna wskazując na moduł.eksport.

Znalazłem ten link przydatny do odpowiedzi na powyższe pytanie.

Http://timnew.me/blog/2012/04/20/exports-vs-module-exports-in-node-js/

Aby dodać do innych postów system modułów w node robi

var exports = module.exports 

Przed wykonaniem kodu. Więc jeśli chcesz eksportować = foo , prawdopodobnie chcesz zrobić moduł.exports = exports = foo, ale za pomocą exports.foo = foo powinno być dobrze

" jeśli chcesz, aby główny eksport twojego modułu był funkcją (taką jak konstruktor) lub jeśli chcesz wyeksportować cały obiekt w jednym przydziale, zamiast budować go po jednej właściwości naraz, przypisz go do modułu.eksport zamiast eksportu."- http://nodejs.org/api/modules.html

1.exports - > use as singleton utility
2. module-exports - > use as logical objects such as service , model etc

Stwórzmy jeden moduł na 2 sposoby:

One way

var aa = {
    a: () => {return 'a'},
    b: () => {return 'b'}
}

module.exports = aa;

Second way

exports.a = () => {return 'a';}
exports.b = () => {return 'b';}

I tak require () zintegruje moduł.

Pierwsza droga:

function require(){
    module.exports = {};
    var exports = module.exports;

    var aa = {
        a: () => {return 'a'},
        b: () => {return 'b'}
    }
    module.exports = aa;

    return module.exports;
}

Second way

function require(){
    module.exports = {};
    var exports = module.exports;

    exports.a = () => {return 'a';}
    exports.b = () => {return 'b';}

    return module.exports;
}

W module node js.plik js służy do uruchomienia modułu.system ładowania.za każdym razem, gdy node wykonuje plik, owija zawartość pliku js następująco

'(function (exports, require, module, __filename, __dirname) {',+
     //your js file content
 '\n});'

Z powodu tego zawijania w kod źródłowy ur js możesz uzyskać dostęp do eksportu, require, modułu itp.. to podejście jest używane, ponieważ nie ma innego sposobu, aby uzyskać funkcjonalności zapisane w pliku js do innego.

Następnie node wykonuje tę zawiniętą funkcję używając c++. w tym momencie eksportuje obiekt, który przeszedł do tej funkcji będzie wypełniony.

Możesz zobaczyć wewnątrz tej funkcji parametry eksportu i modułu. w rzeczywistości exports jest publicznym członkiem funkcji konstruktora modułu.

Spójrz na następujący kod

Skopiuj ten kod do b. js

console.log("module is "+Object.prototype.toString.call(module));
console.log("object.keys "+Object.keys(module));
console.log(module.exports);
console.log(exports === module.exports);
console.log("exports is "+Object.prototype.toString.call(exports));
console.log('----------------------------------------------');
var foo = require('a.js');
console.log("object.keys of foo: "+Object.keys(foo));
console.log('name is '+ foo);
foo();

Skopiuj ten kod do a. js

exports.name = 'hello';
module.exports.name = 'hi';
module.exports.age = 23;
module.exports = function(){console.log('function to module exports')};
//exports = function(){console.log('function to export');}

Teraz uruchom za pomocą węzła

To jest wyjście

module is [object Object]
object.keys id,exports,parent,filename,loaded,children,paths
{}
true

Eksport to [object Object]

Obiekt.keys of foo: name is function () {console.log ('function to module exports')} funkcja do eksport modułu

Teraz Usuń skomentowaną linię w.js i skomentuj linię powyżej tej linii i usuń ostatnią linię b. js i uruchom.

W świecie javascript nie można przypisać obiektu przekazanego jako parametr, ale można zmienić publiczny element funkcji, gdy obiekt tej funkcji ustawiony jako parametr na inną funkcję

Do remember

Użyj modułu.eksportuje tylko wtedy, gdy chcesz uzyskać funkcję, gdy używasz słowa kluczowego require . w powyższym przykładzie var foo = require( a. js); możesz zobaczyć, że możemy wywołać foo jako funkcję;

Tak wyjaśnia to dokumentacja węzła "Obiekt exports jest tworzony przez system modułów. Czasami jest to niedopuszczalne, wielu chce, aby ich moduł był instancją jakiejś klasy. W tym celu Przypisz żądany obiekt eksportu do modułu.eksport."

1. Zarówno module.exports jak i exports wskazują na to samo function database_module(cfg) {...}.

   1| var a, b;
   2| a = b = function() { console.log("Old"); };
   3|     b = function() { console.log("New"); };
   4|
   5| a(); // "Old"
   6| b(); // "New"
   

   Możesz zmienić b w linii 3 na a, wyjście jest odwrotne. Wniosek jest następujący:

   a i b są niezależne.

2. Więc module.exports = exports = nano = function database_module(cfg) {...} jest równoważne:

   var f = function database_module(cfg) {...};
   module.exports = f;
   exports = f;
   

   Zakłada się, że powyższe jest module.js, co jest wymagane przez foo.js. Korzyści z module.exports = exports = nano = function database_module(cfg) {...} jest teraz jasne:

   • W foo.js, ponieważ module.exports jest require('./module.js'):

     var output = require('./modules.js')();
     

   • W moduls.js: możesz użyć exports zamiast module.exports.

Więc, będziesz szczęśliwy, jeśli zarówno exports i module.exports wskazując na to samo.

Dlaczego oba są tu używane

Wierzę, że chcą tylko być jasne, że module.exports, exports, i nano wskaż tę samą funkcję-pozwalając na użycie dowolnej zmiennej do wywołania funkcji w pliku. nano dostarcza kontekstu do tego, co robi funkcja.

exports nie będzie eksportowane(tylko module.exports będzie), więc po co nadpisywać to również?

Rozmyślność ogranicza ryzyko przyszłych błędów, takich jak użycie exports zamiast module.exports w aktach. Zawiera również Wyjaśnienie , że module.exports i exports w rzeczywistości wskazują na tę samą wartość.

module.exports vs exports

Dopóki nie zmienisz przypisania module.exports lub exports (i zamiast tego nie dodasz wartości do obiektu, do którego się odnoszą), nie będziesz miał żadnych problemów i możesz bezpiecznie używać exports, aby być bardziej zwięzłym.

Podczas przypisywania do obiektu innego niż obiekt, są one teraz wskazujące na różne miejsca, które mogą być mylące, chyba że celowo chcesz module.exports być czymś konkretnym (np. funkcją).

Ustawienie exports na inny obiekt nie ma większego sensu, ponieważ będziesz musiał ustawić module.exports = exports na końcu, aby móc go używać w innych plikach.

let module = { exports: {} };
let exports = module.exports;

exports.msg = 'hi';
console.log(module.exports === exports); // true

exports = 'yo';
console.log(module.exports === exports); // false

exports = module.exports;
console.log(module.exports === exports); // true

module.exports = 'hello';
console.log(module.exports === exports); // false

module.exports = exports;
console.log(module.exports === exports); // true

Dlaczego przypisać module.exports do funkcji?

App1.js: let sayHello = require('./helloWorld1'); sayHello.hello; // hello world

App2.js: let sayHello = require('./helloWorld2'); sayHello; // hello world