Como você compartilha constantes nos módulos do NodeJS?

Atualmente estou fazendo isso:

foo.js

const FOO = 5;

module.exports = {
    FOO: FOO
};

E usá-lo em bar.js:

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

Existe uma maneira melhor de fazer isso? Parece estranho declarar a constante no objeto de exportação.

Você pode exportá-lo explicitamente para o escopo global com global.FOO = 5. Então você simplesmente precisa exigir o arquivo e nem mesmo salvar seu valor de retorno.

Mas realmente, você não deveria fazer isso. Manter as coisas adequadamente encapsuladas é uma coisa boa. Você já tem a idéia certa, então continue fazendo o que está fazendo.

Na minha opinião, a utilização Object.freezepermite um estilo mais seco e declarativo. Meu padrão preferido é:

./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'

Aviso de desempenho desatualizado

O seguinte problema foi corrigido na v8 em janeiro de 2014 e não é mais relevante para a maioria dos desenvolvedores:

Lembre-se de que a configuração de gravável como false e o uso do Object.freeze têm uma penalidade de desempenho maciça na v8 - https://bugs.chromium.org/p/v8/issues/detail?id=1858 e http://jsperf.com / objeto congelado desempenho

Tecnicamente, constnão faz parte da especificação ECMAScript. Além disso, usando o padrão "CommonJS Module" que você anotou, é possível alterar o valor dessa "constante", já que agora é apenas uma propriedade do objeto. (não tenho certeza se isso trará alterações em cascata a outros scripts que exigem o mesmo módulo, mas é possível)

Para obter uma constante real que você também pode compartilhar, veja Object.create, Object.definePropertye Object.defineProperties. Se você definir writable: false, o valor na sua "constante" não poderá ser modificado. :)

É um pouco detalhado, (mas mesmo isso pode ser alterado com um pouco de JS), mas você só precisa fazer isso uma vez para o seu módulo de constantes. Usando esses métodos, qualquer atributo que você deixar de fora é o padrão false. (ao contrário de definir propriedades por meio de atribuição, cujo padrão é todos os atributos true)

Então, hipoteticamente, você pode simplesmente definir valuee enumerable, deixando de fora writablee, configurablecomo eles serão o padrão false, eu os incluí para maior clareza.

Atualização - Criei um novo módulo ( constantes de nó ) com funções auxiliares para esse mesmo caso de uso.

constants.js - Bom

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

constants.js - Melhor

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.

exportar em foo.js

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

importar em bar.js

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

Eu achei a solução que Dominic sugeriu ser a melhor, mas ainda falta um recurso da declaração "const". Quando você declara uma constante em JS com a palavra-chave "const", a existência da constante é verificada no tempo de análise, não no tempo de execução. Portanto, se você digitou incorretamente o nome da constante em algum lugar posteriormente no seu código, receberá um erro ao tentar iniciar o programa node.js. Qual é uma verificação ortográfica muito mais melhor.

Se você definir a constante com a função define () como sugerido por Dominic, você não receberá um erro se tiver digitado incorretamente a constante, e o valor da constante incorreta será indefinido (o que pode levar a dores de cabeça na depuração).

Mas acho que é o melhor que podemos conseguir.

Além disso, aqui está um tipo de melhoria da função de Dominic, em 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;

Dessa forma, você pode usar a função define () em outros módulos, e permite definir constantes dentro do módulo constants.js e constantes dentro do módulo a partir do qual você chamou a função. A declaração de constantes do módulo pode ser feita de duas maneiras (em script.js).

Primeiro:

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

Segundo:

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

Além disso, se você deseja que a função define () seja chamada apenas a partir do módulo constantes (para não inchar o objeto global), defina-a assim em constants.js:

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

e use-o assim em script.js:

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

Da experiência anterior do projeto, esta é uma boa maneira:

No 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

No main.js (ou app.js, etc.), use-o como abaixo:

// main.js

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

console.log(constants.key1);

console.dir(constants.key3);

Eu acho que constresolve o problema para a maioria das pessoas que procura esse anwwer. Se você realmente precisa de uma constante imutável, procure as outras respostas. Para manter tudo organizado, salve todas as constantes em uma pasta e exijo a pasta inteira.

arquivo 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
}

Ps. aqui o deale noteserá o primeiro nível no main.js

src / consts_folder / note.js

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

Ps. objserá o segundo nível no main.js

src / consts_folder / deal.js

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

Ps. strserá o segundo nível no main.js

Resultado final no arquivo main.js.

console.log(constants.deal); Ouput:

{deal: {str: 'Eu sou uma string de transação'},

console.log(constants.note); Ouput:

note Observação: {obj: {type: 'object', descrição: 'Eu sou um objeto de anotação'}}

importe export(provavelmente precisará de algo como babel a partir de 2018 para usar a importação)

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

Como alternativa, você pode agrupar seus valores "constantes" em um objeto local e exportar uma função que retorna um clone superficial desse objeto.

var constants = { FOO: "foo" }

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

Então, não importa se alguém reatribuir o FOO, porque isso afetará apenas sua cópia local.

Como o Node.js está usando os padrões CommonJS, você só pode compartilhar variáveis ​​entre os módulos com module.exportsou definindo uma var global como faria no navegador, mas em vez de usar a janela usada global.your_var = value;.

Acabei fazendo isso exportando um objeto congelado com funções getter anônimas, em vez das próprias constantes. Isso reduz o risco de erros desagradáveis ​​introduzidos devido a um simples erro de digitação do nome const, pois um erro de tempo de execução será gerado no caso de um erro de digitação. Aqui está um exemplo completo que também usa os símbolos ES6 para as constantes, garantindo a exclusividade e as funções de seta ES6. Gostaria de receber feedback se algo nessa abordagem parecer problemático.

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

Eu recomendo fazê-lo com o webpack (pressupõe que você esteja usando o webpack).

Definir constantes é tão simples quanto definir o arquivo de configuração do webpack:

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

Dessa forma, você os define fora da sua fonte e eles estarão disponíveis em todos os seus arquivos.

Não acho que seja uma boa prática invadir o espaço GLOBAL a partir de módulos, mas em cenários onde poderia ser estritamente necessário implementá-lo:

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

Deve ser considerado o impacto desse recurso. Sem a nomeação adequada dessas constantes, o risco de SOBRESCREVER variáveis ​​globais já definidas é algo real.