JavaScriptに定数はありますか？

JavaScriptで定数を使用する方法はありますか？

そうでない場合、定数として使用される変数を指定するための一般的な方法は何ですか？

ES2015以降、JavaScriptには次の概念がありconstます。

const MY_CONSTANT = "some-value";

これは、IE 8、9、10を除くほとんどすべてのブラウザーで機能します。厳密モードを有効にする必要がある場合もあります。

varALL_CAPSなどの規則を使用して、古いブラウザをサポートする必要がある場合や、レガシーコードを使用している場合に、特定の値を変更してはならないことを示すことができます。

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（）メソッドを使用する必要があります。

変数値を厳密に保護する必要がない場合は、提案されているとおりに行い、すべて大文字の規則を使用します。

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）。

参照：ES5のObject.defineProperty？

いいえ、一般的ではありません。Firefoxは実装してconstいますが、IEは実装していません。

@Johnは、長年他の言語で使用されてきたconstの一般的な命名規則を指していますが、これを使用できなかった理由はわかりません。もちろん、それは誰かがとにかく変数の値を上書きしないという意味ではありません。:)

JavaScriptでは、定数を返す関数を使用するのが私の好みです。

function MY_CONSTANT() {
   return "some-value";
}


alert(MY_CONSTANT());

Mozillas 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。そしてそれがばかげている理由：

では、IE9はconstで何をしているのでしょうか？これまでのところ、私たちの決定はそれをサポートしないことです。すべてのブラウザで利用できるようになったことがないため、まだコンセンサス機能ではありません。

...

結局のところ、Webのための最良の長期的な解決策は、それを省いて標準化プロセスが進むのを待つことです。

他のブラウザが正しく実装していないため、実装していませんか？！それをより良くすることを恐れすぎますか？標準の定義の有無にかかわらず、定数は定数です。一度設定すると、変更されることはありません。

そしてすべてのアイデアに：すべての関数（XSSなど）を上書きできます。したがって、varまたはに違いはありませんfunction(){return}。const唯一の実定数です。

更新：IE11 は 以下をサポートしますconst：

IE11はLETを含む新興のECMAScript 6標準の明確に定義され、一般に使用される機能のサポート含むconst、Map、Set、およびWeakMap、ならびに__proto__ための改良された相互運用性を。

関数を使用してもかまわない場合：

var constant = function(val) {
   return function() {
        return val;
    }
}

このアプローチは、あなたの代わりに、通常の変数の関数与えますが、それは保証^*誰もそれのセットに一度値を変えることはできませんことを。

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

私は個人的に、特にノックアウトのオブザーバブルからこのパターンに慣れた後、これをかなり楽しいと感じています。

^{_{*関数を呼び出すconstant前に誰かが関数を再定義しない限り}}

「新しい」オブジェクトAPIを使用すると、次のようなことができます。

var obj = {};
Object.defineProperty(obj, 'CONSTANT', {
  configurable: false
  enumerable: true,
  writable: false,
  value: "your constant value"
});

詳細については、Mozilla MDN でこれを参照してください。オブジェクトにアタッチされているため、これは第1レベルの変数ではありませんが、スコープがあれば、それにアタッチできます。this同様に動作するはずです。したがって、たとえばグローバルスコープでこれを行うと、ウィンドウ上で疑似定数値が宣言されます（これは本当に悪い考えです。グローバル変数を不注意に宣言しないでください）。

Object.defineProperty(this, 'constant', {
  enumerable: true, 
  writable: false, 
  value: 7, 
  configurable: false
});

> constant
=> 7
> constant = 5
=> 7

注：割り当てはコンソールで割り当てられた値を返しますが、変数の値は変更されません

可能な場合は、定数を構造体にグループ化します。

たとえば、現在のゲームプロジェクトでは、以下を使用しました。

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

古いブラウザでは、凍結メソッドにポリフィルを使用できます。

関数の呼び出しに問題がない場合は、ブラウザ間で定数を定義する方法が最適です。自己実行関数内でオブジェクトをスコープし、定数の取得関数を返すex：

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すべての定数を置く名前空間も作成しました。繰り返しますが、オーバーヘッドがあります。シーッシュ。

今、私はただKISSにvar MY_CONST = 'whatever';行きます。

私の意見（オブジェクトでのみ機能します）。

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;

私もこれに問題がありました。そして、かなり長い間、答えを探して、全員のすべての応答を見た後、私はこれに対する実行可能な解決策を思いついたと思います。

私が出くわした答えのほとんどは、定数を保持する関数を使用しているようです。MANYフォーラムのユーザーの多くが投稿しているように、クライアント側のユーザーは関数を簡単に上書きできます。定数オブジェクトには外部からはアクセスできず、内部の関数からしかアクセスできないというキース・エヴェッツの回答に興味をそそられました。

だから私はこの解決策を思いつきました：

すべてを匿名関数の中に入れて、変数、オブジェクトなどをクライアント側で変更できないようにします。また、他の関数が内部から「実際の」関数を呼び出すようにして、「実際の」関数を非表示にします。関数を使用して、クライアント側のユーザーによって関数が変更されたかどうかを確認することも考えました。関数が変更されている場合は、内部で「保護」されていて変更できない変数を使用して元に戻します。

/*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コードを無料で圧縮および難読化できるサイトです。

1. 上記のスクリプトのすべてのコードをコピーして、javascriptcompressor.comページの上部のtextareaに貼り付けます。
2. Base62エンコードチェックボックスをチェックし、変数を縮小チェックボックスをチェックします。
3. 圧縮ボタンを押します。
4. すべてを.jsファイルに貼り付けて保存し、ページの先頭に追加します。

明らかに、これは標準化されたクロスブラウザーのconstキーワードの必要性を示しています。

しかし、今のところ：

var myconst = value;

または

Object['myconst'] = value;

どちらも十分に見え、それ以外はバズーカでフライを撃つようなものです。

私は、Greasemonkeyスクリプトconstでvarはなくを使用していますが、これは、Firefoxでのみ実行されるためです...
命名規則も確かに有効です（両方を実行します）。

JavaScriptでの私の慣例は、定数をできるだけ避けて、代わりに文字列を使用することでした。定数を外部に公開したい場合、定数に関する問題が発生します。

たとえば、次の日付APIを実装できます。

date.add(5, MyModule.Date.DAY).add(12, MyModule.Date.HOUR)

しかし、単純に書く方がはるかに短くて自然です：

date.add(5, "days").add(12, "hours")

このように「日」と「時間」は定数のように機能します。「時間」が表す秒数を外側から変更できないためです。ただし、上書きするのは簡単MyModule.Date.HOURです。

この種のアプローチは、デバッグにも役立ちます。Firebugがあなたにaction === 18それが何を意味するのかを理解するのはかなり難しいと言ったら、それを見るとaction === "save"それはすぐにはっきりします。

わかりました、これは醜いですが、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でテスト済み。

それは言及する価値がある場合は、で定数を定義することができ、角度使用します$provide.constant()

angularApp.constant('YOUR_CONSTANT', 'value');

代わりに行うことができるバークの答えの改良版CONFIG.MY_CONSTCONFIG.get('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;
}());

_{*初期値が不変である場合のみ、プロパティは読み取り専用です。}

JavaScript ES6 は、すべての主要なブラウザでサポートされているconstキーワードを（再）導入しました。

を介して宣言された変数はconst、再宣言または再割り当てできません。

それ以外は、とconst同様に動作しletます。

これは、プリミティブデータ型（ブール、ヌル、未定義、数値、文字列、シンボル）に対して期待どおりに動作します。

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とにかく、すべての宣言について従うのは良い慣習なので、それだけに頼ってください。

別の選択肢は次のようなものです：

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"真のままであろう。

JavaScriptには定数がすでに存在します。次のような定数を定義します。

const name1 = value;

これは、再割り当てによって変更することはできません。

キーワード 'const'は以前に提案され、現在ES6に正式に含まれています。constキーワードを使用すると、不変の文字列として機能する値/文字列を渡すことができます。

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.jsconst上記に加えて実装します。