Какова цель Node.модуль js.экспорт и как вы его используете?

на это уже ответили, но я хотел бы добавить некоторые разъяснения...

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

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

основной вариант использования, который вы увидите (например, в примере кода ExpressJS) , заключается в том, что вы устанавливаете свойства на exports объект в a .JS файл, который затем можно импортировать с помощью require()

так в простом подсчитывая примере, вы смогли есть:

(счетчик.в JS):

var count = 1;

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

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

... затем в вашем приложении (web.JS, или действительно любой другой .JS-файла):

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

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

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

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

(sayhello.в JS):

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

(app.в JS):

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

разница между экспортом и модуль.экспорт объясняется лучше в ответ здесь.

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

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

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

(sayhello.в JS):

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

(app.в JS):

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

или с помощью ЕС6 особенности

(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 (кэширование и циклические ссылки))

несколько вещей, которые вы должны заботиться, если вы назначаете ссылку на новый объект 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() {}; 

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

У меня есть видео на module_export доступно здесь

при разделении кода программы на несколько файлов,module.exports используется для публикации переменных и функций для потребителя модуля. The require() вызов в исходном файле заменяется соответствующим module.exports загрузить из модуля.

помните при написании модулей

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

ссылка на ссылку выглядит так:

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

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

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

почему ?

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

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

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();

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

в узле есть некоторые модули по умолчанию или существующие модули.js при загрузке и установке узла.js like HTTP " и " Сыс etc.

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

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

прежде чем я напишу что-нибудь здесь, Помните, модуль.поставляемый.additionTwo это то же самое, что экспорт.additionTwo

Ха, так вот в чем причина, нам нравится

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

будьте осторожны с путь

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

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

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

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

это будет ошибка, говоря

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

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

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

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

еще одна вещь, вы также можете запустить дополнение.JS-файл, не устанавливая NODE_PATH, возвращается в командную строку nodejs:

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

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

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

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

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

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

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

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

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

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

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

цель:

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

Википедия

Я думаю, что становится трудно писать большие программы без модульного / многоразового кода. В 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;

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

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

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

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

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

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

1. если файл хочет экспортировать что-то он должен объявить его с помощью 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

условие_2.js

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

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

другие полезные вещи, чтобы знать:

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