好吧，这很难看，但它给了我一个在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测试。

在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"时，你马上就明白了。

在可能的情况下将常量分组到结构中:

例如，在我目前的游戏项目中，我使用了以下方法:

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和IE10等早期浏览器。

在JavaScript中引入常量充其量是一种hack。

在JavaScript中创建持久且全局可访问的值的一个好方法是声明一个具有“只读”属性的对象文字，如下所示:

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

你可以将你所有的常量组合在一个单独的“my”附属对象中，在那里你可以查找你存储的值或其他任何你决定放在那里的东西。现在让我们来测试一下它是否有效:

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

正如我们所看到的，“我的”。Constant1”属性保留了其原始价值。你已经为自己设置了一些不错的“绿色”临时常数……

当然，这只能防止您意外地修改、修改、无效或清空您的属性常量值，就像在给定的例子中那样。

否则我仍然认为常数是傻瓜用的。 我仍然认为，用你巨大的自由换取一个小小的欺骗性的安全是最糟糕的交易。

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

如果你不介意使用函数:

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

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

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

我个人觉得这相当令人愉快，特别是在我已经习惯了这种模式之后。

*除非有人在你调用函数常量之前重新定义了它