Y a-t-il des constantes en JavaScript?
Est-il possible d'utiliser des constantes en JavaScript?
Sinon, quelle est la pratique habituelle pour spécifier des variables qui sont utilisées comme constantes?
Depuis ES2015 , JavaScript a une notion de const :
const MY_CONSTANT = "some-value";
Cela fonctionnera dans à peu près tous les navigateurs sauf IE 8, 9 et 1 . Certains peuvent aussi avoir besoin de 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";
Essayez-vous de protéger les variables contre les modifications? Si oui, alors vous pouvez utiliser un pattern 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 projet ECMAScript 6 , mais il ne bénéficie jusqu'ici que d'un petit support 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 tilisez const si vous souhaitez également que la référence constants soit en lecture seule.
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 });
_C'est supporté par tous les navigateurs modernes (ainsi que IE ≥ 9).
Voir aussi: Object.defineProperty in ES5?
Non, pas en général. Firefox implémente const mais je sais que IE ne le fait pas.
@ John indique une pratique de dénomination commune pour les consts utilisée depuis des années dans d'autres langues. Je ne vois donc pas pourquoi. vous ne pouvez pas utiliser ça. Bien sûr, cela ne signifie pas que quelqu'un n'écrira pas la valeur de la variable de toute façon. :)
Documents Web MDN Mozillas contiennent de bons exemples et des 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 pour laquelle c'est absurde :
Alors, que fait IE9 avec const? Jusqu'ici, notre décision a été de ne pas l'appuyer. Ce n’est pas encore une fonctionnalité de consensus car elle n’a jamais été disponible sur tous les navigateurs.
...
En fin de compte, il semble que la meilleure solution à long terme pour le Web consiste à le laisser de côté et à attendre que les processus de normalisation suivent leur cours.
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 entre var et function(){return}. const est la seule constante réelle.
Mise à jour: IE11 prend en chargeconst:
IE11 prend en charge les fonctionnalités bien définies et couramment utilisées de la nouvelle norme ECMAScript 6, notamment let,
const,Map,SetetWeakMap, ainsi que comme__proto__pour une meilleure interopérabilité.
En JavaScript, ma préférence est d'utiliser des fonctions pour renvoyer des valeurs constantes.
function MY_CONSTANT() {
return "some-value";
}
alert(MY_CONSTANT());
avec la "nouvelle" API d'objet, vous pouvez faire quelque chose comme ceci:
var obj = {};
Object.defineProperty(obj, 'CONSTANT', {
configurable: false
enumerable: true,
writable: false,
value: "your constant value"
});
jetez un oeil à this sur le MDN de Mozilla 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, vous pouvez l'attacher à cela. this devrait également fonctionner. Ainsi, par exemple, cela dans la portée globale déclarera une pseudo valeur constante sur la fenêtre (ce qui est une très mauvaise idée, vous ne devriez 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
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 d'observables.
* Sauf si quelqu'un a redéfini la fonction constant avant de l'appeler
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, 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 le nouveau standard ES6 qui a la déclaration 'const'.
Ci-dessus fonctionne dans les navigateurs précédents tels que IE8, IE9 et IE10.
Oubliez IE et utilisez le mot clé const.
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
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.
Un nom propre comme
var iw_constant={
name:'sudhanshu',
age:'23'
//all varibale come like this
}
ainsi, lors de son utilisation, il 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 le navigateur hérité.
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 suivante, il est préférable de définir une constante entre 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 la valeur, utilisez iw_constant('name') ou iw_constant('age')
** 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 sera remplacé, votre constante restera entière).
Pendant un certain temps, j'ai spécifié des "constantes" (qui n'étaient toujours pas 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);
}
Dans le passé, j'ai également créé un espace de noms CONST dans lequel je mettrais toutes mes constantes. Encore une fois, avec les frais généraux. Sheesh.
Maintenant, je viens de faire var MY_CONST = 'whatever'; à KISS .
Mon avis (ne fonctionne qu'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
Essayer! Mais comprenez - ceci est un objet, mais pas une simple variable.
Essayez aussi juste:
const a = 9;
Cela montre clairement la nécessité d'un mot-clé const standard pour tous les 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.
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 à partir des fonctions de l'intérieur.
Alors je suis venu avec cette solution:
Placez tout dans une fonction anonyme afin 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 pour qu'il soit très difficile à lire, à vous comprendre, y compris à vous, le programmeur. Il existe un site sur lequel vous pouvez aller: 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.
En JavaScript, ma pratique a été d'éviter autant que possible les constantes et d'utiliser plutôt des chaînes. Des problèmes de 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, les "jours" et les "heures" agissent vraiment comme des constantes, car vous ne pouvez pas changer de l'extérieur le nombre de secondes que "heures" représente. Mais il est facile d'écraser MyModule.Date.HOUR.
Ce type d’approche facilitera également le débogage. Si Firebug vous dit que action === 18, il est assez difficile de comprendre ce que cela signifie, mais lorsque vous voyez action === "save", alors tout est clair.
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 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.
J'utilise const au lieu de var dans mes scripts Greasemonkey, mais c'est parce qu'ils ne fonctionneront que sous Firefox ...
La convention des noms peut aussi être la voie à suivre (je fais les deux!).
Si cela vaut la peine d'être mentionné, vous pouvez définir des constantes dans angular en utilisant $provide.constant()
angularApp.constant('YOUR_CONSTANT', 'value');
OK, 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 renvoie 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);
A quoi est-ce bon? Pas grand chose, puisque ce n'est pas multi-navigateur. Au mieux, peut-être un peu de tranquillité d'esprit qu'au moins certains = les 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.
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 transmettre une valeur/chaîne qui agira comme une chaîne immuable.
en Javascript existe déjà constantes . Vous définissez une constante comme ceci:
const name1 = value;
Cela ne peut pas changer par réaffectation.
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 puisque nous essayons d'utiliser un opérateur d'affectation avec un getter, donc constantMap.MY_CONSTANT === "myconstant" resterait vrai.
Introduire des constantes dans JavaScript est au mieux un hack.
Un moyen intéressant de créer des valeurs persistantes et globalement accessibles en JavaScript serait de déclarer un objet littéral avec des propriétés "en lecture seule" comme celles-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 objet accessoire "mon", dans lequel vous pourrez rechercher vos valeurs stockées ou tout ce que vous auriez décidé de placer. Voyons maintenant si cela fonctionne:
my.constant1; >> "constant 1"
my.constant1 = "new constant 1";
my.constant1; >> "constant 1"
Comme on peut le constater, la propriété "my.constant1" a conservé sa valeur d'origine. Vous vous êtes créé des constantes temporaires "vertes" de Nice ...
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.
le mot clé const est disponible en langage javascript, mais il ne prend pas en charge le navigateur IE. Reste tous les navigateurs pris en charge.
Checkout https://www.npmjs.com/package/constjs , qui fournit trois fonctions pour créer enum, string const et bitmap. Le résultat renvoyé est soit gelé ou scellé vous ne pouvez donc pas modifier/supprimer les propriétés après leur création, vous ne pouvez pas non plus ajouter de nouvelles propriétés au résultat renvoyé.
créer Enum:
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
Créer une chaîne constante:
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';
Créer un bitmap:
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
Pour plus d'informations s'il vous plaît checkout
Disclaim: Je suis l'auteur de cet outil.
Déclarez un résultat nommé en lecture seule.
Les variables déclarées via const ne peuvent être ni déclarées ni réaffectées.
Les constantes peuvent être déclarées en majuscules ou en minuscules, mais une convention courante consiste à utiliser des lettres toutes en majuscules.
// 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