Y a-t-il des constantes dans JavaScript?

essayez-vous de protéger les variables contre les modifications? Si c'est le cas, alors vous pouvez utiliser un modèle de module:

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

selon cette approche, les valeurs ne peuvent pas être modifiées. Mais, vous devez utiliser la méthode get () sur CONFIG :(.

si vous n'avez pas besoin de protéger strictement la valeur des variables, alors faites comme suggéré et utilisez une convention de tous les CAPS.

le const mot-clé est dans L'ECMAScript 6 projet mais il bénéficie jusqu'à présent seulement d'une légère prise en charge du navigateur: http://kangax.github.io/compat-table/es6 / . La syntaxe est:

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

Voir Objet.congeler . Vous pouvez utiliser const si vous voulez faire la référence constants en lecture seule aussi bien.

IE supporte les constantes, en quelque sorte, par exemple:

<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 introduit Object.defineProperty :

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

c'est pris en charge dans chaque navigateur moderne (ainsi que IE ≥ 9).

Voir Aussi: objet.defineProperty in ES5?

non, pas en général. Firefox implémente const mais je sais que IE n'est pas.

@John indique une pratique courante de dénomination des consts qui a été utilisée pendant des années dans d'autres langues, Je ne vois aucune raison pour laquelle vous ne pouviez pas utiliser cela. Bien sûr, cela ne signifie pas que quelqu'un n'écrira pas sur la valeur de la variable de toute façon. :)

Mozillas MDN Web Docs contiennent de bons exemples et des explications à propos de const . Extrait:

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

mais il est triste que IE9/10 ne supporte toujours pas const . Et la raison c'est absurde :

alors, que fait IE9 avec const? Si à présent, notre décision a été de ne pas en charge. Il n'est pas encore un consensus fonction qu'il n'a jamais été disponible sur tous les navigateurs.

...

à la fin, il semble comme le meilleur solution à long terme pour le web est de les laisser et attendre le processus de normalisation pour exécuter leurs cours.

ils ne l'implémentent pas parce que d'autres navigateurs ne l'ont pas implémenté correctement?! Trop peur de faire mieux? Définition des normes ou non, une constante est une constante: fixée une fois, jamais modifiée.

et à toutes les idées: chaque fonction peut être écrasée (XSS etc.). Il n'y a donc pas de différence entre var et function(){return} . const est la seule constante réelle.

mise à jour: IE11 prend en charge const :

IE11 inclut le support pour le bien définie et est communément utilisé les caractéristiques de l'émergence de l'ECMAScript 6 standard, y compris de laisser, const , Map , Set , et WeakMap , ainsi que __proto__ pour une meilleure interopérabilité.

En JavaScript, ma préférence est d'utiliser des fonctions pour retourner des valeurs constantes.

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


alert(MY_CONSTANT());

si cela ne vous dérange pas d'utiliser des fonctions:

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

cette approche vous donne des fonctions au lieu de variables régulières, mais elle garantit ^* que personne ne peut modifier la valeur une fois qu'elle est définie.

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

personnellement je trouve cela plutôt agréable, surtout après m'être habitué à ce modèle de Knockout observables.

^{_{*a moins que quelqu'un n'ait redéfini la fonction constant avant que vous l'appeliez}}

avec la" nouvelle "api objet vous pouvez faire quelque chose comme ceci:

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

regardez ce sur le Mozilla MDN pour plus de détails. Ce n'est pas une variable de premier niveau, car elle est attachée à un objet, mais si vous avez une portée, n'importe quoi, vous pouvez l'attacher à cela. this devrait aussi fonctionner. Ainsi, par exemple, dans la portée globale va déclarer une pseudo valeur constante sur la fenêtre (qui est une très mauvaise idée, vous ne devrait pas déclarer global vars négligemment)

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

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

note: assignment vous donnera la Valeur assignée dans la console, mais la valeur de la variable ne changera pas

regrouper les constantes dans les structures lorsque c'est possible:

exemple, dans mon projet de jeu actuel, j'ai utilisé ci-dessous:

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

affectation:

var wildType = CONST_WILD_TYPES.REGULAR;

Comparaison:

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

plus récemment, j'utilise, pour la comparaison:

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

IE11 est avec de nouveaux ES6 norme de 'const' déclaration.

Ci-dessus fonctionne dans plus tôt les navigateurs comme IE8, IE9 et IE10.

vous pouvez facilement équiper votre script d'un mécanisme pour les constantes qui peuvent être réglées mais pas modifiées. Une tentative de modification entraînera une erreur.

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

oubliez IE et utilisez le mot-clé const .

pourtant, il n'y a pas de navigateur exact prédéfini façon de le faire , vous pouvez l'atteindre en contrôlant la portée des variables comme indiqué sur d'autres réponses.

mais je suggérerai d'utiliser l'espace du nom pour distinguer d'autres variables. cela réduira au minimum le risque de collision avec d'autres variables.

nom propre comme

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

ainsi, en l'utilisant sera iw_constant.name ou iw_constant.age

vous pouvez également bloquer l'ajout d'une nouvelle clé ou la modification d'une clé à l'intérieur de iw_constant en utilisant L'objet.gel de la méthode. Cependant, son pas pris en charge sur les anciens navigateur.

ex:

Object.freeze(iw_constant);

pour les navigateurs plus anciens, vous pouvez utiliser polyfill pour la méthode de congélation.

si vous êtes d'accord avec la fonction d'appel, suivre est la meilleure façon de définir constante à travers le navigateur. Délimiter votre objet à l'intérieur une fonction auto-exécutante et retourner une fonction get pour vos constantes ex:

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

       };

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

//pour obtenir la valeur d'utilisation iw_constant('name') ou iw_constant('age')

** dans les deux exemples, vous devez être très prudent sur l'espacement des noms pour que votre objet ou fonction ne soit pas remplacé par une autre bibliothèque.(Si l'objet ou la fonction elle-même sera remplacé votre constante entière ira)

pendant un certain temps, j'ai spécifié des" constantes "(qui n'étaient toujours pas des constantes) dans les littérales des objets passées aux déclarations with() . J'ai pensé qu'il était si intelligent. Voici un exemple:

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

dans le passé, j'ai aussi créé un espace de noms CONST où je mettrais toutes mes constantes. Encore une fois, avec les frais généraux. Sheesh.

maintenant, je fais juste var MY_CONST = 'whatever'; à KISS .

mon avis (fonctionne seulement avec des objets).

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

essayez! Mais comprendre - c'est objet, mais pas simple variable.

Essayez aussi juste:

const a = 9;

moi aussi, j'ai eu un problème avec cela. Et après un certain temps à chercher la réponse et à regarder toutes les réponses de tout le monde, je pense que j'ai trouvé une solution viable à cela.

il semble que la plupart des réponses que j'ai rencontrées utilisent des fonctions pour maintenir les constantes. Comme beaucoup d'utilisateurs des nombreux forums postent sur, les fonctions peuvent être facilement sur écrites par les utilisateurs du côté du client. J'ai été intrigué par la réponse de Keith Evetts l'objet constantes ne peut pas être accédé par l'extérieur, mais seulement à partir des fonctions de l'intérieur.

alors j'ai trouvé cette solution:

mettez tout dans une fonction anonyme de cette façon, les variables, les objets, etc. ne peut pas être changé du côté du client. Aussi masquer le "vrai" fonctions en ayant d'autres fonctions d'appel le "vrai" fonctions de l'intérieur. J'ai également pensé à utiliser des fonctions pour vérifier si une fonction a été changée par un utilisateur sur le côté client. Si les fonctions ont été modifiées, changez-les en utilisant des variables qui sont "protégées" à l'intérieur et ne peuvent pas être changées.

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

Il semble aussi que la sécurité est vraiment un problème et il n'y a pas à "cacher" une programmation côté client. Une bonne idée pour moi est de compresser votre code afin qu'il soit vraiment difficile pour quiconque, y compris vous, le programmeur, de le lire et de le comprendre. Il y a un site où vous pouvez aller: http://javascriptcompressor.com / . (Ce n'est pas mon site, ne vous inquiétez pas je ne suis pas de la publicité.) Ceci est un site qui vous permettra de compresser et d'obscurcir le code Javascript gratuitement.

1. copiez tout le code dans le script ci-dessus et collez-le dans le haut du texte sur le javascriptcompressor.com page.
2. cochez la case base62 encode, cochez la case Shrink Variables.
3. appuyez sur le bouton compresse.
4. coller et enregistrer tout dans un .fichier js et l'ajouter à votre page dans l'en-tête de votre page.

cela montre clairement la nécessité d'un mot-clé standardisé cross-browser const.

mais pour l'instant:

var myconst = value;

ou

Object['myconst'] = value;

les deux semblent suffisants et tout le reste est comme tirer une mouche avec un bazooka.

j'utilise const au lieu de var dans mes scripts Greasemonkey, mais c'est parce qu'ils ne fonctionnent que sur Firefox...

La Convention des noms peut aussi être la voie à suivre (je fais les deux!).

dans JavaScript ma pratique a été d'éviter les constantes autant que je peux et d'utiliser des chaînes à la place. Les problèmes avec les constantes apparaissent quand vous voulez exposer vos constantes au monde extérieur:

par exemple, on pourrait implémenter L'API de Date suivante:

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

mais il est beaucoup plus court et plus naturel d'écrire simplement:

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

de Cette façon, "jours" et "heures" vraiment agir comme des constantes, parce que vous ne pouvez pas changement de l'extérieur combien de secondes "heures". Mais il est facile de remplacer MyModule.Date.HOUR .

ce type d'approche aidera également au débogage. Si Firebug vous dit action === 18 il est assez difficile de comprendre ce que cela signifie, Mais quand vous voyez action === "save" alors il est immédiatement clair.

OK, c'est moche, mais ça me donne une constante En Firefox et chrome, une constante inconstante (WTF?) dans Safari et Opera, et une variable dans IE.

bien sûr eval() est diabolique, mais sans lui, c'est à dire qu'il envoie une erreur, empêchant les scripts de s'exécuter.

Safari et Opera soutiennent le mot-clé de const, mais vous pouvez changer la valeur de const .

dans cet exemple, le code côté serveur écrit JavaScript à la page, en remplaçant {0} par une valeur.

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

à quoi ça sert? Pas grand-chose, vu que ce n'est pas cross-browser. Au mieux, peut-être un peu de tranquillité d'esprit qu'au moins certains navigateurs ne laisseront pas bookmarklets ou script tiers modifier la valeur.

Testé avec Firefox 2, 3, 3.6, 4, Fer 8, Chrome 10, 12, Opera 11, Safari 5, IE 6, 9.

si cela vaut la peine de mentionner, vous pouvez définir les constantes dans angulaire en utilisant $provide.constant()

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

une version améliorée de réponse de Burke qui vous permet de faire CONFIG.MY_CONST au lieu de CONFIG.get('MY_CONST') .

Il faut IE9+ ou un vrai navigateur 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;
}());

_{* les propriétés sont en lecture seule, seulement si les valeurs initiales sont immuables.}

JavaScript ES6 (re-)introduit le const mot-clé qui est pris en charge dans tous les principaux navigateurs .

Les Variables

déclarées via const ne peuvent pas être déclarées ou réattribuées.

en dehors de cela, const se comporte let .

il se comporte comme prévu pour les types de données primitifs (Booléen, Null, Non Défini, Nombre, Chaîne, Symbole):

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

Attention: attention aux pièges concernant les objets:

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

si vous avez vraiment besoin d'un objet immuable et absolument constant, utilisez const ALL_CAPS pour préciser votre intention. C'est une bonne convention à suivre pour toutes les déclarations const de toute façon, donc il suffit de compter sur elle.

une autre alternative est quelque chose comme:

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

puis simplement: var foo = constantMap.MY_CONSTANT

si vous étiez à constantMap.MY_CONSTANT = "bar" cela n'aurait aucun effet puisque nous essayons d'utiliser un opérateur d'affectation avec un getter, donc constantMap.MY_CONSTANT === "myconstant" resterait vrai.

en Javascript existe déjà constantes . Vous définissez une constante comme ceci:

const name1 = value;

cela ne peut changer par réaffectation.

le mot-clé "const" a été proposé plus tôt et maintenant il a été officiellement inclus dans ES6. En utilisant le mot-clé const, vous pouvez passer une valeur/chaîne qui agira comme une chaîne immuable.

introduire des constantes dans JavaScript est au mieux un piratage.

une bonne façon de rendre les valeurs persistantes et globalement accessibles en JavaScript serait de déclarer un objet littéral avec quelques propriétés "en lecture seule" comme ceci:

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

vous aurez toutes vos constantes groupées dans un seul" mon " objet accessoire où vous pouvez chercher vos valeurs stockées ou n'importe quoi d'autre que vous avez peut-être décidé de mettre là pour cette matière. Maintenant, nous allons tester si cela fonctionne:

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

comme on peut le voir, le " my.constant1 " propriété a préservé sa valeur originale. Tu t'es créé de jolies constantes "vertes" temporaires...

mais bien sûr, cela ne vous empêchera pas de modifier, d'altérer, d'annuler ou de vider accidentellement votre valeur constante de propriété avec un accès direct comme dans l'exemple donné.

sinon je pense toujours que les constantes sont pour les nuls. Et j'ai encore pensez que l'échange de votre grande liberté contre un petit coin de sécurité trompeuse est le pire commerce possible.

Rhino.js met en œuvre const en plus de ce qui a été mentionné ci-dessus.