Jaki jest cel Node.moduł js.eksport i jak z niego korzystać?

To już zostało wyjaśnione, ale chciałem dodać kilka wyjaśnień...

Możesz użyć zarówno exports jak i module.exports do zaimportowania kodu do aplikacji w następujący sposób:

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

Podstawowy przypadek użycia (np. w przykładowym kodzie ExpressJS) polega na tym, że ustawiasz właściwości obiektu exports W a .plik js, który następnie importujesz za pomocą require()

Więc w prostym przykładzie zliczania możesz mieć:

(kontr.js):

var count = 1;

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

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

... wtedy w Twoim aplikacja (web.js, a właściwie każdy inny .plik js):

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

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

Mówiąc najprościej, wymagane pliki można traktować jako funkcje zwracające pojedynczy obiekt i można dodać właściwości (ciągi znaków, liczby,tablice, funkcje, cokolwiek) do zwracanego obiektu, ustawiając je na exports.

Czasami chcesz, aby obiekt zwrócony z wywołania require() był funkcją, którą możesz wywołać, a nie tylko obiektem z właściwościami. W takim przypadku należy również ustawić module.exports, Jak to:

(sayhello.js):

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

(ok.js):

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

Różnica między eksportem a modułem.eksport jest wyjaśnione lepiej w ta odpowiedź tutaj .

Zauważ, że mechanizm modułu NodeJS opiera się na CommonJS moduły, które są obsługiwane w wielu innych implementacjach, takich jak RequireJS, ale także SproutCore, CouchDB, Wakanda, OrientDB, ArangoDB, RingoJS, TeaJS, SilkJS, curl.js, a nawet Adobe Photoshop (via PSLib ). Pełną listę znanych wdrożeń znajdziesz tutaj .

O ile twój moduł nie używa specyficznych funkcji węzła lub modułu, gorąco zachęcam do używania exports zamiast module.exports który nie jest częścią Standardu CommonJS, a następnie w większości nie jest obsługiwany przez inne implementacje.

Kolejną cechą charakterystyczną NodeJS jest przypisanie referencji do nowego obiektu exports zamiast dodawania do niego właściwości i metod, jak w ostatnim przykładzie dostarczonym przez Jed Watsona w tym wątku. Ja osobiście zniechęcaj do tej praktyki, ponieważ ta łamie kołowe wsparcie referencyjne mechanizmu wspólnych modułów js. Nie jest on wtedy wspierany przez wszystkie implementacje I przykład Jed powinien być napisany w ten sposób (lub podobny), aby zapewnić bardziej uniwersalny moduł: {]}

(sayhello.js):

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

(ok.js):

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

Lub za pomocą funkcji ES6

(sayhello.js):

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

(ok.js):

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

PS: wygląda na to, że Appcelerator implementuje również CommonJS Moduły, ale bez circular reference support (patrz: Appcelerator i CommonJS modules (caching i circular reference))

Kilka rzeczy, o które musisz zadbać, jeśli przypisujesz odwołanie do nowego obiektu exports i /lub modules.exports:

1. Wszystkie właściwości/metody wcześniej dołączone do oryginalnego exports lub module.exports są oczywiście utracone, ponieważ wyeksportowany obiekt będzie teraz odwoływał się do innego nowego

Ten jest oczywisty, ale jeśli dodasz wyeksportowaną metodę na początku istniejącego modułu, upewnij się, że wyeksportowany obiekt nie odwołuje się do innego obiektu w 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. W przypadku gdy jeden z exports lub module.exports odwołuje się do nowej wartości, nie odwołuje się już do tego samego obiektu

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. Podstępna konsekwencja. Jeśli zmienisz odniesienie do exports i module.exports, trudno powiedzieć, które API jest narażone (wygląda na to, że module.exports wygrywa)

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

Moduł.właściwość exports lub obiekt exports pozwala modułowi wybrać, co ma być współdzielone z aplikacją

Mam film o module_export dostępny tutaj

Podczas dzielenia kodu programu na wiele plików, module.exports jest używany do publikowania zmiennych i funkcji konsumentowi modułu. Wywołanie require() w pliku źródłowym jest zastępowane odpowiadającym mu wywołaniem module.exports załadowanym z modułu.

Pamiętaj podczas pisania modułów

• Ładowanie modułów jest buforowane, tylko początkowe wywołanie ocenia JavaScript.
• możliwe jest użycie zmiennych lokalnych i funkcji wewnątrz modułu, nie wszystko musi być eksportowane.
• The module.exports obiekt jest również dostępny jako skrót exports. Ale zwracając jedyną funkcję, Zawsze używaj module.exports.

Zgodnie z: "Modules Part 2-Writing modules" .

Odnośnik jest taki:

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

Właściwości exports lub module.exports, takie jak funkcje lub zmienne, będą eksponowane na zewnątrz

Jest coś, na co musisz zwrócić większą uwagę : nie Eksportuj override.

Ponieważ eksportuje tylko odniesienie do modułu.eksport , możesz dodać właściwości do eksportu ,ale jeśli nadpiszesz eksport, link odniesienia zostanie uszkodzony .

Dobry przykład:

exports.name = 'william';

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

Zły przykład :

exports = 'william';

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

Jeśli chcesz wyświetlić tylko jedną funkcję lub zmienną, w ten sposób:

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

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

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

Ten moduł ujawnił tylko jedną funkcję, a właściwość name jest prywatna dla zewnętrznej .

Istnieje kilka domyślnych lub istniejących modułów w node.js podczas pobierania i instalowania node.js jak http, sys itd.

Ponieważ są już w node.js, kiedy chcemy korzystać z tych modułów w zasadzie lubimy importować Moduły , ale dlaczego? ponieważ są one już obecne w węźle.js. Importowanie jest jak pobieranie ich z węzła.js i umieszczanie ich w twoim programie. A potem ich używać.

wywóz jest dokładnie przeciwnie, tworzysz żądany moduł, powiedzmy Dodanie modułu.js i umieszczenie tego modułu w węźle.js, robisz to eksportując.

zanim cokolwiek tu napiszę, pamiętaj, Moduł.eksport.dodatek jest taki sam jak .additionTwo

Huh, więc to jest powód, robimy jak

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

Uważaj na ścieżkę

Powiedzmy, że stworzyłeś dodatek.moduł js,

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

When you run this on Twój węzeł.Wiersz polecenia JS:

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

To będzie błąd mówiąc

Błąd: nie można znaleźć dodania modułu.js

To dlatego, że węzeł.proces js nie jest w stanie dodać.js odkąd nie wspomnieliśmy o ścieżce. Możemy więc ustawić ścieżkę używając NODE_PATH

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

Teraz, to powinno działać pomyślnie bez żadnych błędów!!

Jeszcze jedno, Możesz również uruchomić dodatek.plik js nie ustawiając NODE_PATH, wróć do polecenia nodejs prompt:

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

Ponieważ podajemy tutaj ścieżkę, mówiąc, że znajduje się ona w bieżącym katalogu ./, powinno to również działać pomyślnie.

Moduł zawiera powiązany kod w jedną jednostkę kodu. Podczas tworzenia modułu można to zinterpretować jako przeniesienie wszystkich powiązanych funkcji do pliku.

Załóżmy, że istnieje plik Hello.js, które zawierają dwie funkcje

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

Piszemy funkcję tylko wtedy, gdy użyteczność kodu to więcej niż jedno wywołanie.

Załóżmy, że chcemy zwiększyć użyteczność funkcji do innego pliku say World.js,w tym przypadku eksportowanie pliku wchodzi w obrazek, który można uzyskać przez moduł.eksport.

Możesz po prostu wyeksportować obie funkcje za pomocą kodu podanego poniżej

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

Teraz wystarczy zażądać nazwy pliku do świata.js w celu użycia tych funkcji

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

Intencją jest:

Programowanie Modułowe jest techniką projektowania oprogramowania, która podkreśla rozdzielenie funkcjonalności programu na niezależne, wymiennych modułów, tak aby każdy z nich zawierał wszystko co niezbędne aby wykonać tylko jeden aspekt pożądanej funkcjonalności.

Wikipedia

Wyobrażam sobie, że trudno jest pisać duże programy bez kodu modularnego / wielokrotnego użytku. W nodejs możemy tworzyć programy modułowe wykorzystujące module.exports definiowanie tego, co ujawniamy i z czym tworzymy nasz program require.

Wypróbuj ten przykład:

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;

Program.js

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

log('hello world!');

wykonaj

$ node program.js

Hello world!

A teraz spróbuj zamienić ./ stdoutLogjs dla ./ align = "left" / js .

Jaki jest cel systemu modułowego?

Realizuje następujące rzeczy:

1. utrzymuje nasze pliki z wzdęcia do naprawdę dużych rozmiarów. Pliki zawierające np. 5000 linii kodu są zazwyczaj bardzo trudne do opanowania podczas tworzenia.
2. wymusza rozdzielenie obaw. dzielenie naszego kodu na wiele plików pozwala nam na posiadanie odpowiednich nazw plików dla każdego pliku. W ten sposób możemy łatwo zidentyfikować, co każdy moduł robi i gdzie go znaleźć (zakładając, że stworzyliśmy logiczną strukturę katalogów, która jest nadal Twoim obowiązkiem).

Posiadanie modułów ułatwia znalezienie pewnych części kodu, co czyni nasz kod łatwiejszym do utrzymania.

Jak to działa?

NodejS wykorzystuje system modułu CommomJS, który działa w następujący sposób:

1. Jeśli plik chce coś wyeksportować, musi to zadeklarować używając składni module.export
2. Jeśli plik chce import czegoś musi to zadeklarować używając składni require('file')

Przykład:

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

Inne przydatne rzeczy, które warto wiedzieć:

1. moduły są buforowane . Podczas ładowania tego samego modułu w 2 różnych plikach moduł musi zostać załadowany tylko raz. Drugi raz wywołane require() na tym samym module jest pobierane z pamięci podręcznej.
2. moduły są ładowane w synchroniczne . To zachowanie jest wymagane, jeśli było asynchroniczne, nie mogliśmy od razu uzyskać dostępu do obiektu pobranego z require().