Gibt es Konstanten in JavaScript?

Gibt es eine Möglichkeit, Konstanten in JavaScript zu verwenden ?

Wenn nicht, wie wird üblicherweise Variablen angegeben, die als Konstanten verwendet werden?

Seit ES2015 hat JavaScript eine Vorstellung von const:

const MY_CONSTANT = "some-value";

Dies funktioniert in nahezu allen Browsern außer IE 8, 9 und 10 . Für einige muss möglicherweise auch der strikte Modus aktiviert sein.

Sie können varKonventionen wie ALL_CAPS verwenden, um zu zeigen, dass bestimmte Werte nicht geändert werden sollten, wenn Sie ältere Browser unterstützen müssen oder mit Legacy-Code arbeiten:

var MY_CONSTANT = "some-value";

Versuchen Sie, die Variablen vor Änderungen zu schützen? Wenn ja, können Sie ein Modulmuster verwenden:

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

Mit diesem Ansatz können die Werte nicht geändert werden. Sie müssen jedoch die Methode get () für CONFIG :( verwenden.

Wenn Sie den Variablenwert nicht streng schützen müssen, gehen Sie einfach wie vorgeschlagen vor und verwenden Sie eine Konvention von ALL CAPS.

Das constSchlüsselwort befindet sich im Entwurf von ECMAScript 6, wird jedoch bisher nur von wenigen Browsern unterstützt: http://kangax.github.io/compat-table/es6/ . Die Syntax lautet:

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

Siehe Object.freeze . Sie können verwenden,const wenn Sie die constantsReferenz auch schreibgeschützt machen möchten .

IE unterstützt Konstanten, z. B.:

<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 führt ein Object.defineProperty:

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

Es wird in jedem modernen Browser (sowie IE ≥ 9) unterstützt.

Siehe auch: Object.defineProperty in ES5?

Nein, im Allgemeinen nicht. Firefox implementiert, constaber ich weiß, dass IE dies nicht tut.

@John weist auf eine gängige Benennungspraxis für Konstanten hin, die seit Jahren in anderen Sprachen verwendet wird. Ich sehe keinen Grund, warum Sie das nicht verwenden konnten. Das bedeutet natürlich nicht, dass jemand den Wert der Variablen sowieso nicht überschreibt. :) :)

In JavaScript bevorzuge ich die Verwendung von Funktionen, um konstante Werte zurückzugeben.

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


alert(MY_CONSTANT());

Mozillas MDN-Webdokumente enthalten gute Beispiele und Erklärungen zu const. Auszug:

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

Es ist jedoch traurig, dass IE9 / 10 immer noch nicht unterstützt const. Und der Grund, warum es absurd ist :

Also, was macht IE9 mit const? Bisher haben wir beschlossen, dies nicht zu unterstützen. Es ist noch keine Konsensfunktion, da es noch nie in allen Browsern verfügbar war.

...

Am Ende scheint es die beste langfristige Lösung für das Web zu sein, es wegzulassen und darauf zu warten, dass Standardisierungsprozesse ihren Lauf nehmen.

Sie implementieren es nicht, weil andere Browser es nicht richtig implementiert haben?! Zu ängstlich, es besser zu machen? Standarddefinitionen oder nicht, eine Konstante ist eine Konstante: einmal gesetzt, nie geändert.

Und zu allen Ideen: Jede Funktion kann überschrieben werden (XSS etc.). Es gibt also keinen Unterschied in varoder function(){return}. constist die einzige wirkliche Konstante.

Update: IE11 unterstützt const :

IE11 bietet Unterstützung für die gut definiert und häufig verwendete Funktionen des neuen ECMAScript 6 Standard einschließlich let, const, Map, Set, und WeakMapsowie __proto__für eine verbesserte Interoperabilität.

Wenn es Ihnen nichts ausmacht, Funktionen zu verwenden:

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

Dieser Ansatz bietet Ihnen Funktionen anstelle von regulären Variablen, garantiert jedoch ^*, dass niemand den Wert ändern kann, sobald er festgelegt ist.

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

Ich persönlich finde das ziemlich angenehm, besonders nachdem ich mich an dieses Muster von Knockout-Observablen gewöhnt habe.

^{_{* Es sei denn, jemand hat die Funktion neu definiert, constantbevor Sie sie aufgerufen haben}}

Mit der "neuen" Objekt-API können Sie Folgendes tun:

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

werfen Sie einen Blick auf diese auf dem Mozilla MDN für weitere Einzelheiten. Es ist keine Variable der ersten Ebene, da sie an ein Objekt angehängt ist. Wenn Sie jedoch einen Bereich haben, können Sie ihn an diesen anhängen. thissollte auch funktionieren. Wenn Sie dies beispielsweise im globalen Bereich tun, wird im Fenster ein Pseudokonstantenwert deklariert (was eine wirklich schlechte Idee ist, sollten Sie globale Variablen nicht nachlässig deklarieren).

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

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

Hinweis: Durch die Zuweisung erhalten Sie den zugewiesenen Wert in der Konsole zurück, der Wert der Variablen ändert sich jedoch nicht

Gruppieren Sie Konstanten nach Möglichkeit in Strukturen:

Beispiel, in meinem aktuellen Spielprojekt, habe ich unten verwendet:

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

Zuordnung:

var wildType = CONST_WILD_TYPES.REGULAR;

Vergleich:

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

In jüngerer Zeit verwende ich zum Vergleich:

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

IE11 ist mit dem neuen ES6-Standard ausgestattet, der über eine 'const'-Deklaration verfügt.
Oben funktioniert in früheren Browsern wie IE8, IE9 und IE10.

Sie können Ihr Skript problemlos mit einem Mechanismus für Konstanten ausstatten, der festgelegt, aber nicht geändert werden kann. Ein Versuch, sie zu ändern, führt zu einem Fehler.

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

Vergiss den IE und benutze das constSchlüsselwort.

Es gibt jedoch keine genaue browserübergreifende vordefinierte Methode. Sie können dies erreichen, indem Sie den Umfang der Variablen steuern, wie in anderen Antworten gezeigt.

Aber ich werde vorschlagen, Namensraum zu verwenden, um von anderen Variablen zu unterscheiden. Dadurch wird die Wahrscheinlichkeit einer Kollision mit anderen Variablen auf ein Minimum reduziert.

Richtiger Namespace wie

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

also während der Verwendung wird es sein iw_constant.nameoderiw_constant.age

Sie können das Hinzufügen eines neuen Schlüssels oder das Ändern eines Schlüssels in iw_constant mithilfe der Object.freeze-Methode auch blockieren. Es wird jedoch nicht von älteren Browsern unterstützt.

Ex:

Object.freeze(iw_constant);

Für ältere Browser können Sie die Polyfill- Methode zum Einfrieren verwenden.

Wenn Sie mit dem Aufrufen der Funktion einverstanden sind, ist das Folgende am besten browserübergreifend, um Konstanten zu definieren. Scoping Ihres Objekts innerhalb einer selbstausführenden Funktion und Rückgabe einer get-Funktion für Ihre Konstanten, z.

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

       };

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

// um den Wert zu erhalten, benutze iw_constant('name')oderiw_constant('age')

** In beiden Beispielen müssen Sie beim Namensabstand sehr vorsichtig sein, damit Ihr Objekt oder Ihre Funktion nicht durch eine andere Bibliothek ersetzt wird. (Wenn das Objekt oder die Funktion selbst ersetzt wird, wird Ihre gesamte Konstante gelöscht.)

Für eine Weile habe ich "Konstanten" (die eigentlich noch keine Konstanten waren) in Objektliteralen angegeben, die an with()Anweisungen übergeben wurden. Ich fand es so klug. Hier ist ein Beispiel:

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

In der Vergangenheit habe ich auch einen CONSTNamespace erstellt, in den ich alle meine Konstanten eingefügt habe. Wieder mit dem Overhead. Meine Güte.

Nun, ich weiß nur var MY_CONST = 'whatever';zu KISS .

Meine Meinung (funktioniert nur mit Objekten).

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

Versuchen! Aber verstehe - das ist ein Objekt, aber keine einfache Variable.

Versuchen Sie auch einfach:

const a = 9;

Ich hatte auch ein Problem damit. Und nachdem ich eine ganze Weile nach der Antwort gesucht und alle Antworten von allen betrachtet habe, denke ich, dass ich eine tragfähige Lösung dafür gefunden habe.

Es scheint, dass die meisten Antworten, auf die ich gestoßen bin, Funktionen zum Halten der Konstanten verwenden. Wie viele Benutzer der VIELEN Foren berichten, können die Funktionen von Benutzern auf der Clientseite leicht überschrieben werden. Ich war fasziniert von Keith Evetts Antwort, dass auf das Konstantenobjekt nicht von außen zugegriffen werden kann, sondern nur von den Funktionen auf der Innenseite.

Also habe ich mir diese Lösung ausgedacht:

Fügen Sie alles in eine anonyme Funktion ein, damit die Variablen, Objekte usw. vom Client nicht geändert werden können. Verstecken Sie auch die "echten" Funktionen, indem andere Funktionen die "echten" Funktionen von innen aufrufen. Ich dachte auch daran, Funktionen zu verwenden, um zu überprüfen, ob eine Funktion von einem Benutzer auf der Clientseite geändert wurde. Wenn die Funktionen geändert wurden, ändern Sie sie mithilfe von Variablen, die innen 'geschützt' sind und nicht geändert werden können.

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

Es scheint auch, dass Sicherheit wirklich ein Problem ist und es keine Möglichkeit gibt, Ihre Programmierung auf der Clientseite zu "verbergen". Eine gute Idee für mich ist es, Ihren Code so zu komprimieren, dass es für jeden, einschließlich Sie, den Programmierer, wirklich schwierig ist, ihn zu lesen und zu verstehen. Es gibt eine Website, die Sie besuchen können: http://javascriptcompressor.com/ . (Dies ist nicht meine Website, keine Sorge, ich mache keine Werbung.) Auf dieser Website können Sie Javascript-Code kostenlos komprimieren und verschleiern.

1. Kopieren Sie den gesamten Code im obigen Skript und fügen Sie ihn in den oberen Textbereich auf der Seite javascriptcompressor.com ein.
2. Aktivieren Sie das Kontrollkästchen Base62-Codierung und das Kontrollkästchen Variablen verkleinern.
3. Drücken Sie die Komprimiertaste.
4. Fügen Sie alles ein, speichern Sie es in einer .js-Datei und fügen Sie es Ihrer Seite im Kopf Ihrer Seite hinzu.

Dies zeigt deutlich die Notwendigkeit eines standardisierten browserübergreifenden const-Schlüsselworts.

Aber für den Moment:

var myconst = value;

oder

Object['myconst'] = value;

Beides scheint ausreichend zu sein und alles andere ist wie das Schießen einer Fliege mit einer Panzerfaust.

Ich verwende conststatt varin meinen Greasemonkey-Skripten, aber es liegt daran, dass sie nur unter Firefox ausgeführt werden ... Die
Namenskonvention kann in der Tat auch der richtige Weg sein (ich mache beides!).

In JavaScript bestand meine Praxis darin, Konstanten so weit wie möglich zu vermeiden und stattdessen Zeichenfolgen zu verwenden. Probleme mit Konstanten treten auf, wenn Sie Ihre Konstanten der Außenwelt aussetzen möchten:

Zum Beispiel könnte man die folgende Datums-API implementieren:

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

Aber es ist viel kürzer und natürlicher, einfach zu schreiben:

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

Auf diese Weise verhalten sich "Tage" und "Stunden" wirklich wie Konstanten, da Sie von außen nicht ändern können, wie viele Sekunden "Stunden" darstellen. Aber es ist leicht zu überschreiben MyModule.Date.HOUR.

Diese Art von Ansatz hilft auch beim Debuggen. Wenn Firebug Ihnen sagt, dass action === 18es ziemlich schwer ist herauszufinden, was es bedeutet, aber wenn Sie es sehen, action === "save"ist es sofort klar.

Okay, das ist hässlich, aber es gibt mir eine Konstante in Firefox und Chromium, eine inkonstante Konstante (WTF?) In Safari und Opera und eine Variable in IE.

Natürlich ist eval () böse, aber ohne es gibt IE einen Fehler aus, der die Ausführung von Skripten verhindert.

Safari und Opera unterstützen das Schlüsselwort const, Sie können jedoch den Wert der Konstante ändern .

In diesem Beispiel schreibt serverseitiger Code JavaScript auf die Seite und ersetzt {0} durch einen Wert.

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

Wofür ist das gut? Nicht viel, da es nicht browserübergreifend ist. Bestenfalls vielleicht ein wenig Ruhe, zumindest einige Browser nicht zulassen, dass Lesezeichen oder Skripte von Drittanbietern den Wert ändern.

Getestet mit Firefox 2, 3, 3.6, 4, Iron 8, Chrome 10, 12, Opera 11, Safari 5, IE 6, 9.

Wenn es erwähnenswert ist, können Sie Konstanten im Winkel mit definieren$provide.constant()

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

Eine verbesserte Version von Burkes Antwort , mit der Sie CONFIG.MY_CONSTstatt CONFIG.get('MY_CONST').

Es erfordert IE9 + oder einen echten Webbrowser.

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

_{* Die Eigenschaften sind nur dann schreibgeschützt, wenn die Anfangswerte unveränderlich sind.}

JavaScript ES6 hat das constSchlüsselwort (neu) eingeführt, das in allen gängigen Browsern unterstützt wird .

Über deklarierte Variablen constkönnen nicht erneut deklariert oder neu zugewiesen werden.

Abgesehen davon constverhält sich ähnlich wie let.

Es verhält sich wie erwartet für primitive Datentypen (Boolean, Null, Undefined, Number, String, Symbol):

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

Achtung: Beachten Sie die Fallstricke bei Objekten:

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

Wenn Sie wirklich ein unveränderliches und absolut konstantes Objekt benötigen: Verwenden Sie es einfach const ALL_CAPS, um Ihre Absicht klar zu machen. Es ist constsowieso eine gute Konvention, alle Erklärungen einzuhalten, also verlassen Sie sich einfach darauf.

Eine andere Alternative ist so etwas wie:

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

Dann einfach: var foo = constantMap.MY_CONSTANT

Wenn Sie dazu constantMap.MY_CONSTANT = "bar"wären, hätte dies keine Auswirkung, da wir versuchen, einen Zuweisungsoperator mit einem Getter zu verwenden, und constantMap.MY_CONSTANT === "myconstant"würde daher wahr bleiben.

In Javascript gibt es bereits Konstanten . Sie definieren eine Konstante wie folgt:

const name1 = value;

Dies kann sich nicht durch Neuzuweisung ändern.

Das Schlüsselwort 'const' wurde früher vorgeschlagen und jetzt offiziell in ES6 aufgenommen. Mit dem Schlüsselwort const können Sie einen Wert / eine Zeichenfolge übergeben, die als unveränderliche Zeichenfolge fungiert.

Das Einführen von Konstanten in JavaScript ist bestenfalls ein Hack.

Eine gute Möglichkeit, dauerhafte und global zugängliche Werte in JavaScript zu erstellen, besteht darin, ein Objektliteral mit einigen schreibgeschützten Eigenschaften wie diesen zu deklarieren:

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

Sie haben alle Ihre Konstanten in einem einzigen "my" -Zubehörobjekt zusammengefasst, in dem Sie nach Ihren gespeicherten Werten oder anderen Elementen suchen können, die Sie möglicherweise dort abgelegt haben. Testen wir nun, ob es funktioniert:

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

Wie wir sehen können, hat die Eigenschaft "my.constant1" ihren ursprünglichen Wert beibehalten. Sie haben sich einige schöne 'grüne' temporäre Konstanten gemacht ...

Dies schützt Sie jedoch natürlich nur davor, Ihren Wert für die Eigenschaftskonstante versehentlich mit einem direkten Zugriff wie im angegebenen Beispiel zu ändern, zu ändern, aufzuheben oder zu leeren.

Ansonsten denke ich immer noch, dass Konstanten für Dummies sind. Und ich denke immer noch, dass der Austausch Ihrer großen Freiheit gegen eine kleine Ecke trügerischer Sicherheit der schlechteste Handel ist, der möglich ist.

Rhino.jsGeräte constzusätzlich zu dem, was oben erwähnt wurde.