blocks|key|1955708|text|您可以使用global.FOO+=+5显式地将其导出到全局范围。然后，您只需要请求该文件，甚至不保存返回值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1955709|但说真的，你不应该这么做。保持适当的封装是一件好事。你已经有了正确的想法，所以继续做你正在做的事情。|1955710|entityMap^0|5|E|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

You can explicitly export it to the global scope with <code>global.FOO = 5</code>. Then you simply need to require the file, and not even save your return value.

But really, you shouldn't do that. Keeping things properly encapsulated is a good thing. You have the right idea already, so keep doing what you're doing.

blocks|key|1742543|text|在我看来，利用Object.freeze允许使用DRYer和更具声明性的风格。我更喜欢的模式是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1742544|./lib/constants.js|1742545|module.exports+=+Object.freeze({
++++MY_CONSTANT:+'some+value',
++++ANOTHER_CONSTANT:+'another+value'
});|code-block|syntax|javascript|1742546|./lib/some-module.js|1742547|var+constants+=+require('./constants');

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

constants.MY_CONSTANT+=+'some+other+value';

console.log(constants.MY_CONSTANT);+//+'some+value'|1742548|过时的性能警告|1742549|以下问题已于2014年1月在v8中修复，不再与大多数开发人员相关：|1742550|请注意，将writable设置为false和使用Object.freeze都会在v8+-+https://bugs.chromium.org/p/v8/issues/detail?id=1858和http://jsperf.com/performance-frozen-object中产生巨大的性能损失|1742551|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze|1|https://bugs.chromium.org/p/v8/issues/detail?id=1858|2|http://jsperf.com/performance-frozen-object^0|7|D|7|D|0|0|0|I|0|0|0|K|0|0|0|0|19|1G|1|2Q|17|2|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|F|3|G|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1M|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1N|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1O|8|@]|D|@$9|1P|A|1Q|1|1R]|$9|1S|A|1T|1|1U]]|E|$]]|$1|W|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]|16|$5|Z|10|11|E|$12|17]]]]

In my opinion, utilizing <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze" rel="noreferrer"><code>Object.freeze</code></a> allows for a DRYer and more declarative style. My preferred pattern is:
<h3><code>./lib/constants.js</code></h3>
<pre><code>module.exports = Object.freeze({
 MY_CONSTANT: 'some value',
 ANOTHER_CONSTANT: 'another value'
});
</code></pre>
<h3><code>./lib/some-module.js</code></h3>
<pre><code>var constants = require('./constants');

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

constants.MY_CONSTANT = 'some other value';

console.log(constants.MY_CONSTANT); // 'some value'
</code></pre>
<h3>Outdated Performance Warning</h3>
The following issue was fixed in v8 in Jan 2014 and is no longer relevant to most developers:
Be aware that both setting writable to false and using Object.freeze have a massive performance penalty in v8 - <a href="https://bugs.chromium.org/p/v8/issues/detail?id=1858" rel="noreferrer">https://bugs.chromium.org/p/v8/issues/detail?id=1858</a> and <a href="http://jsperf.com/performance-frozen-object" rel="noreferrer">http://jsperf.com/performance-frozen-object</a>

blocks|key|1956159|text|ES6方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1956160|以foo.js格式导出|1956161|const+FOO+=+'bar';
module.exports+=+{
++FOO
}|code-block|syntax|javascript|1956162|在bar.js中导入|1956163|const+{FOO}+=+require('foo');|1956164|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

ES6 way.

export in foo.js

<pre><code>const FOO = 'bar';
module.exports = {
 FOO
}
</code></pre>

import in bar.js

<pre><code>const {FOO} = require('foo');
</code></pre>

blocks|key|1742470|text|我发现Dominic建议的解决方案是最好的，但它仍然缺少"const“声明的一个特征。当您在JS中使用"const“关键字声明一个常量时，将在解析时而不是运行时检查该常量是否存在。因此，如果您稍后在代码中的某个地方拼写错误了常量的名称，那么当您尝试启动node.js程序时就会得到一个错误。这是一种更好的拼写错误检查。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1742471|如果您像Dominic建议的那样使用define()函数定义常量，那么在拼写错误的情况下不会出现错误，并且拼写错误的常量的值将是未定义的(这可能会导致调试难题)。|1742472|但我想这是我们能得到的最好的了。|1742473|此外，这是在constans.js中对Dominic函数的一种改进：|1742474|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;|code-block|syntax|javascript|1742475|通过这种方式，您可以在其他模块中使用define()函数，并且它允许您在constants.js模块中定义常量，以及在从中调用该函数的模块中定义常量。然后可以通过两种方式声明模块常量(在script.js中)。|1742476|首先：|1742477|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|1742478|第二：|1742479|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|1742480|此外，如果您希望仅从constants模块调用define()函数(而不是使全局对象膨胀)，则可以在constants.js中这样定义它：|1742481|exports.define+=+function+(+name,+value,+exportsObject+)|1742482|在script.js中像这样使用它：|1742483|constants.define(+'SOME_CONSTANT',+"const+value+1"+);|1742484|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1D|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|1F|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|J|7|1J|8|@]|9|@]|A|$K|L]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

I found the solution Dominic suggested to be the best one, but it still misses one feature of the "const" declaration. When you declare a constant in JS with the "const" keyword, the existence of the constant is checked at parse time, not at runtime. So if you misspelled the name of the constant somewhere later in your code, you'll get an error when you try to start your node.js program. Which is a far more better misspelling check.

If you define the constant with the define() function like Dominic suggested, you won't get an error if you misspelled the constant, and the value of the misspelled constant will be undefined (which can lead to debugging headaches).

But I guess this is the best we can get.

Additionally, here's a kind of improvement of Dominic's function, in constans.js:

<pre><code>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;
</code></pre>

In this way you can use the define() function in other modules, and it allows you to define constants both inside the constants.js module and constants inside your module from which you called the function. Declaring module constants can then be done in two ways (in script.js).

First:

<pre><code>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
</code></pre>

Second:

<pre><code>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
</code></pre>

Also, if you want the define() function to be called only from the constants module (not to bloat the global object), you define it like this in constants.js:

<pre><code>exports.define = function ( name, value, exportsObject )
</code></pre>

and use it like this in script.js:

<pre><code>constants.define( 'SOME_CONSTANT', "const value 1" );
</code></pre>

blocks|key|1742872|text|从以前的项目经验来看，这是一个很好的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1742873|在constants.js中：|1742874|//+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|code-block|syntax|javascript|1742875|在main.js+(或app.js等)中，按如下方式使用它：|1742876|//+main.js

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

console.log(constants.key1);

console.dir(constants.key3);|1742877|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

From previous project experience, this is a good way:

In the constants.js:

<pre><code>// 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
</code></pre>

In main.js (or app.js, etc.), use it as below:

<pre><code>// main.js

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

console.log(constants.key1);

console.dir(constants.key3);
</code></pre>

blocks|key|1956345|text|import和export+(从2018年起，prob需要类似于babel的东西才能使用导入)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1956346|types.js|1956347|export+const+BLUE+=+'BLUE'
export+const+RED+=+'RED'|code-block|syntax|javascript|1956348|myApp.js|1956349|import+*+as+types+from+'./types.js'

const+MyApp+=+()+=>+{
++let+colour+=+types.RED
}|1956350|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import|1956351|entityMap|0|LINK|mutability|MUTABLE|url^0|0|6|7|6|0|0|0|0|0|0|2B|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|S|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|R]]]]

<code>import</code> and <code>export</code> (prob need something like babel as of 2018 to use import)

types.js

<pre><code>export const BLUE = 'BLUE'
export const RED = 'RED'
</code></pre>

myApp.js

<pre><code>import * as types from './types.js'

const MyApp = () =&gt; {
 let colour = types.RED
}
</code></pre>

<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import" rel="noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import</a>

blocks|key|1742774|text|作为另一种选择，您可以将“常量”值分组到一个本地对象中，然后导出一个函数，该函数返回此对象的浅克隆。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1742775|var+constants+=+{+FOO:+"foo"+}

module.exports+=+function()+{
++return+Object.assign({},+constants)
}|code-block|syntax|javascript|1742776|那么，如果有人重新分配FOO也没关系，因为这只会影响他们的本地副本。|1742777|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As an alternative, you can group your "constant" values in a local object, and export a function that returns a shallow clone of this object.

<pre><code>var constants = { FOO: "foo" }

module.exports = function() {
 return Object.assign({}, constants)
}
</code></pre>

Then it doesn't matter if someone re-assigns FOO because it will only affect their local copy.

blocks|key|1742410|text|由于Node.js使用的是CommonJS模式，因此您只能使用module.exports或通过设置全局变量(就像在浏览器中那样)在模块之间共享变量，但是您可以使用global.your_var+=+value;而不是window。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1742411|entityMap^0|V|E|2A|O|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Since Node.js is using the CommonJS patterns, you can only share variables between modules with <code>module.exports</code> or by setting a global var like you would in the browser, but instead of using window you use <code>global.your_var = value;</code>.

blocks|key|1955974|text|我最终通过导出一个带有匿名getter函数的冻结对象，而不是常量本身来做到这一点。这降低了由于const名称的简单拼写错误而引入的讨厌bug的风险，因为在拼写错误的情况下将抛出运行时错误。下面是一个完整的示例，它还使用了常量和ES6箭头函数的ES6符号，以确保唯一性。如果这种方法中有任何问题，我将非常感谢反馈。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1955975|'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
});|code-block|syntax|javascript|1955976|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I ended up doing this by exporting a frozen object with anonymous getter functions, rather than the constants themselves. This reduces the risk of nasty bugs introduced due to a simple typo of the const name, as a runtime error will be thrown in case of a typo. Here's a full example that also uses ES6 Symbols for the constants, ensuring uniqueness, and ES6 arrow functions. Would appreciate feedback if anything in this approach seems problematic.

<pre><code>'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: () =&gt; DIRECTORY,
 getSheet: () =&gt; SHEET,
 getComposer: () =&gt; COMPOSER
});
</code></pre>

blocks|key|1956010|text|我推荐使用webpack+(假设你使用的是webpack)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1956011|定义常量就像设置webpack配置文件一样简单：|1956012|var+webpack+=+require('webpack');
module.exports+=+{
++++plugins:+[
++++++++new+webpack.DefinePlugin({
++++++++++++'APP_ENV':+'"dev"',
++++++++++++'process.env':+{
++++++++++++++++'NODE_ENV':+'"development"'
++++++++++++}
++++++++})
++++],++++
};|code-block|syntax|javascript|1956013|通过这种方式，您可以在源代码之外定义它们，它们将在您的所有文件中可用。|1956014|entityMap|0|LINK|mutability|MUTABLE|url|https://webpack.github.io/^0|5|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I recommend doing it with <a href="https://webpack.github.io/" rel="nofollow">webpack</a> (assumes you're using webpack).

Defining constants is as simple as setting the webpack config file:

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

This way you define them outside your source, and they will be available in all your files.

Currently I'm doing this:

foo.js

<pre><code>const FOO = 5;

module.exports = {
 FOO: FOO
};
</code></pre>

And using it in <code>bar.js</code>:

<pre><code>var foo = require('foo');
foo.FOO; // 5
</code></pre>

Is there a better way to do this? It feels awkward to declare the constant in the exports object.

How do you share constants in NodeJS modules?

目前我正在做这件事：foo.jsconst FOO = 5;module.exports = {    FOO: FOO};并在bar.js中使用它var foo = require('foo');foo.FOO; // 5有没有更好的方法来做这件事？在exports对象中声明常量感觉很笨拙。

问如何在NodeJS模块中共享常量？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在NodeJS模块中共享常量？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在NodeJS模块中共享常量？
EN