JavaScript中是否有常量？

Question

有没有办法在JavaScript中使用常量？

如果没有，指定用作常量的变量的常用做法是什么？

Answer 1

自ES2015起，JavaScript的概念为const：

const MY_CONSTANT = "some-value";

这将在pretty much all browsers except IE 8, 9 and 10中有效。有些可能还需要启用strict mode。

您可以将var与ALL_CAPS等惯例一起使用，以表明如果您需要支持旧浏览器或使用旧版代码，则不应修改某些值：

var MY_CONSTANT = "some-value";

Answer 2

您是否尝试保护变量不被修改？如果是这样，那么您可以使用模块模式：

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约定。

Answer 3

const关键字位于the ECMAScript 6 draft，但到目前为止只享有一小部分浏览器支持：http://kangax.github.io/compat-table/es6/。语法是：

const CONSTANT_NAME = 0;

Answer 4

"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。如果您想将constants引用设为只读，也可以use const。

Answer 5

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>

Answer 6

ECMAScript 5确实引入了Object.defineProperty：

Object.defineProperty (window,'CONSTANT',{ value : 5, writable: false });

它是supported in every modern browser（以及IE≥9）。

另请参阅：Object.defineProperty in ES5?

Answer 7

不，不是一般的。 Firefox实现const，但我知道IE没有。

---

@John指向已在其他语言中使用多年的竞争的常见命名实践，我认为没有理由不能使用它。当然，这并不意味着有人不会写出变量的值。 ：）

Answer 8

Mozillas MDN Web Docs包含有关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做什么？所以   到目前为止，我们的决定一直没有   支持它。这尚未达成共识   从未有过的功能   在所有浏览器上。

     

...

     

最后，它似乎是最好的   网络的长期解决方案是   把它留下来等待   标准化过程来运行他们的   当然。

他们没有实现它，因为其他浏览器没有正确实现它？！太害怕让它变得更好？标准定义与否，常数是常数：设置一次，永不改变。

所有想法：每个功能都可以被覆盖（XSS等）。因此var或function(){return}没有区别。 const是唯一真正的常数。

更新： IE11 supports const：

  

IE11包括对新兴ECMAScript 6标准明确定义和常用功能的支持，包括let， const ，Map，Set和WeakMap，以及__proto__，以提高互操作性。

Answer 9

在JavaScript中，我的首选是使用函数来返回常量值。

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


alert(MY_CONSTANT());

Answer 10

如果您不介意使用功能：

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

这种方法为函数提供了函数而不是常规变量，但它保证 ^* 一旦设置了值就没有人可以改变它。

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

我个人认为这很令人愉快，特别是在从淘汰观察中习惯了这种模式之后。

^{_{*除非在您调用函数{/ 1>}之前重新定义了函数}}

Answer 11

使用“new”Object 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

注意：赋值将返回控制台中指定的值，但变量的值不会改变

Answer 12

尽可能将组常量分组到结构中：

例如，在我目前的游戏项目中，我使用了以下内容：

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采用新的ES6标准，具有'const'声明 以上版本适用于IE8，IE9和IE等早期浏览器。 IE10。

Answer 13

您可以轻松地为脚本配备一个可以设置但不能更改的常量机制。尝试更改它们将产生错误。

/* 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  

Answer 14

忘记IE并使用const关键字。

Answer 15

然而，没有确切的跨浏览器预​​定义方法来实现它，您可以通过控制其他答案所示的变量范围来实现它。

但我建议使用名称空间来区分其他变量。这样可以将碰撞的几率从其他变量降到最小。

正确的命名空间，如

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

---

**在这两个示例中，您必须非常小心名称间距，以便您的对象或函数不应该通过其他库替换。（如果对象或函数本身将被替换，您的整个常量将会去）

Answer 16

有一段时间，我在传递给with()语句的对象文字中指定了“常量”（它实际上不是常量）。我觉得它太聪明了。这是一个例子：

with ({
    MY_CONST : 'some really important value'
}) {
    alert(MY_CONST);
}

在过去，我还创建了一个CONST命名空间，我将放置所有常量。再次，与开销。啧。

现在，我只是var MY_CONST = 'whatever';到KISS。

Answer 17

我的意见（仅适用于对象）。

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;

Answer 18

我也遇到过这个问题。经过一段时间寻找答案并查看每个人的所有答案后，我想我已经想出了一个可行的解决方案。

似乎我遇到的大部分答案都是使用函数来保存常量。正如许多论坛的许多用户所发布的那样，这些功能可以很容易地被客户端的用户覆盖。我对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代码的网站。

1. 复制上述脚本中的所有代码并将其粘贴到javascriptcompressor.com页面的顶部textarea中。
2. 选中Base62编码复选框，选中Shrink Variables复选框。
3. 按下“压缩”按钮。
4. 将其全部粘贴并保存在.js文件中，然后将其添加到页面顶部的页面中。

Answer 19

显然，这表明需要标准化的跨浏览器const关键字。

但是现在：

var myconst = value;

或

Object['myconst'] = value;

两者看起来都足够了，其他任何东西就像是用火箭筒射击飞行。

Answer 20

好吧，这很丑陋，但它在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);

这有什么好处？不多，因为它不是跨浏览器。充其量，也许有点安心，至少一些浏览器不会让bookmarklet或第三方脚本修改该值。

使用Firefox 2,3,3.6,4，Iron 8，Chrome 10,12，Opera 11，Safari 5，IE 6,9进行测试。

Answer 21

在JavaScript中我的做法是尽可能地避免使用常量并使用字符串代替。当您想要将常量暴露给外部世界时，会出现常量问题：

例如，可以实现以下Date 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"时，它会立即显现出来。

Answer 22

Burke's answer的改进版本，可让您CONFIG.MY_CONST代替CONFIG.get('MY_CONST')。

它需要IE9 +或真正的网络浏览器。

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

_{*仅当初始值是不可变的时，属性才是只读的。}

Answer 23

如果值得一提，您可以使用angular

在$provide.constant()中定义常量

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

Answer 24

我在Greasemonkey脚本中使用const而不是var，但这是因为它们只能在Firefox上运行...
名称约定确实也是可行的方法（我同时做到了！）。

Answer 25

JavaScript ES6（重新）引入了const keyword支持的all major browsers。

  

通过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声明都是一个很好的约定，所以只需依靠它。

Answer 26

另一种选择是：

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"，那么我们尝试将赋值运算符与getter一起使用就无效了，因此constantMap.MY_CONSTANT === "myconstant"将保持为真。

Answer 27

Javascript中的

已经存在constants。你定义一个这样的常量：

const name1 = value;

这不能通过重新分配来改变。

Answer 28

关键字＆＃39; const＆＃39;之前已提出，现已正式纳入ES6。通过使用const关键字，您可以传递将充当不可变字符串的值/字符串。

Answer 29

除了上面提到的内容之外，

Rhino.js实现了const。

Answer 30

将常量引入JavaScript充其量只是一种破解。

在JavaScript中创建持久性和全局可访问值的一种好方法是声明一个具有一些“只读”属性的对象文字：

            my={get constant1(){return "constant 1"},
                get constant2(){return "constant 2"},
                get constant3(){return "constant 3"},
                get constantN(){return "constant N"}
                }

您将所有常量分组到一个“我的”附件对象中，您可以在其中查找存储的值或您可能决定放在那里的任何其他内容。现在让我们测试它是否有效：

           my.constant1; >> "constant 1" 
           my.constant1 = "new constant 1";
           my.constant1; >> "constant 1" 

正如我们所看到的，“my.constant1”属性保留了原始值。你已经为自己制作了一些不错的“绿色”临时常量...

但是，当然这只会防止您使用直接访问意外修改，更改，取消或清空属性常量值，如给定示例中所示。

否则我仍然认为常数是针对傻瓜的。 而且我仍然认为，将你的巨大自由交换到一个欺骗性安全的小角落是最糟糕的交易。

Answer 31

const关键字在javascript语言中可用，但它不支持IE浏览器。休息所有支持的浏览器。

Answer 32

Checkout https://www.npmjs.com/package/constjs，提供三个函数来创建枚举，字符串const和位图。返回的结果是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 

创建字符串const：

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  

有关详细信息，请结帐

• https://www.npmjs.com/package/constjs
• 或https://github.com/greenlaw110/constjs

免责声明：如果是这个工具，我就是作者。

Answer 33

  

声明一个名为constatnt的只读。

     

通过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