ES2015 以降、JavaScriptには const の概念があります。
const MY_CONSTANT = "some-value";
これは IE 8、9、10以外のほとんどすべてのブラウザで動作します 。 厳密モード 有効も必要な場合があります。
ALL_CAPSのような規則でvarを使用すると、古いブラウザをサポートする必要がある場合や従来のコードを使用している場合は、特定の値を変更しないでください。
var MY_CONSTANT = "some-value";
あなたは変更から変数を保護しようとしていますか？もしそうなら、あなたはモジュールパターンを使用することができます：
var CONFIG = (function() {
var private = {
'MY_CONST': '1',
'ANOTHER_CONST': '2'
};
return {
get: function(name) { return private[name]; }
};
})();
alert('MY_CONST: ' + CONFIG.get('MY_CONST')); // 1
CONFIG.MY_CONST = '2';
alert('MY_CONST: ' + CONFIG.get('MY_CONST')); // 1
CONFIG.private.MY_CONST = '2'; // error
alert('MY_CONST: ' + CONFIG.get('MY_CONST')); // 1
この方法では、値を変更することはできません。ただし、CONFIG :(ではget（）メソッドを使用する必要があります。
変数の値を厳密に保護する必要がない場合は、推奨されているようにしてALL CAPSの規則を使用してください。
constキーワードは ECMAScript 6ドラフト にありますが、これまでのところブラウザのサポートはほんの少ししかありません： http://kangax.github.io/compat-table/es6/ 。構文は次のとおりです。
const CONSTANT_NAME = 0;
"use strict";
var constants = Object.freeze({
"π": 3.141592653589793 ,
"e": 2.718281828459045 ,
"i": Math.sqrt(-1)
});
constants.π; // -> 3.141592653589793
constants.π = 3; // -> TypeError: Cannot assign to read only property 'π' …
constants.π; // -> 3.141592653589793
delete constants.π; // -> TypeError: Unable to delete property.
constants.π; // -> 3.141592653589793
Object.freeze を参照してください。 const参照を読み取り専用にしたい場合は、 constants を使用できます。
IEは定数をサポートしています。
<script language="VBScript">
Const IE_CONST = True
</script>
<script type="text/javascript">
if (typeof TEST_CONST == 'undefined') {
const IE_CONST = false;
}
alert(IE_CONST);
</script>
ECMAScript 5では Object.defineProperty が導入されています。
Object.defineProperty (window,'CONSTANT',{ value : 5, writable: false });
最近のすべてのブラウザでサポートされています （IE≥9と同様に）。
いいえ、一般的ではありません。 Firefoxはconstを実装していますが、IEはそうではないことを私は知っています。
@John は、他の言語で長年使用されてきたconstの一般的な命名規則を示していますが、それが使用できない理由はわかりません。もちろん、それは誰かがとにかく変数の値を上書きしないという意味ではありません。 :)
MozillaのMDN Webドキュメント はconstについての良い例と説明を含みます。抜粋：
// define MY_FAV as a constant and give it the value 7
const MY_FAV = 7;
// this will throw an error - Uncaught TypeError: Assignment to constant variable.
MY_FAV = 20;
しかし、IE9/10がまだconstをサポートしていないのは残念です。そしてその理由は absurd ：
それで、IE9はconstで何をしているのでしょうか？これまでのところ、私たちの決定はそれを支持しないことでした。それはすべてのブラウザで利用可能ではありませんでしたようにそれはまだ合意機能ではありません。
...
結局のところ、それはWebのための最善の長期的な解決策はそれを除外し、標準化プロセスが彼らのコースを実行するのを待つことであるように思えます。
他のブラウザでは正しく実装されていないため、実装されていません。それを良くすることを恐れすぎますか？規格の定義にかかわらず、定数は定数です。一度設定すると、変更されることはありません。
そしてすべてのアイデアに：すべての関数は上書きされることがあります（XSSなど）。そのためvarやfunction(){return}に違いはありません。 constは唯一の実定数です。
更新：IE11 サポートconst：
IE11には、let、
const、Map、Set、WeakMap、相互運用性の向上のための__proto__など、明確に定義され一般的に使用されるECMAScript 6規格の機能がサポートされています。
JavaScriptでは、関数を使って定数値を返すのが私の好みです。
function MY_CONSTANT() {
return "some-value";
}
alert(MY_CONSTANT());
「新しい」オブジェクトAPIを使えば、次のようなことができます。
var obj = {};
Object.defineProperty(obj, 'CONSTANT', {
configurable: false
enumerable: true,
writable: false,
value: "your constant value"
});
詳しくはMozilla MDNの this をご覧ください。最初のレベルの変数ではありません。それはオブジェクトに結び付けられているからです。しかし、スコープを持っているなら何でも、あなたはそれをそれに結び付けることができます。 thisも動作するはずです。したがって、たとえば、グローバルスコープでこれを実行すると、ウィンドウ上で疑似定数値が宣言されます（これは本当に悪い考えです。グローバル変数を不用意に宣言しないでください）。
Object.defineProperty(this, 'constant', {
enumerable: true,
writable: false,
value: 7,
configurable: false
});
> constant
=> 7
> constant = 5
=> 7
注意：代入はコンソールに代入された値を返しますが、変数の値は変わりません
関数を使っても構わないのなら：
var constant = function(val) {
return function() {
return val;
}
}
この方法では、通常の変数ではなく関数を使用できますが、保証されています。* いったん設定されると、だれも値を変更することはできません。
a = constant(10);
a(); // 10
b = constant(20);
b(); // 20
私は個人的には、このパターンがノックアウト観測量から慣れてきた後で、これはかなり楽しいと思います。
*あなたがそれを呼び出す前に誰かが関数constantを再定義しない限り
可能であれば、定数を構造体にグループ化します。
例として、私の現在のゲームプロジェクトでは、私は以下を使いました：
var CONST_WILD_TYPES = {
REGULAR: 'REGULAR',
EXPANDING: 'EXPANDING',
STICKY: 'STICKY',
SHIFTING: 'SHIFTING'
};
割り当て：
var wildType = CONST_WILD_TYPES.REGULAR;
比較：
if (wildType === CONST_WILD_TYPES.REGULAR) {
// do something here
}
ごく最近、私は比較のために使っています：
switch (wildType) {
case CONST_WILD_TYPES.REGULAR:
// do something here
break;
case CONST_WILD_TYPES.EXPANDING:
// do something here
break;
}
IE11は、「const」宣言を持つ新しいES6標準を採用しています。
上記はIE8、IE9、IE10のような初期のブラウザで動作します。
スクリプトには、設定はできるが変更はできない定数のメカニズムを簡単に装備することができます。それらを変更しようとするとエラーが発生します。
/* author Keith Evetts 2009 License: LGPL
anonymous function sets up:
global function SETCONST (String name, mixed value)
global function CONST (String name)
constants once set may not be altered - console error is generated
they are retrieved as CONST(name)
the object holding the constants is private and cannot be accessed from the outer script directly, only through the setter and getter provided
*/
(function(){
var constants = {};
self.SETCONST = function(name,value) {
if (typeof name !== 'string') { throw new Error('constant name is not a string'); }
if (!value) { throw new Error(' no value supplied for constant ' + name); }
else if ((name in constants) ) { throw new Error('constant ' + name + ' is already defined'); }
else {
constants[name] = value;
return true;
}
};
self.CONST = function(name) {
if (typeof name !== 'string') { throw new Error('constant name is not a string'); }
if ( name in constants ) { return constants[name]; }
else { throw new Error('constant ' + name + ' has not been defined'); }
};
}())
// ------------- demo ----------------------------
SETCONST( 'VAT', 0.175 );
alert( CONST('VAT') );
//try to alter the value of VAT
try{
SETCONST( 'VAT', 0.22 );
} catch ( exc ) {
alert (exc.message);
}
//check old value of VAT remains
alert( CONST('VAT') );
// try to get at constants object directly
constants['DODO'] = "dead bird"; // error
IEを忘れてconstキーワードを使用してください。
しかし、それを実行するための正確なクロスブラウザの事前定義された方法はありません。他の答えで示されているように変数の範囲を制御することによってそれを達成することができます。
しかし、他の変数と区別するために名前空間を使うことをお勧めします。これにより、他の変数による衝突の可能性が最小限に抑えられます。
適切な名前空間のような
var iw_constant={
name:'sudhanshu',
age:'23'
//all varibale come like this
}
そのため、使用中はiw_constant.nameまたはiw_constant.ageになります。
Object.freezeメソッドを使用して、iw_constant内で新しいキーを追加したり、キーを変更したりすることをブロックすることもできます。しかし、それはレガシーブラウザではサポートされていません。
例：
Object.freeze(iw_constant);
古いブラウザでは polyfill を使用することができます。
関数の呼び出しに問題がなければ、ブラウザに依存しない方法で定数を定義するのが最善です。オブジェクトを自己実行関数内にスコープし、定数に対してget関数を返す例：
var iw_constant= (function(){
var allConstant={
name:'sudhanshu',
age:'23'
//all varibale come like this
};
return function(key){
allConstant[key];
}
};
//値を取得するにはiw_constant('name')またはiw_constant('age')を使用
**どちらの例でも、オブジェクトまたは関数が他のライブラリを介して置き換えられないように、名前の間隔には細心の注意を払う必要があります（オブジェクトまたは関数自体が置き換えられる場合は、定数全体が使用されます）。
しばらくの間、私はwith()ステートメントに渡されるオブジェクトリテラルに "定数"（まだ実際には定数ではない）を指定しました。私はそれがとても賢いと思った。これが例です：
with ({
MY_CONST : 'some really important value'
}) {
alert(MY_CONST);
}
過去に、私はすべての定数を置くCONST名前空間も作成しました。オーバーヘッドもあります。シーシー.
さて、私はvar MY_CONST = 'whatever';を _ kiss _ にするだけです。
私の意見は（オブジェクトだけで動作します）。
var constants = (function(){
var a = 9;
//GLOBAL CONSTANT (through "return")
window.__defineGetter__("GCONST", function(){
return a;
});
//LOCAL CONSTANT
return {
get CONST(){
return a;
}
}
})();
constants.CONST = 8; //9
alert(constants.CONST); //9
やってみて！しかし、理解してください - これは目的ですが、単純な変数ではありません。
また試してみてください。
const a = 9;
明らかにこれは標準化されたクロスブラウザのconstキーワードの必要性を示しています。
しかし、今のところ：
var myconst = value;
または
Object['myconst'] = value;
どちらも十分なようですが、他にはバズーカでハエを撃つようなものです。
私もこれに問題がありました。そして、しばらくして答えを探し、すべての回答を調べた後、私はこれに対する実行可能な解決策を思いついたと思います。
私が遭遇した答えのほとんどは、定数を保持するために関数を使用しているようです。多くのフォーラムのユーザが投稿しているように、クライアント側のユーザがその機能を簡単に上書きすることができます。私はKeith Evettsの答えに興味をそそられました。定数オブジェクトには外部からはアクセスできず、内部の関数からしかアクセスできません。
だから私はこの解決策を思い付きました：
変数、オブジェクトなどがクライアント側で変更されないように、すべてを無名関数の中に入れます。他の関数に内側から「実際の」関数を呼び出させることで、「実際の」関数を隠します。また、クライアントサイドのユーザーによって機能が変更されたかどうかを確認するために機能を使用することも考えました。機能が変更されている場合は、内側が「保護」されていて変更できない変数を使用して元に戻してください。
/*Tested in: IE 9.0.8; Firefox 14.0.1; Chrome 20.0.1180.60 m; Not Tested in Safari*/
(function(){
/*The two functions _define and _access are from Keith Evetts 2009 License: LGPL (SETCONST and CONST).
They're the same just as he did them, the only things I changed are the variable names and the text
of the error messages.
*/
//object literal to hold the constants
var j = {};
/*Global function _define(String h, mixed m). I named it define to mimic the way PHP 'defines' constants.
The argument 'h' is the name of the const and has to be a string, 'm' is the value of the const and has
to exist. If there is already a property with the same name in the object holder, then we throw an error.
If not, we add the property and set the value to it. This is a 'hidden' function and the user doesn't
see any of your coding call this function. You call the _makeDef() in your code and that function calls
this function. - You can change the error messages to whatever you want them to say.
*/
self._define = function(h,m) {
if (typeof h !== 'string') { throw new Error('I don\'t know what to do.'); }
if (!m) { throw new Error('I don\'t know what to do.'); }
else if ((h in j) ) { throw new Error('We have a problem!'); }
else {
j[h] = m;
return true;
}
};
/*Global function _makeDef(String t, mixed y). I named it makeDef because we 'make the define' with this
function. The argument 't' is the name of the const and doesn't need to be all caps because I set it
to upper case within the function, 'y' is the value of the value of the const and has to exist. I
make different variables to make it harder for a user to figure out whats going on. We then call the
_define function with the two new variables. You call this function in your code to set the constant.
You can change the error message to whatever you want it to say.
*/
self._makeDef = function(t, y) {
if(!y) { throw new Error('I don\'t know what to do.'); return false; }
q = t.toUpperCase();
w = y;
_define(q, w);
};
/*Global function _getDef(String s). I named it getDef because we 'get the define' with this function. The
argument 's' is the name of the const and doesn't need to be all capse because I set it to upper case
within the function. I make a different variable to make it harder for a user to figure out whats going
on. The function returns the _access function call. I pass the new variable and the original string
along to the _access function. I do this because if a user is trying to get the value of something, if
there is an error the argument doesn't get displayed with upper case in the error message. You call this
function in your code to get the constant.
*/
self._getDef = function(s) {
z = s.toUpperCase();
return _access(z, s);
};
/*Global function _access(String g, String f). I named it access because we 'access' the constant through
this function. The argument 'g' is the name of the const and its all upper case, 'f' is also the name
of the const, but its the original string that was passed to the _getDef() function. If there is an
error, the original string, 'f', is displayed. This makes it harder for a user to figure out how the
constants are being stored. If there is a property with the same name in the object holder, we return
the constant value. If not, we check if the 'f' variable exists, if not, set it to the value of 'g' and
throw an error. This is a 'hidden' function and the user doesn't see any of your coding call this
function. You call the _getDef() function in your code and that function calls this function.
You can change the error messages to whatever you want them to say.
*/
self._access = function(g, f) {
if (typeof g !== 'string') { throw new Error('I don\'t know what to do.'); }
if ( g in j ) { return j[g]; }
else { if(!f) { f = g; } throw new Error('I don\'t know what to do. I have no idea what \''+f+'\' is.'); }
};
/*The four variables below are private and cannot be accessed from the outside script except for the
functions inside this anonymous function. These variables are strings of the four above functions and
will be used by the all-dreaded eval() function to set them back to their original if any of them should
be changed by a user trying to hack your code.
*/
var _define_func_string = "function(h,m) {"+" if (typeof h !== 'string') { throw new Error('I don\\'t know what to do.'); }"+" if (!m) { throw new Error('I don\\'t know what to do.'); }"+" else if ((h in j) ) { throw new Error('We have a problem!'); }"+" else {"+" j[h] = m;"+" return true;"+" }"+" }";
var _makeDef_func_string = "function(t, y) {"+" if(!y) { throw new Error('I don\\'t know what to do.'); return false; }"+" q = t.toUpperCase();"+" w = y;"+" _define(q, w);"+" }";
var _getDef_func_string = "function(s) {"+" z = s.toUpperCase();"+" return _access(z, s);"+" }";
var _access_func_string = "function(g, f) {"+" if (typeof g !== 'string') { throw new Error('I don\\'t know what to do.'); }"+" if ( g in j ) { return j[g]; }"+" else { if(!f) { f = g; } throw new Error('I don\\'t know what to do. I have no idea what \\''+f+'\\' is.'); }"+" }";
/*Global function _doFunctionCheck(String u). I named it doFunctionCheck because we're 'checking the functions'
The argument 'u' is the name of any of the four above function names you want to check. This function will
check if a specific line of code is inside a given function. If it is, then we do nothing, if not, then
we use the eval() function to set the function back to its original coding using the function string
variables above. This function will also throw an error depending upon the doError variable being set to true
This is a 'hidden' function and the user doesn't see any of your coding call this function. You call the
doCodeCheck() function and that function calls this function. - You can change the error messages to
whatever you want them to say.
*/
self._doFunctionCheck = function(u) {
var errMsg = 'We have a BIG problem! You\'ve changed my code.';
var doError = true;
d = u;
switch(d.toLowerCase())
{
case "_getdef":
if(_getDef.toString().indexOf("z = s.toUpperCase();") != -1) { /*do nothing*/ }
else { eval("_getDef = "+_getDef_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
case "_makedef":
if(_makeDef.toString().indexOf("q = t.toUpperCase();") != -1) { /*do nothing*/ }
else { eval("_makeDef = "+_makeDef_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
case "_define":
if(_define.toString().indexOf("else if((h in j) ) {") != -1) { /*do nothing*/ }
else { eval("_define = "+_define_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
case "_access":
if(_access.toString().indexOf("else { if(!f) { f = g; }") != -1) { /*do nothing*/ }
else { eval("_access = "+_access_func_string); if(doError === true) { throw new Error(errMsg); } }
break;
default:
if(doError === true) { throw new Error('I don\'t know what to do.'); }
}
};
/*Global function _doCodeCheck(String v). I named it doCodeCheck because we're 'doing a code check'. The argument
'v' is the name of one of the first four functions in this script that you want to check. I make a different
variable to make it harder for a user to figure out whats going on. You call this function in your code to check
if any of the functions has been changed by the user.
*/
self._doCodeCheck = function(v) {
l = v;
_doFunctionCheck(l);
};
}())
セキュリティは本当に問題であり、クライアント側からプログラミングを「隠す」方法はないようです。私にとって良い考えは、あなたを含むあなたのプログラマーを含む誰もがそれを読んで理解するのが本当に難しいようにあなたのコードを圧縮することです。あなたが行くことができるサイトがあります： http://javascriptcompressor.com/ /。 （これは私のサイトではない、私が宣伝しているのではないことを心配しないでください。）これは無料でJavascriptコードを圧縮および難読化することを可能にするサイトです。
- 上記のスクリプトのすべてのコードをコピーして、javascriptcompressor.comページの一番上のtextareaに貼り付けます。
- Base62エンコードチェックボックスをチェックし、Shrink Variablesチェックボックスをチェックします。
- 圧縮ボタンを押します。
- すべて貼り付けて.jsファイルに保存し、ページの先頭のページに追加します。
JavaScriptでは、できる限り定数を使用せずに代わりに文字列を使用することを習慣としています。定数に関する問題は、定数を外界に公開したい場合に発生します。
たとえば、次のDate APIを実装できます。
date.add(5, MyModule.Date.DAY).add(12, MyModule.Date.HOUR)
しかし、単純に書くのがはるかに短く、より自然です。
date.add(5, "days").add(12, "hours")
このように、 "days"と "hours"は実際には定数のように機能します。なぜなら、 "hours"が何秒を表すのかを外部から変更することはできないからです。しかしMyModule.Date.HOURを上書きするのは簡単です。
この種のアプローチはデバッグにも役立ちます。 Firebugからaction === 18と言われた場合、その意味を理解するのはかなり困難ですが、action === "save"が表示されたらすぐにわかります。
Burke's answer の改良版で、CONFIG.get('MY_CONST')の代わりにCONFIG.MY_CONSTを実行できます。
IE9以降または本物のWebブラウザが必要です。
var CONFIG = (function() {
var constants = {
'MY_CONST': 1,
'ANOTHER_CONST': 2
};
var result = {};
for (var n in constants)
if (constants.hasOwnProperty(n))
Object.defineProperty(result, n, { value: constants[n] });
return result;
}());
*初期値が不変の場合のみ、プロパティは読み取り専用です。
私のGreasemonkeyスクリプトではconstの代わりにvarを使用していますが、それはそれらがFirefoxでしか動作しないからです...
名前の付け方も、実際には可能性があります（私は両方ともします）。
JavaScript ES6では、 constキーワード が導入されました。これは すべての主要ブラウザでサポートされています 。
constを介して宣言された変数は、再宣言または再割り当てすることはできません。
それ以外は、constは let のように動作します。
プリミティブデータ型（Boolean、Null、Undefined、Number、String、Symbol）に対して期待どおりに動作します。
const x = 1;
x = 2;
console.log(x); // 1 ...as expected, re-assigning fails
注意： オブジェクトに関する落とし穴に注意してください。
const o = {x: 1};
o = {x: 2};
console.log(o); // {x: 1} ...as expected, re-assigning fails
o.x = 2;
console.log(o); // {x: 2} !!! const does not make objects immutable!
const a = [];
a = [1];
console.log(a); // 1 ...as expected, re-assigning fails
a.Push(1);
console.log(a); // [1] !!! const does not make objects immutable
不変で絶対的に一定のオブジェクトが本当に必要な場合は、const ALL_CAPSを使用して意図を明確にしてください。とにかくすべてのconst宣言に従うのは良い慣習ですので、それに頼ってください。
言及する価値がある場合は、 angle に $provide.constant() を使用して定数を定義できます。
angularApp.constant('YOUR_CONSTANT', 'value');
さて、これは醜いですが、FirefoxとChromiumでは定数、SafariとOperaでは定数（WTF？）、そしてIEでは変数になります。
もちろんeval（）は悪ですが、それがなければIEはエラーを投げ、スクリプトの実行を妨げます。
SafariとOperaはconstキーワードをサポートしていますが、 あなたはconstの値を変更することができます 。
この例では、サーバー側のコードがページにJavaScriptを書き込んで、{0}を値に置き換えています。
try{
// i can haz const?
eval("const FOO='{0}';");
// for reals?
var original=FOO;
try{
FOO='?NO!';
}catch(err1){
// no err from Firefox/Chrome - fails silently
alert('err1 '+err1);
}
alert('const '+FOO);
if(FOO=='?NO!'){
// changed in Sf/Op - set back to original value
FOO=original;
}
}catch(err2){
// IE fail
alert('err2 '+err2);
// set var (no var keyword - Chrome/Firefox complain about redefining const)
FOO='{0}';
alert('var '+FOO);
}
alert('FOO '+FOO);
これは何のために良いのですか？それはクロスブラウザではないのであまりありません。せいぜい、少なくとも 一部の ブラウザでは、ブックマークレットやサードパーティのスクリプトで値を変更することはできません。
Firefox 2、3、3.6、4、Iron 8、Chrome 10、12、Opera 11、Safari 5、IE 6、9でテスト済み。
キーワード「const」は以前に提案され、現在は正式にES6に含まれています。 constキーワードを使用することで、不変の文字列として機能する値/文字列を渡すことができます。
もう1つの選択肢は次のようなものです。
var constants = {
MY_CONSTANT : "myconstant",
SOMETHING_ELSE : 123
}
, constantMap = new function ConstantMap() {};
for(var c in constants) {
!function(cKey) {
Object.defineProperty(constantMap, cKey, {
enumerable : true,
get : function(name) { return constants[cKey]; }
})
}(c);
}
それでは単純に：var foo = constantMap.MY_CONSTANT
constantMap.MY_CONSTANT = "bar"を使用した場合は、代入演算子をゲッターと共に使用しようとしているので効果がありません。したがって、constantMap.MY_CONSTANT === "myconstant"はtrueのままです。
JavaScriptに定数を導入することはせいぜいハックです。
JavaScriptで永続的かつグローバルにアクセス可能な値を作成するための良い方法は、次のようないくつかの "読み取り専用"プロパティを持つオブジェクトリテラルを宣言することです。
my={get constant1(){return "constant 1"},
get constant2(){return "constant 2"},
get constant3(){return "constant 3"},
get constantN(){return "constant N"}
}
すべての定数は1つの「my」アクセサリオブジェクトにまとめられ、そこに格納されている値、またはそのことを考慮してそこに置くことにしたその他のものを探すことができます。それでうまくいくかどうかテストしましょう：
my.constant1; >> "constant 1"
my.constant1 = "new constant 1";
my.constant1; >> "constant 1"
ご覧のとおり、 "my.constant1"プロパティは元の値を保持しています。あなたは自分自身でいくつかの素敵な「緑の」一時定数を作りました...
しかしもちろんこれは、与えられた例のように直接アクセスであなたのプロパティ定数値を誤って変更、変更、無効化、または空にすることからあなたを守るだけです。
そうでなければ私はまだ定数はダミー用だと思います。そして私は、あなたの大きな自由を詐欺的なセキュリティの小さな隅に交換することは、可能な限り最悪の取引であるとまだ思います。
Rhino.jsは、上記に加えてconstを実装しています。
javascript言語で利用可能なconstキーワードが、それはIEブラウザをサポートしません。サポートされているすべてのブラウザを休ませてください。
チェックアウト https://www.npmjs.com/package/constjs 、enum、文字列const、およびビットマップを作成するための3つの関数を提供します。返された結果は frozen または sealed のいずれかです。したがって、作成後にプロパティを変更/削除することはできません。返された結果に新しいプロパティを追加することもできません。
列挙型を作成します。
var ConstJs = require('constjs');
var Colors = ConstJs.enum("blue red");
var myColor = Colors.blue;
console.log(myColor.isBlue()); // output true
console.log(myColor.is('blue')); // output true
console.log(myColor.is('BLUE')); // output true
console.log(myColor.is(0)); // output true
console.log(myColor.is(Colors.blue)); // output true
console.log(myColor.isRed()); // output false
console.log(myColor.is('red')); // output false
console.log(myColor._id); // output blue
console.log(myColor.name()); // output blue
console.log(myColor.toString()); // output blue
// See how CamelCase is used to generate the isXxx() functions
var AppMode = ConstJs.enum('SIGN_UP, LOG_IN, FORGOT_PASSWORD');
var curMode = AppMode.LOG_IN;
console.log(curMode.isLogIn()); // output true
console.log(curMode.isSignUp()); // output false
console.log(curMode.isForgotPassword()); // output false
文字列定数を作成します。
var ConstJs = require('constjs');
var Weekdays = ConstJs.const("Mon, Tue, Wed");
console.log(Weekdays); // output {Mon: 'Mon', Tue: 'Tue', Wed: 'Wed'}
var today = Weekdays.Wed;
console.log(today); // output: 'Wed';
ビットマップを作成します。
var ConstJs = require('constjs');
var ColorFlags = ConstJs.bitmap("blue red");
console.log(ColorFlags.blue); // output false
var StyleFlags = ConstJs.bitmap(true, "rustic model minimalist");
console.log(StyleFlags.rustic); // output true
var CityFlags = ConstJs.bitmap({Chengdu: true, Sydney: false});
console.log(CityFlags.Chengdu); //output true
console.log(CityFlags.Sydney); // output false
var DayFlags = ConstJs.bitmap(true, {Mon: false, Tue: true});
console.log(DayFlags.Mon); // output false. Default val wont override specified val if the type is boolean
詳細についてはチェックアウトしてください
免責事項：私はこのツールなら作者です。
読み取り専用の名前付き定数を宣言します。
Constによって宣言された変数は、再宣言または再割り当てすることはできません。
定数は大文字または小文字で宣言できますが、一般的な慣例ではすべて大文字を使用します。
// const c;
// c = 9; //intialization and declearation at same place
const c = 9;
// const c = 9;// re-declare and initialization is not possible
console.log(c);//9