Há constantes no JavaScript?

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

Usando esta abordagem, os valores não podem ser modificados. Mas, você tem que usar o método get () no CONFIG: (.

Se você não precisa proteger estritamente o valor das variáveis, então faça o que foi sugerido e use uma convenção de todas as CAPS.

A const palavra-chave está em o ECMAScript 6 projecto mas até agora só goza de um punhado de suporte ao navegador: http://kangax.github.io/compat-table/es6/. A sintaxe é:

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

Ver Objecto.quieto. Pode utilizar const Se você quiser fazer a referência apenas para leitura também.

IE suporta constantes, como por exemplo:

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

O ECMAScript 5 introduz Object.defineProperty:

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

É suportado em cada navegador moderno (assim como IE ≥ 9).

Ver também: objecto.na ES5?

@John. aponta para uma prática comum de nomenclatura para consts que tem sido usado por anos em outras línguas, eu não vejo nenhuma razão pela qual você não poderia usar isso. Claro que isso não significa que alguém não vai escrever sobre o valor da variável de qualquer maneira. :)

Os documentos web Mozillas MDN contêm bons exemplos e explicações sobre const. Excerto:

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

Mas é triste que o IE9/10 ainda não suporte const. E a razão pela qual é absurdo:

Então, o que é que a IE9 está a fazer com a const? Entao até agora, a nossa decisão foi não apoia-o. Ainda não é um consenso. recurso como nunca esteve disponível em todos os navegadores.

...

No final, parece o melhor. longo a solução de termo para a web é deixa - o de fora e espera processos de normalização para executar os seus curso.

E a todas as ideias: Todas as funções podem ser sobrepostas (XSS etc.). Portanto, não há diferença em var ou function(){return}. const é o único real constante.

Actualizar: Suporte IE11 const:

A IE11 inclui o suporte para as características bem definidas e comumente usadas da emergente norma ECMAScript 6, incluindo o let, const, Map, Set, e WeakMap, bem como __proto__ para melhorar a interoperabilidade.

Em JavaScript, a minha preferência é usar funções para devolver valores constantes.

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


alert(MY_CONSTANT());

Se não se importar de usar funções:

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

Esta abordagem dá-lhe funções em vez de variáveis regulares, mas garante^* que ninguém pode alterar o valor assim que estiver definido.

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

^{_{*a menos que alguém tenha redefinido a função constant antes de lhe chamares isso.}}

Com a api "novo" objecto pode fazer algo assim:

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

Dê uma olhada em Este no Mozilla MDN para mais detalhes. Não é uma variável de primeiro nível, pois está ligada a um objeto, mas se você tem um escopo, qualquer coisa, você pode anexá-lo a isso. this deve funcionar também. Então, por exemplo, fazendo isso no escopo global irá declarar um valor pseudo constante na janela (o que é uma péssima idéia, você não deve declarar vars globais descuidadamente)

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

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

Nota: a atribuição devolver-lhe-á o valor atribuído na consola, mas o valor da variável não mudará

Constantes de grupo em estruturas, sempre que possível:

Exemplo, no meu projecto de jogo actual, usei a seguir:

var CONST_WILD_TYPES = {
    REGULAR: 'REGULAR',
    EXPANDING: 'EXPANDING',
    STICKY: 'STICKY',
    SHIFTING: 'SHIFTING'
};

Atribuição:

var wildType = CONST_WILD_TYPES.REGULAR;

Comparação:

if (wildType === CONST_WILD_TYPES.REGULAR) {
    // do something here
}

Mais recentemente, estou a usar, para comparação:

switch (wildType) {
    case CONST_WILD_TYPES.REGULAR:
        // do something here
        break;
    case CONST_WILD_TYPES.EXPANDING:
        // do something here
        break;
}

Você pode facilmente equipar o seu script com um mecanismo para constantes que podem ser definidas, mas não alteradas. Uma tentativa de alterá-los irá gerar um erro.

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

Esqueça IE e use a palavra-chave const.

No entanto, não existe uma forma predefinida exacta de fazer isso, você pode alcançá-lo controlando o âmbito das variáveis como mostrado em outras respostas.

Mas vou sugerir usar o espaço de nome para distinguir de outras variáveis. Isso reduzirá a chance de colisão ao mínimo a partir de outras variáveis.

Um espaço de nomes adequado como

var iw_constant={
     name:'sudhanshu',
     age:'23'
     //all varibale come like this
}

Por isso, durante a sua utilização, será iw_constant.name ou iw_constant.age

Você também pode bloquear a adição de qualquer nova chave ou alterar qualquer chave dentro iw_ constant a usar o objecto.método de congelamento. No entanto, não é suportado no navegador legado.

Ex:

Object.freeze(iw_constant);

Para o navegador mais antigo, pode utilizar polifill para o método de congelamento.

Se não se importar com a função de chamada a seguir é a melhor forma de cross browser definir constante. Scoping your object within a self executing function and returning a get function for your constants ex:

var iw_constant= (function(){
       var allConstant={
             name:'sudhanshu',
             age:'23'
             //all varibale come like this

       };

       return function(key){
          allConstant[key];
       }
    };

/ / para obter o valor de Utilização iw_constant('name') ou iw_constant('age')

* * em ambos os exemplos você tem que ter muito cuidado no espaçamento de nomes para que seu objeto ou função não deve ser substituído através de outra biblioteca.

Por um tempo, eu especificei "constantes" (que ainda não eram realmente constantes) em literais de objetos passados para with() declarações. Pensei que era tão inteligente. Aqui está um exemplo:

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

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

Tenta também:

const a = 9;

Coloque tudo dentro de uma função anônima para que assim, as variáveis, objetos, etc. não pode ser alterado pelo lado do cliente. Também esconder as funções 'reais', tendo outras funções chamadas de funções' reais ' a partir do interior. Eu também pensei em usar funções para verificar se uma função foi alterada por um usuário no lado do cliente. Se as funções foram alteradas, mudá-los de volta usando variáveis que são 'protegidas' no interior e não podem ser alteradas.

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

Isto mostra claramente a necessidade de uma palavra-chave cross-browser cont.

Mas por agora:

var myconst = value;

Ou

Object['myconst'] = value;

Eu uso {[[0]} em vez de var nos meus scripts Greasemonkey, mas é porque eles vão correr apenas no Firefox...
Convenção de nomes também pode ser o caminho a seguir (eu faço ambos!).

Em JavaScript a minha prática tem sido evitar constantes tanto quanto posso e usar strings em vez disso. Problemas com constantes aparecem quando você quer expor suas constantes para o mundo exterior:

Por exemplo, pode-se implementar a seguinte API de data:

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

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

Claro que eval() é mau, mas sem ele, ou seja, lança um erro, impedindo scripts de correr.

O Safari e o Opera suportam a palavra-chave const, maspode alterar o valor do const .

Neste exemplo, o código do lado do servidor está a escrever JavaScript na página, substituindo {0} por um valor.

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

Testado com Firefox 2, 3, 3.6, 4, Iron 8, cromo 10, 12, Opera 11, Safari 5, IE 6, 9.

Se vale a pena mencionar, você pode definir constantes em angular usando $provide.constant()

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

Uma versão melhorada da resposta de Burke que te permite fazerCONFIG.MY_CONST em vez de CONFIG.get('MY_CONST').

Requer IE9+ ou um verdadeiro navegador 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;
}());

_{* as propriedades são apenas de leitura, apenas se os valores iniciais são imutáveis.}

O JavaScript ES6 (re)introduziu o const palavra-chave que é suportada em todos os navegadores principais .

As variáveis declaradas via const não podem ser re-declaradas ou re-atribuídas.

Além disso, const comporta-se de forma semelhante a let.

Comporta-se como esperado para tipos de dados primitivos (booleanos, nulos, indefinidos, números, cadeias, Símbolos):

const x = 1;
x = 2;
console.log(x); // 1 ...as expected, re-assigning fails

Atenção: objectos:

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

Se você realmente precisa de um objeto imutável e absolutamente constante: basta usar const ALL_CAPS para deixar a sua intenção clara. É uma boa convenção a seguir para todas as declarações {[[2]} de qualquer forma, por isso apenas confie nela.

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

Então simplesmente: var foo = constantMap.MY_CONSTANT

Se você fosse {[[2]} isso não teria efeito porque estamos tentando usar um operador de atribuição com um getter, portanto constantMap.MY_CONSTANT === "myconstant" permaneceria verdadeiro.

No Javascript já existe constantes . Você define uma constante como esta:

const name1 = value;

Uma boa maneira de tornar valores persistentes e globalmente acessíveis em JavaScript seria declarar um objecto literal com algumas propriedades "apenas para leitura"como esta:

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

Você terá todas as suas constantes agrupadas em um único objeto acessório" meu " onde você pode procurar os seus valores armazenados ou qualquer outra coisa que você possa ter decidido colocar lá para esse assunto. Agora vamos testar se funciona.

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

Rhino.js implementos const além do que foi mencionado acima.