Як ви ділите константи в модулях NodeJS?

В даний час я роблю це:

foo.js

const FOO = 5;

module.exports = {
    FOO: FOO
};

І використовуючи це в bar.js:

var foo = require('foo');
foo.FOO; // 5

Чи є кращий спосіб зробити це? Незручно оголошувати константу в об'єкті експорту.

Ви можете явно експортувати його в глобальний обсяг за допомогою global.FOO = 5. Тоді вам просто потрібно вимагати файл, і навіть не зберігати своє повернене значення.

Але насправді, не варто цього робити. Зберігати речі правильно капсульованими - це добре. Ви вже маєте правильну ідею, тому продовжуйте робити те, що ви робите.

На мою думку, використання Object.freezeдозволяє отримати сушений і декларативніший стиль. Мій кращий зразок:

./lib/constants.js

module.exports = Object.freeze({
    MY_CONSTANT: 'some value',
    ANOTHER_CONSTANT: 'another value'
});

./lib/some-module.js

var constants = require('./constants');

console.log(constants.MY_CONSTANT); // 'some value'

constants.MY_CONSTANT = 'some other value';

console.log(constants.MY_CONSTANT); // 'some value'

Застаріле попередження про ефективність

Наступна проблема була виправлена ​​в v8 в січні 2014 року і більше не стосується більшості розробників:

Майте на увазі, що як налаштування, що можна записати на помилкове, так і використовувати Object.freeze, у версії v8 передбачено велике покарання за продуктивність - https://bugs.chromium.org/p/v8/isissue/detail?id=1858 та http://jsperf.com / performance-Заморожений-об'єкт

Технічно constне входить до специфікації ECMAScript. Також, використовуючи вказаний вами шаблон "CommonJS модуль", ви можете змінити значення цієї "константи", оскільки тепер це лише властивість об'єкта. .

Для того, щоб отримати реальну константу, ви можете поділитися, перевірити Object.create, Object.definePropertyі Object.defineProperties. Якщо ви встановите writable: false, значення у вашій "константі" неможливо змінити. :)

Це трохи детально, (але навіть це можна змінити за допомогою невеликого JS), але вам потрібно зробити це лише один раз для вашого модуля констант. Використовуючи ці методи, будь-який атрибут, для якого ви не залишаєте стандартні false. (на відміну від визначення властивостей за допомогою призначення, яке за замовчуванням застосовує всі атрибути true)

Отже, гіпотетично, ви можете просто встановити, valueі enumerable, виходячи з роботи, writableі configurableоскільки вони за замовчуванням false, я щойно включив їх для ясності.

Оновлення - я створив новий модуль ( вузли-константи ) з допоміжними функціями для цього дуже зручного випадку.

constants.js - Добре

Object.defineProperty(exports, "PI", {
    value:        3.14,
    enumerable:   true,
    writable:     false,
    configurable: false
});

constants.js - Краще

function define(name, value) {
    Object.defineProperty(exports, name, {
        value:      value,
        enumerable: true
    });
}

define("PI", 3.14);

script.js

var constants = require("./constants");

console.log(constants.PI); // 3.14
constants.PI = 5;
console.log(constants.PI); // still 3.14

ES6 спосіб.

експорт у foo.js

const FOO = 'bar';
module.exports = {
  FOO
}

імпорт у bar.js

const {FOO} = require('foo');

Я знайшов рішення, яке Домінік запропонував як найкраще, але воно все ще не вистачає однієї функції декларації "const". Коли ви оголошуєте константу в JS за допомогою ключового слова "const", існування константи перевіряється під час розбору, а не під час виконання. Тож якщо ви неправильно написали ім'я константи десь пізніше у своєму коді, ви отримаєте помилку при спробі запуску програми node.js. Що набагато краще перевірки орфографії.

Якщо ви визначите константу з функцією define (), як запропонував Домінік, ви не отримаєте помилку, якщо помилково написали константу, і значення констант, написане неправильно, буде невизначено (що може призвести до налагодження головних болів).

Але я думаю, це найкраще, що ми можемо отримати.

Крім того, ось своєрідне вдосконалення функції Домініка в constans.js:

global.define = function ( name, value, exportsObject )
{
    if ( !exportsObject )
    {
        if ( exports.exportsObject )
            exportsObject = exports.exportsObject;
        else 
            exportsObject = exports;        
    }

    Object.defineProperty( exportsObject, name, {
        'value': value,
        'enumerable': true,
        'writable': false,
    });
}

exports.exportObject = null;

Таким чином ви можете використовувати функцію define () в інших модулях, і вона дозволяє визначати константи як всередині модуля constants.js, так і константи всередині вашого модуля, з якого ви викликали функцію. Оголошення констант модуля може бути зроблено двома способами (у script.js).

Перший:

require( './constants.js' );

define( 'SOME_LOCAL_CONSTANT', "const value 1", this ); // constant in script.js
define( 'SOME_OTHER_LOCAL_CONSTANT', "const value 2", this ); // constant in script.js

define( 'CONSTANT_IN_CONSTANTS_MODULE', "const value x" ); // this is a constant in constants.js module

Друге:

constants = require( './constants.js' );

// More convenient for setting a lot of constants inside the module
constants.exportsObject = this;
define( 'SOME_CONSTANT', "const value 1" ); // constant in script.js
define( 'SOME_OTHER_CONSTANT', "const value 2" ); // constant in script.js

Крім того, якщо ви хочете, щоб функція define () викликалася тільки з модуля констант (щоб не роздував глобальний об'єкт), ви визначаєте її так у constants.js:

exports.define = function ( name, value, exportsObject )

і використовувати його так у script.js:

constants.define( 'SOME_CONSTANT', "const value 1" );

З попереднього досвіду проекту, це хороший спосіб:

В the constants.js:

// constants.js

'use strict';

let constants = {
    key1: "value1",
    key2: "value2",
    key3: {
        subkey1: "subvalue1",
        subkey2: "subvalue2"
    }
};

module.exports =
        Object.freeze(constants); // freeze prevents changes by users

У main.js (або app.js тощо) використовуйте його, як показано нижче:

// main.js

let constants = require('./constants');

console.log(constants.key1);

console.dir(constants.key3);

Я думаю, що це constвирішує проблему для більшості людей, які шукають цю передчуття. Якщо вам справді потрібна незмінна константа, подивіться на інші відповіді. Щоб все було організовано, я зберігаю всі константи в папці, а потім вимагаю всю папку.

файл src / main.js

const constants = require("./consts_folder");

src / consts_folder / index.js

const deal = require("./deal.js")
const note = require("./note.js")


module.exports = {
  deal,
  note
}

Пс. тут dealі noteбуде перший рівень на main.js

src / consts_folder / note.js

exports.obj = {
  type: "object",
  description: "I'm a note object"
}

Пс. objбуде другим рівнем на main.js

src / consts_folder / deal.js

exports.str = "I'm a deal string"

Пс. strбуде другим рівнем на main.js

Кінцевий результат у файлі main.js:

console.log(constants.deal); Вихід:

{deal: {str: 'I \' ma deal string '},

console.log(constants.note); Вихід:

Примітка: {obj: {type: 'object', description: 'I \' ma note object '}}

importі export(проблематика потребує щось на зразок бабеля станом на 2018 рік, щоб використовувати імпорт)

types.js

export const BLUE = 'BLUE'
export const RED = 'RED'

myApp.js

import * as types from './types.js'

const MyApp = () => {
  let colour = types.RED
}

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import

Як альтернатива, ви можете згрупувати свої "постійні" значення в локальний об'єкт та експортувати функцію, яка повертає мілкий клон цього об'єкта.

var constants = { FOO: "foo" }

module.exports = function() {
  return Object.assign({}, constants)
}

Тоді не має значення, чи хтось повторно призначить FOO, оскільки це вплине лише на їх локальну копію.

Оскільки Node.js використовує шаблони CommonJS, ви можете ділитися змінними між модулями лише за module.exportsдопомогою встановлення глобального варіанту var, як у браузері, але замість того, щоб використовувати вікно, яке ви використовуєте global.your_var = value;.

Я закінчив це, експортувавши заморожений об'єкт з анонімними функціями отримання, а не самі константи. Це зменшує ризик появи неприємних помилок через простий друк назви const, оскільки помилка виконання буде видана у разі помилки. Ось повний приклад, який також використовує символи ES6 для констант, забезпечуючи унікальність та функції стрілок ES6. Будемо вдячні за відгуки, якщо щось у цьому підході здасться проблематичним.

'use strict';
const DIRECTORY = Symbol('the directory of all sheets');
const SHEET = Symbol('an individual sheet');
const COMPOSER = Symbol('the sheet composer');

module.exports = Object.freeze({
  getDirectory: () => DIRECTORY,
  getSheet: () => SHEET,
  getComposer: () => COMPOSER
});

Я рекомендую робити це з webpack (припускаючи, що ви використовуєте webpack).

Визначити константи так само просто, як встановити файл конфігурації веб-пакету:

var webpack = require('webpack');
module.exports = {
    plugins: [
        new webpack.DefinePlugin({
            'APP_ENV': '"dev"',
            'process.env': {
                'NODE_ENV': '"development"'
            }
        })
    ],    
};

Таким чином ви визначаєте їх поза своїм джерелом, і вони будуть доступні у всіх ваших файлах.

Я не думаю, що це вдала практика вторгнутись у простір GLOBAL від модулів, але в сценаріях, де це може бути суворо необхідне для його реалізації:

Object.defineProperty(global,'MYCONSTANT',{value:'foo',writable:false,configurable:false});

Слід враховувати вплив цього ресурсу. Без належного іменування цих констант, ризик ЗАПИСУВАННЯ вже визначених глобальних змінних є чимось реальним.