Y a-t-il des constantes en JavaScript?
https://stackoverflow.com/questions/130396
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Existe-t-il un moyen d'utiliser des constantes en JavaScript?
Si non, quelle est la pratique habituelle pour spécifier des variables utilisées comme constantes?
La solution
Depuis que ES2015 , JavaScript a la notion de const :
const MY_CONSTANT = "some-value";
Cela fonctionnera dans à peu près tous les navigateurs, à l'exception des navigateurs IE 8, 9 et 10 . Certains peuvent également avoir besoin du mode strict activé.
Vous pouvez utiliser var avec des conventions telles que ALL_CAPS pour indiquer que certaines valeurs ne doivent pas être modifiées si vous devez prendre en charge des navigateurs plus anciens ou si vous utilisez du code hérité:
var MY_CONSTANT = "some-value";
Autres conseils
Essayez-vous de protéger les variables contre les modifications? Si tel est le cas, 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
En utilisant 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, procédez comme indiqué et utilisez la convention ALL CAPS.
Le mot clé const se trouve dans le brouillon ECMAScript 6. , mais il n’a jusqu’à présent que peu d’assistance en matière de navigateur: http: // kangax. github.io/compat-table/es6/ . La syntaxe est la suivante:
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 Object.freeze . . Vous pouvez utiliser const si vous souhaitez créer la référence constantes . en lecture seule également.
IE prend en charge 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 });
Il est pris en charge par tous les navigateurs modernes (ainsi que par IE & # 8805; 9).
Voir aussi: Object.defineProperty dans ES5?
Non, pas en général. Firefox implémente const mais je sais que IE ne le fait pas.
@John pointe vers une pratique courante de dénomination des consts utilisée depuis des années. dans d'autres langues, je ne vois aucune raison pour que vous ne puissiez pas utiliser cela. Bien sûr, cela ne signifie pas que quelqu'un n'écrira pas la valeur de la variable de toute façon. :)
Documents Web avec MDN de Mozillas contiennent bons exemples et explications sur 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 regrettable que IE9 / 10 ne supporte toujours pas const . Et la raison en est absurde :
Alors, que fait IE9 avec const? Alors Jusqu'ici, notre décision a été de ne pas soutiens le. Ce n’est pas encore un consensus fonctionnalité comme il n'a jamais été disponible sur tous les navigateurs.
...
En fin de compte, il semble que le meilleur solution à long terme pour le web est de laisser tomber et attendre processus de normalisation pour exécuter leur bien sûr.
Ils ne l'implémentent pas parce que d'autres navigateurs ne l'ont pas implémenté correctement?! Trop peur de le rendre meilleur? Définitions standards ou non, une constante est une constante: définie une fois, jamais modifiée.
Et à toutes les idées: chaque fonction peut être écrasée (XSS, etc.). Donc, il n'y a pas de différence dans var ou function () {return} . const est la seule constante réelle.
Mise à jour:
IE11 prend en charge const :
IE11 prend en charge les fonctionnalités bien définies et couramment utilisées de la nouvelle norme ECMAScript 6, notamment let,
const,Map, < code> Définissez etWeakMap, ainsi que__ proto __pour améliorer l'interopérabilité.
En JavaScript, je préfère utiliser des fonctions pour renvoyer 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 normales, mais elle garantit * que personne ne peut modifier la valeur une fois 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 d'observables knock-out.
* Sauf si quelqu'un a redéfini la fonction constante avant de l'appeler
avec le " nouveau " Objet api vous pouvez faire quelque chose comme ça:
var obj = {};
Object.defineProperty(obj, 'CONSTANT', {
configurable: false
enumerable: true,
writable: false,
value: "your constant value"
});
consultez cette sur le MDN de Mozilla pour plus d'informations. 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, vous pouvez l'attacher à cela. this devrait également fonctionner.
Ainsi, par exemple, cela dans la portée globale déclarera une pseudo-valeur constante dans la fenêtre (ce qui est une très mauvaise idée, vous ne devez pas déclarer les vars globaux sans précaution).
Object.defineProperty(this, 'constant', {
enumerable: true,
writable: false,
value: 7,
configurable: false
});
> constant
=> 7
> constant = 5
=> 7
note: assignation vous rendra la valeur assignée dans la console, mais la valeur de la variable ne changera pas
Regroupez les constantes en structures si 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, à des fins de comparaison:
switch (wildType) {
case CONST_WILD_TYPES.REGULAR:
// do something here
break;
case CONST_WILD_TYPES.EXPANDING:
// do something here
break;
}
IE11 utilise le nouveau standard ES6 doté de la déclaration 'const'.
Ci-dessus fonctionne dans les navigateurs précédents tels que IE8, IE9 & amp; IE10.
Vous pouvez facilement équiper votre script d’un mécanisme pour les constantes qui peuvent être définies mais non modifiées. Une tentative de les modifier va générer 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’existe pas de méthode prédéfinie pour tous les navigateurs, vous pouvez y parvenir en contrôlant la portée des variables comme indiqué dans les autres réponses.
Mais je suggérerai d'utiliser un espace de noms pour distinguer d'autres variables. cela réduira au minimum les risques de collision dus à d'autres variables.
Espacement de noms correct, comme
var iw_constant={
name:'sudhanshu',
age:'23'
//all varibale come like this
}
donc lors de l’utilisation, ce sera iw_constant.name ou iw_constant.age
Vous pouvez également bloquer l’ajout de toute nouvelle clé ou la modification de toute clé dans iw_constant à l’aide de la méthode Object.freeze. Cependant, il n'est pas pris en charge sur les navigateurs existants.
ex:
Object.freeze(iw_constant);
Pour les navigateurs plus anciens, vous pouvez utiliser polyfill pour la méthode freeze.
Si vous êtes d'accord avec l'appel de la fonction, le suivi est le meilleur moyen de définir une constante pour tous les navigateurs. Scoping de votre objet dans une fonction auto-exécutante et retourne 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 l'utilisation de la valeur
iw_constant ('nom') ou iw_constant ('âge')
** Dans les deux exemples, vous devez faire très attention à l'espacement des noms afin que votre objet ou votre fonction ne soit pas remplacé par une autre bibliothèque (si l'objet ou la fonction elle-même est remplacé, votre constante sera supprimée) >
Pendant un moment, j'ai spécifié les "constantes". (qui n'étaient toujours pas réellement des constantes) dans les littéraux d'objet transmis aux instructions with () . Je pensais que c'était si intelligent. Voici un exemple:
with ({
MY_CONST : 'some really important value'
}) {
alert(MY_CONST);
}
Par le passé, j'ai également créé un espace-noms CONST dans lequel je mettrais toutes mes constantes. Encore une fois, avec les frais généraux. Sheesh.
Maintenant, je fais juste var MY_CONST = 'quel que soit'; pour KISS .
Mon avis (fonctionne uniquement 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 comprenez, c’est un objet, mais pas une simple variable.
Essayez aussi juste:
const a = 9;
Moi aussi j'ai eu un problème avec ça. Et après un bon bout de temps à chercher la réponse et à regarder toutes les réponses de tout le monde, je pense avoir trouvé une solution viable à cela.
Il semble que la plupart des réponses que j'ai rencontrées utilisent des fonctions pour contenir les constantes. Comme de nombreux utilisateurs des forums MANY parlent de beaucoup, les fonctions peuvent être facilement écrites par les utilisateurs du côté client. La réponse de Keith Evetts m'a intriguée, à savoir que l'objet constantes n'est pas accessible de l'extérieur, mais uniquement des fonctions à l'intérieur.
J'ai donc proposé cette solution:
Placez tout dans une fonction anonyme de manière à ce que les variables, objets, etc. ne puissent pas être modifiés par le côté client. Cachez également les fonctions "réelles" en faisant en sorte que d'autres fonctions appellent les fonctions "réelles" de l'intérieur. J'ai aussi pensé à utiliser des fonctions pour vérifier si une fonction a été modifiée par un utilisateur côté client. Si les fonctions ont été modifiées, modifiez-les à nouveau à l'aide de variables "protégées" à l'intérieur qui ne peuvent pas être modifié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 également que la sécurité soit vraiment un problème et qu’il n’ya aucun moyen de vous "cacher" en programmant du côté client. Une bonne idée pour moi est de compresser votre code de sorte qu'il soit très difficile pour tout le monde, y compris vous, le programmeur, de le lire et de le comprendre. Vous pouvez accéder à un site sur: http://javascriptcompressor.com/ . (Ce n’est pas mon site, ne vous inquiétez pas, je ne fais pas de publicité.) C’est un site qui vous permettra de compresser et d’obscurcir le code Javascript gratuitement.
- Copiez tout le code dans le script ci-dessus et collez-le dans la zone de texte supérieure de la page javascriptcompressor.com.
- Cochez la case Encodage Base62, cochez la case Réduire les variables.
- Appuyez sur le bouton Compresser.
- Collez et enregistrez le tout dans un fichier .js et ajoutez-le à votre page dans l'en-tête de votre page.
Cela montre clairement la nécessité d'un mot clé const standard pour plusieurs navigateurs.
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 fonctionneront que sur Firefox ...
La convention de nom peut aussi être la voie à suivre (je fais les deux!).
En JavaScript, ma pratique consistait à éviter autant que possible les constantes et à utiliser des chaînes. Des problèmes avec les constantes apparaissent lorsque vous souhaitez exposer vos constantes au monde extérieur:
Par exemple, on pourrait implémenter l'API Date suivante:
date.add(5, MyModule.Date.DAY).add(12, MyModule.Date.HOUR)
Mais il est beaucoup plus court et naturel de simplement écrire:
date.add(5, "days").add(12, "hours")
De cette façon, " jours " et " heures " agissez vraiment comme des constantes, car vous ne pouvez pas modifier de l'extérieur le nombre de secondes "heures". représente. Mais il est facile d'écraser MyModule.Date.HOUR .
Ce type d’approche facilitera également le débogage. Si Firebug vous indique action === 18 , il est assez difficile de comprendre ce que cela signifie, mais lorsque vous voyez action === "enregistrer", alors tout est immédiatement clair.
D'accord, c'est moche, mais cela me donne une constante dans Firefox et Chromium, une constante non constante (WTF?) dans Safari et Opera, et une variable dans IE.
Bien sûr, eval () est diabolique, mais sans cela, IE génère une erreur empêchant l'exécution des scripts.
Safari et Opera prennent en charge le mot clé const, mais vous pouvez modifier la valeur de const .
Dans cet exemple, le code côté serveur écrit JavaScript sur 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 sert-il? Pas beaucoup, car ce n'est pas multi-navigateur. Dans le meilleur des cas, vous aurez peut-être la certitude qu'au moins certains navigateurs ne laisseront pas les bookmarklets ou les scripts tiers modifier la valeur.
Testé avec Firefox 2, 3, 3.6, 4, Iron 8, Chrome 10, 12, Opera 11, Safari 5, IE 6, 9.
Si cela vaut la peine d'être mentionné, vous pouvez définir des constantes dans angular à l'aide de $ fournir.constant ()
angularApp.constant('YOUR_CONSTANT', 'value');
Une version améliorée de la réponse de Burke qui vous permet d'effectuer CONFIG.MY_CONST au lieu de < code> CONFIG.get ('MY_CONST') .
Il nécessite 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, uniquement si les valeurs initiales sont immuables.
JavaScript ES6 (re-) a introduit le const mot clé pris en charge par tous les principaux navigateurs .
Les variables déclarées via
constne peuvent pas être déclarées à nouveau ni réaffectées.
En dehors de cela, const se comporte de manière similaire à laissez .
Il se comporte comme prévu pour les types de données primitifs (Boolean, Null, Undefined, Number, String, Symbol):
const x = 1;
x = 2;
console.log(x); // 1 ...as expected, re-assigning fails
Attention: soyez attentif aux pièges liés aux 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 simplement const ALL_CAPS pour préciser votre intention. C’est quand même une bonne convention à suivre pour toutes les déclarations const , alors fiez-vous simplement à cela.
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);
}
Alors simplement: var foo = constantMap.MY_CONSTANT
Si vous deviez constantMap.MY_CONSTANT = "bar" , cela n'aurait aucun effet car nous essayons d'utiliser un opérateur d'affectation avec un getter, d'où 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 pas changer par réaffectation.
Le mot clé 'const' a été proposé précédemment et il est maintenant officiellement inclus dans ES6. En utilisant le mot clé const, vous pouvez passer une valeur / chaîne qui agira comme une chaîne immuable.
L'introduction de constantes dans JavaScript est au mieux un hack.
Un bon moyen de créer des valeurs persistantes et globalement accessibles en JavaScript serait de déclarer un objet littéral avec des "quot-read" " propriétés comme celle-ci:
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 regroupées dans un seul " mon " accessoire accessoire où vous pouvez rechercher vos valeurs stockées ou toute autre chose que vous pourriez avoir décidé d'y mettre d'ailleurs. Voyons maintenant si cela fonctionne:
my.constant1; >> "constant 1"
my.constant1 = "new constant 1";
my.constant1; >> "constant 1"
Comme on peut le constater, le "my.constant1" propriété a conservé sa valeur d'origine. Vous vous êtes fait de belles constantes temporaires "vertes" ...
Mais bien sûr, cela ne vous empêchera que de modifier, altérer, annuler ou vider accidentellement la valeur constante de votre propriété avec un accès direct comme dans l'exemple donné.
Sinon, je pense toujours que les constantes sont pour les nuls. Et je pense toujours qu'échanger votre grande liberté contre un petit coin de sécurité trompeuse est le pire commerce possible.
Rhino.js implémente const en plus de ce qui a été mentionné ci-dessus.
