Bagaimana Anda berbagi konstanta dalam modul NodeJS?

Saat ini saya sedang melakukan ini:

foo.js

const FOO = 5;

module.exports = {
    FOO: FOO
};

Dan menggunakannya dalam bar.js:

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

Apakah ada cara yang lebih baik untuk melakukan ini? Rasanya canggung untuk mendeklarasikan konstanta pada objek ekspor.

Anda dapat secara eksplisit mengekspornya ke lingkup global dengan global.FOO = 5. Maka Anda hanya perlu memerlukan file tersebut, dan bahkan tidak menyimpan nilai pengembalian Anda.

Tapi sungguh, Anda tidak harus melakukan itu. Menyimpan segala sesuatu dengan benar adalah hal yang baik. Anda sudah memiliki ide yang tepat, jadi terus lakukan apa yang Anda lakukan.

Menurut pendapat saya, menggunakan Object.freezememungkinkan untuk gaya KERING dan lebih deklaratif. Pola pilihan saya adalah:

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

Peringatan Performa yang sudah usang

Masalah berikut ini diperbaiki di v8 pada Jan 2014 dan tidak lagi relevan untuk sebagian besar pengembang:

Sadarilah bahwa kedua pengaturan dapat ditulisi ke false dan menggunakan Object.freeze memiliki penalti kinerja besar-besaran di v8 - https://bugs.chromium.org/p/v8/issues/detail?id=1858 dan http://jsperf.com / performance-frozen-object

Secara teknis, constini bukan bagian dari spesifikasi ECMAScript. Juga, menggunakan pola "Modul CommonJS" yang telah Anda catat, Anda dapat mengubah nilai "konstan" itu karena sekarang hanya properti objek. (tidak yakin apakah itu akan menyebabkan perubahan pada skrip lain yang memerlukan modul yang sama, tetapi itu mungkin)

Untuk mendapatkan konstan nyata bahwa Anda juga dapat berbagi, memeriksa Object.create, Object.definePropertydan Object.defineProperties. Jika Anda menetapkan writable: false, maka nilai dalam "konstan" Anda tidak dapat dimodifikasi. :)

Ini sedikit bertele-tele, (tetapi bahkan itu dapat diubah dengan sedikit JS) tetapi Anda hanya perlu melakukannya sekali untuk modul konstanta Anda. Dengan menggunakan metode ini, atribut apa pun yang Anda biarkan default false. (sebagai lawan mendefinisikan properti melalui penugasan, yang default semua atribut untuk true)

Jadi, secara hipotesis, Anda bisa mengatur valuedan enumerable, meninggalkan writabledan configurablekarena mereka akan default false, saya baru saja memasukkan mereka untuk kejelasan.

Perbarui - Saya telah membuat modul baru ( konstanta-simpul ) dengan fungsi pembantu untuk kasus penggunaan yang sangat ini.

constants.js - Bagus

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

constants.js - Lebih baik

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

Cara ES6.

ekspor dalam foo.js

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

impor di bar.js

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

Saya menemukan solusi yang disarankan Dominic untuk menjadi yang terbaik, tetapi masih melewatkan satu fitur dari deklarasi "const". Ketika Anda mendeklarasikan konstanta di JS dengan kata kunci "const", keberadaan konstanta diperiksa pada waktu parse, bukan pada saat runtime. Jadi jika Anda salah mengeja nama konstanta di suatu tempat nanti dalam kode Anda, Anda akan mendapatkan kesalahan ketika Anda mencoba memulai program node.js Anda. Yang merupakan pemeriksaan kesalahan pengejaan yang jauh lebih baik.

Jika Anda mendefinisikan konstanta dengan fungsi define () seperti yang disarankan Dominic, Anda tidak akan mendapatkan kesalahan jika Anda salah mengeja konstanta, dan nilai konstanta salah eja akan tidak terdefinisi (yang dapat menyebabkan sakit kepala debugging).

Tapi saya kira ini adalah yang terbaik yang bisa kita dapatkan.

Selain itu, ini adalah semacam peningkatan fungsi Dominic, di 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;

Dengan cara ini Anda dapat menggunakan fungsi define () di modul lain, dan memungkinkan Anda untuk mendefinisikan konstanta di dalam module constants.js dan konstanta di dalam modul tempat Anda memanggil fungsi tersebut. Mendeklarasikan konstanta modul kemudian dapat dilakukan dengan dua cara (dalam script.js).

Pertama:

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

Kedua:

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

Juga, jika Anda ingin fungsi define () dipanggil hanya dari modul konstanta (bukan untuk mengasapi objek global), Anda mendefinisikannya seperti ini di constants.js:

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

dan gunakan seperti ini di script.js:

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

Dari pengalaman proyek sebelumnya, ini adalah cara yang baik:

Dalam 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

Di main.js (atau app.js, dll.), Gunakan seperti di bawah ini:

// main.js

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

console.log(constants.key1);

console.dir(constants.key3);

Saya pikir itu const memecahkan masalah bagi kebanyakan orang yang mencari anwwer ini. Jika Anda benar-benar membutuhkan konstanta abadi, lihat jawaban yang lain. Agar semuanya teratur, saya menyimpan semua konstanta pada folder dan kemudian meminta seluruh folder.

file 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. di sini dealdan noteakan menjadi level pertama di main.js

src / consts_folder / note.js

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

Ps. objakan menjadi level kedua di main.js

src / consts_folder / deal.js

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

Ps. strakan menjadi level kedua di main.js

Hasil akhir pada file main.js:

console.log(constants.deal); Ouput:

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

console.log(constants.note); Ouput:

note: {obj: {type: 'object', description: 'I \' ma note object '}}

importdan export(mungkin perlu sesuatu seperti babel pada 2018 untuk menggunakan impor)

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

Sebagai alternatif, Anda bisa mengelompokkan nilai "konstan" Anda di objek lokal, dan mengekspor fungsi yang mengembalikan klon dangkal objek ini.

var constants = { FOO: "foo" }

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

Maka tidak masalah jika seseorang menetapkan ulang FOO karena hanya akan mempengaruhi salinan lokal mereka.

Karena Node.js menggunakan pola CommonJS, Anda hanya dapat berbagi variabel antara modul dengan module.exportsatau dengan mengatur var global seperti yang Anda lakukan di browser, tetapi alih-alih menggunakan jendela yang Anda gunakan global.your_var = value;.

Saya akhirnya melakukan ini dengan mengekspor objek beku dengan fungsi pengambil anonim, daripada konstanta itu sendiri. Ini mengurangi risiko bug jahat yang diperkenalkan karena kesalahan ketik sederhana dari nama const, karena kesalahan runtime akan dilemparkan jika terjadi kesalahan ketik. Berikut adalah contoh lengkap yang juga menggunakan Simbol ES6 untuk konstanta, memastikan keunikan, dan fungsi panah ES6. Akan menghargai umpan balik jika ada sesuatu dalam pendekatan ini yang tampaknya bermasalah.

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

Saya sarankan melakukannya dengan webpack (menganggap Anda menggunakan webpack).

Menentukan konstanta sesederhana mengatur file konfigurasi webpack:

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

Dengan cara ini Anda mendefinisikannya di luar sumber Anda, dan mereka akan tersedia di semua file Anda.

Saya pikir ini bukan praktik yang baik untuk menyerbu ruang GLOBAL dari modul, tetapi dalam skenario di mana bisa sangat diperlukan untuk mengimplementasikannya:

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

Itu harus dipertimbangkan dampak dari sumber daya ini. Tanpa penamaan konstanta yang tepat, risiko OVERWRITTING sudah didefinisikan variabel global, adalah sesuatu yang nyata.