javascript - exports - node js export class




Какова цель Node.js module.exports и как вы ее используете? (8)

Какова цель модульной системы?

Он выполняет следующие действия:

  1. Сохраняет наши файлы от раздувания до действительно больших размеров. Имея файлы с, например, 5000 строк кода в нем, как правило, трудно справиться во время разработки.
  2. Обеспечивает разделение проблем. Наличие нашего кода, разбитого на несколько файлов, позволяет нам иметь соответствующие имена файлов для каждого файла. Таким образом, мы можем легко определить, что делает каждый модуль и где его найти (при условии, что мы создали логическую структуру каталогов, которая по-прежнему является вашей ответственностью).

Наличие модулей облегчает поиск определенных частей кода, что делает наш код более удобным.

Как это работает?

NodejS использует систему модулей CommomJS, которая работает следующим образом:

  1. Если файл хочет что-то экспортировать, он должен объявить его с module.export синтаксиса module.export
  2. Если файл хочет что-то импортировать, он должен объявить его с помощью синтаксиса require('file')

Пример:

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

Другие полезные вещи:

  1. Модули кэшируются . Когда вы загружаете один и тот же модуль в 2 разных файла, модуль нужно загружать только один раз. Второй раз, когда require() вызывается в том же модуле, вытаскивается из кеша.
  2. Модули загружаются синхронно . Это поведение требуется, если оно было асинхронным, мы не могли сразу получить доступ к объекту, полученному из require() .

Какова цель Node.js module.exports и как вы ее используете?

Я не могу найти какую-либо информацию об этом, но, похоже, это довольно важная часть Node.js, поскольку я часто вижу ее в исходном коде.

Согласно документации Node.js :

модуль

Ссылка на текущий module . В частности, module.exports совпадает с объектом экспорта. См. src/node.js для получения дополнительной информации.

Но это не очень помогает.

Что именно делает module.exports и что будет простым примером?


Модуль инкапсулирует связанный код в единую единицу кода. При создании модуля это можно интерпретировать как перемещение всех связанных функций в файл.

Предположим, что есть файл Hello.js, который включает в себя две функции

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

Мы пишем функцию только тогда, когда полезность кода имеет более одного вызова.

Предположим, что мы хотим повысить полезность функции в другом файле, скажем World.js, в этом случае экспортируется файл, который может быть получен с помощью module.exports.

Вы можете просто экспортировать обе функции по приведенному ниже коду

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

Теперь вам просто нужно указать имя файла в World.js inorder для использования этих функций

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

Несколько вещей, которые вы должны позаботиться, если назначить ссылку на новый объект для exports и / или modules.exports :

1. Все свойства / методы, ранее прикрепленные к исходному exports или module.exports , конечно, потеряны, потому что экспортируемый объект теперь ссылается на другой новый

Это очевидно, но если вы добавите экспортированный метод в начале существующего модуля, убедитесь, что собственный экспортированный объект не ссылается на другой объект в конце

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. Если один из exports или module.exports ссылается на новое значение, они больше не ссылаются на один и тот же объект

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. Трудные последствия. Если вы измените ссылку на exports и module.exports , трудно сказать, какой API выставляется (это выглядит как победы в module.exports )

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

Обратите внимание, что механизм модуля NodeJS основан на модулях CommonJS которые поддерживаются во многих других реализациях, таких как RequireJS , но также SproutCore , CouchDB , Wakanda , OrientDB , ArangoDB , RingoJS , TeaJS , SilkJS , curl.js или даже Adobe Photoshop (через PSLib ). Здесь вы можете найти полный список известных реализаций.

Если ваш модуль не использует узловые функции или модуль, я настоятельно рекомендую вам использовать exports вместо module.exports который не является частью стандарта CommonJS , а затем в большинстве случаев не поддерживается другими реализациями.

Другая особенность NodeJS - это когда вы назначаете ссылку на новый объект для exports вместо того, чтобы просто добавлять к нему свойства и методы, как в последнем примере, представленном Jed Watson в этом потоке. Я лично бы отговорил эту практику, так как это нарушает круглую справочную поддержку механизма модулей CommonJS. Затем он не поддерживается всеми реализациями, и пример Jed должен быть написан таким образом (или аналогичным) для обеспечения более универсального модуля:

(sayhello.js):

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

(app.js):

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

Или используя функции 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!"

PS: Похоже, что Appcelerator также реализует модули CommonJS, но без поддержки циклических ссылок (см .: Модули Appcelerator и CommonJS (кеширование и циклические ссылки) )


Существуют некоторые стандартные или существующие модули в node.js при загрузке и установке node.js, таких как http, sys и т. Д.

Поскольку они уже находятся в node.js, когда мы хотим использовать эти модули, мы в основном используем модули импорта , но почему? потому что они уже присутствуют в node.js. Импорт - это как перенос их из node.js и включение их в вашу программу. И затем, используя их.

В то время как Exports - это точно противоположное, вы создаете модуль, который хотите, скажем, module addition.js и помещаем этот модуль в node.js, вы делаете это, экспортируя его.

Прежде чем написать что-нибудь здесь, помните, module.exports.additionTwo такой же, как export.additionTwo

Да, так вот, нам нравится

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

Будьте осторожны с дорожкой

Допустим, вы создали модуль add.js,

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

Когда вы запустите это в командной строке NODE.JS:

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

Это приведет к ошибке, сказав:

Ошибка: не удается найти модуль add.js

Это связано с тем, что процесс node.js не может скомпоновать add.js, так как мы не упомянули путь. Таким образом, мы можем установить путь, используя NODE_PATH

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

Теперь это должно успешно работать без ошибок!

Кроме того, вы также можете запустить файл added.js, не устанавливая NODE_PATH, обратно в командную строку nodejs:

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

Поскольку мы предоставляем путь здесь, говоря, что он находится в текущем каталоге ./ это также должно успешно выполняться.


Цель:

Модульное программирование - это технология разработки программного обеспечения, которая подчеркивает разделение функциональности программы на независимые взаимозаменяемые модули, так что каждая из них содержит все необходимое для выполнения только одного аспекта желаемой функциональности.

Wikipedia

Я думаю, что становится сложно писать большие программы без модульного / многоразового кода. В nodejs мы можем создавать модульные программы, используя module.exports определяющие, что мы предоставляем и составляем нашу программу с require .

Попробуйте этот пример:

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

выполнять

$ node program.js

Привет, мир!

Теперь попробуйте поменять местами ./stdoutLog.js для ./fileLog.js .


ссылка ссылается следующим образом:

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

свойства exports или module.exports , такие как функции или переменные, будут выставлены вне

вы должны уделять больше внимания: не override экспорт.

Зачем ?

потому что экспортирует только ссылку module.exports, вы можете добавить свойства в экспорт, но если вы переопределите экспорт, ссылка будет нарушена.

хороший пример :

exports.name = 'william';

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

плохой пример:

exports = 'william';

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

Если вы просто хотите открыть только одну функцию или переменную, например:

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

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

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

этот модуль раскрывает только одну функцию, а свойство имени является закрытым для внешнего.


module.exports - это объект, который фактически возвращается в результате вызова вызова.

Первоначально переменная exports устанавливается на тот же объект (т. Е. Это сокращенный псевдоним), поэтому в коде модуля вы обычно пишете что-то вроде этого:

var myFunc1 = function() { ... };
var myFunc2 = function() { ... };
exports.myFunc1 = myFunc1;
exports.myFunc2 = myFunc2;

экспортировать (или «выставить») внутренние функции myFunc1 и myFunc2 .

И в коде вызова вы будете использовать:

var m = require('./mymodule');
m.myFunc1();

где последняя строка показывает, как результат require (обычно) - это просто простой объект, свойства которого могут быть доступны.

NB: если вы перезаписываете exports то он больше не будет ссылаться на module.exports . Поэтому, если вы хотите назначить новый объект (или ссылку на функцию) для exports вы также должны назначить этот новый объект module.exports

Стоит отметить, что имя, добавленное в объект exports , не обязательно должно совпадать с именем внутренней области модуля для значения, которое вы добавляете, чтобы вы могли:

var myVeryLongInternalName = function() { ... };
exports.shortName = myVeryLongInternalName;
// add other objects, functions, as required

с последующим:

var m = require('./mymodule');
m.shortName(); // invokes module.myVeryLongInternalName




node.js