Czy w JavaScript są stałe?

Czy starasz się chronić zmienne przed modyfikacją? Jeśli tak, to możesz użyć wzorca modułu:

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

Używając tego podejścia, wartości nie mogą być modyfikowane. Ale musisz użyć metody get () w config :(.

Jeśli nie musisz ściśle chronić wartości zmiennych, po prostu rób jak sugerujesz i używaj konwencji wszystkich wielkich liter.

Słowo kluczowe const znajduje się w szkicu ECMAScript 6 , ale do tej pory cieszy się tylko małym wsparciem dla przeglądarek: http://kangax.github.io/compat-table/es6 / . składnia jest następująca:

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

Zobacz Obiekt.freeze . Możesz użyć const jeśli chcesz, aby Referencja constants była tylko do odczytu.

IE obsługuje stałe, np.:

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

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

Jest to obsługiwane w każdej nowoczesnej przeglądarce (jak również IE ≥ 9).

Zobacz też: obiekt.defineProperty w ES5?

Nie, Nie ogólnie. Firefox implementuje const ale wiem, że IE nie.

@John wskazuje na powszechną praktykę nazewnictwa konst, która była używana od lat w innych językach, nie widzę powodu, dla którego nie można by tego użyć. Oczywiście nie oznacza to, że ktoś i tak nie napisze nad wartością zmiennej. :)

Mozillas MDN Web Docs zawiera dobre przykłady i wyjaśnienia dotyczące const. Fragment:

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

Ale to smutne, że IE9/10 nadal nie obsługuje const. A powód to absurd :

Więc, co IE9 robi z const? Więc daleko, nasza decyzja była nie wesprzyj to. To jeszcze nie jest konsensus funkcja, ponieważ nigdy nie była dostępna na wszystkich przeglądarkach.

...

W końcu wydaje się, że najlepszy długoterminowe rozwiązaniem dla sieci jest zostawić i czekać na procesy standaryzacji w celu uruchomienia ich oczywiście.

Nie implementują go, ponieważ inne przeglądarki nie zaimplementowały go poprawnie?! Boisz się, że będzie lepiej? Definicje norm czy nie, stała jest stałą: ustawiona raz, nigdy się nie zmieniła.

I do wszystkich idei: każda funkcja może być nadpisana (XSS itp.). Więc nie ma różnicy w var lub function(){return}. const jest jedynym prawdziwym stała.

Update: IE11 obsługuje const:

IE11 zawiera wsparcie dla dobrze zdefiniowanych i powszechnie używanych funkcji powstającego standardu ECMAScript 6, w tym let, const, Map, Set, i WeakMap, a także __proto__ w celu poprawy interoperacyjności.

W JavaScript preferuję używanie funkcji do zwracania wartości stałych.

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


alert(MY_CONSTANT());

Jeśli nie masz nic przeciwko użyciu funkcji:

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

Takie podejście daje funkcje zamiast zmiennych regularnych, ale gwarantuje^* że nikt nie może zmienić wartości po jej ustawieniu.

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

^{_{*chyba że ktoś przedefiniował funkcję constant zanim ją wywołałeś}}

Z" nowym " obiektowym api możesz zrobić coś takiego:

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

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

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

Uwaga: przypisanie zwróci ci przypisaną wartość w konsoli, ale wartość zmiennej nie ulegnie zmianie

Grupowanie stałych w struktury, gdzie to możliwe:

Przykład, w moim obecnym projekcie gry, użyłem poniżej:

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

Przypisanie:

var wildType = CONST_WILD_TYPES.REGULAR;

Porównanie:

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

Ostatnio używam, dla porównania:

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

IE11 jest z nowym standardem ES6, który ma deklarację 'const'.
Powyższe działa we wcześniejszych przeglądarkach, takich jak IE8, IE9 i IE10.

Możesz łatwo wyposażyć swój skrypt w mechanizm stałych, które można ustawić, ale nie zmieniać. Próba ich zmiany wygeneruje błąd.

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

Zapomnij o IE i użyj słowa kluczowego const.

Jednak nie ma dokładnego predefiniowanego sposobu, aby to zrobić, możesz to osiągnąć, kontrolując zakres zmiennych, jak pokazano w innych odpowiedziach.

Ale sugeruję użycie przestrzeni nazw dla odróżnienia od innych zmiennych. zmniejszy to prawdopodobieństwo kolizji z innymi zmiennymi do minimum.

Właściwe przestrzenie nazw jak

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

Więc podczas używania będzie iw_constant.name lub iw_constant.age

Możesz również zablokować Dodawanie nowego klucza lub zmianę dowolnego klucza wewnątrz iw_constant korzystanie z obiektu.metoda zamrażania. Jednak nie jest obsługiwany w starszej przeglądarce.

Ex:

Object.freeze(iw_constant);

Dla starszej przeglądarki można użyć polyfill do metody zamrażania.

Jeśli nie masz nic przeciwko wywołaniu funkcji following jest najlepszym sposobem na zdefiniowanie stałej przez przeglądarkę. Przeszukiwanie obiektu wewnątrz funkcji samoczynnie wykonującej i zwracanie funkcji get dla stałych ex:

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

       };

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

/ / aby uzyskać wartość użyj iw_constant('name') lub iw_constant('age')

* * w obu przykładach musisz należy bardzo uważać na odstępy między nazwami, aby obiekt lub funkcja nie były zastępowane przez inną bibliotekę.(Jeśli obiekt lub sama funkcja zostanie zastąpiona, Cała stała odejdzie)

Przez jakiś czas określałem "stałe" (które nadal nie były stałymi) w literałach obiektów przekazywanych do Instrukcji with(). Myślałem, że to takie sprytne. Oto przykład:

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

W przeszłości stworzyłem również przestrzeń nazw CONST, w której umieściłbym wszystkie moje stałe. Znowu, z nad głową. Sheesh.

Teraz robię var MY_CONST = 'whatever'; pocałunek .

Moja opinia (działa tylko z obiektami).

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

Spróbuj też po prostu:

const a = 9;

Ja też miałem z tym problem. I po dłuższym czasie szukania odpowiedzi i przeglądania wszystkich odpowiedzi przez wszystkich, Myślę, że znalazłem realne rozwiązanie tego problemu.

Wydaje się, że większość odpowiedzi, na które natknąłem się, używa funkcji do utrzymywania stałych. Jak wielu użytkowników wielu postów na forach, funkcje mogą być łatwo napisane przez użytkowników po stronie klienta. Zaintrygowała mnie odpowiedź Keitha Evettsa, że obiekt stały nie może być dostępne z zewnątrz, ale tylko z funkcji wewnątrz.

Więc wymyśliłem takie rozwiązanie:

Umieść wszystko wewnątrz anonimowej funkcji tak, aby w ten sposób zmienne, obiekty itp. nie może być zmieniony przez Klienta. Ukryj również funkcje "rzeczywiste", mając inne funkcje wywołujące funkcje "rzeczywiste" od wewnątrz. Pomyślałem również o użyciu funkcji do sprawdzenia, czy funkcja została zmieniona przez użytkownika po stronie klienta. Jeśli funkcje zostały zmienione, Zmień są one z powrotem za pomocą zmiennych, które są "chronione" wewnątrz i nie mogą być zmieniane.

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

Wydaje się również, że bezpieczeństwo jest naprawdę problemem i nie ma sposobu na "ukrycie" programowania po stronie klienta. Dobrym pomysłem dla mnie jest skompresowanie kodu tak, aby każdemu, w tym Tobie, programistom, było naprawdę ciężko go przeczytać i zrozumieć. Jest strona, do której możesz przejść: http://javascriptcompressor.com/. (to nie jest moja strona, nie martw się, nie reklamuję.) To to strona, która pozwoli Ci skompresować i zaciemnić kod Javascript za darmo.

1. skopiuj cały kod z powyższego skryptu i wklej go do Top textarea na javascriptcompressor.com strona.
2. zaznacz pole kodowania Base62, zaznacz pole wyboru Shrink Variables.
3. naciśnij przycisk Compress.
4. Wklej i zapisz to wszystko wplik js i dodaj go do swojej strony w nagłówku swojej strony.

Wyraźnie pokazuje to potrzebę znormalizowanego słowa kluczowego const między przeglądarkami.

Ale na razie:

var myconst = value;

Lub

Object['myconst'] = value;

Używam const zamiast var w moich skryptach Greasemonkey, ale to dlatego, że będą działać tylko na Firefoksie...
Konwencja nazw może być rzeczywiście drogą do zrobienia, zbyt (robię oba!).

W JavaScript moja praktyka polegała na unikaniu stałych, jak tylko mogę, i używaniu zamiast nich ciągów. Problemy z stałymi pojawiają się, gdy chcesz ujawnić swoje stałe światu zewnętrznemu:

Na przykład można zaimplementować następujące API Date:

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

Ale o wiele krótsze i bardziej naturalne jest po prostu pisać:

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

W ten sposób "dni" i "godziny" naprawdę działają jak stałe, ponieważ nie można zmienić z zewnątrz, ile sekund "godziny" reprezentuje. Ale to łatwe do nadpisania MyModule.Date.HOUR.

Tego rodzaju podejście pomoże również w debugowaniu. Jeśli Firebug powie ci action === 18, trudno jest zrozumieć, co to znaczy, ale kiedy zobaczysz action === "save", od razu jest jasne.

Ok, to jest brzydkie, ale daje mi stałą w Firefoksie i Chromium, stałą niestałą (WTF?) w Safari i operze oraz zmienną w IE.

Oczywiście eval () jest złe, ale bez niego IE wyrzuca błąd, uniemożliwiając uruchamianie skryptów.

Safari i Opera obsługują słowo kluczowe const, ale można zmienić wartość const .

W tym przykładzie kod po stronie serwera zapisuje JavaScript na stronie, zastępując {0} wartością.

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

Co to jest to dobrze? Niewiele, ponieważ nie jest to przeglądarka. W najlepszym razie, może trochę spokoju, że przynajmniej niektóre przeglądarki nie pozwalają bookmarklets lub skrypt innych firm modyfikować wartość.

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

Jeśli warto wspomnieć, można zdefiniować stałe w kątowe używając $provide.constant()

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

Ulepszona wersja odpowiedzi Burke ' a , która pozwala zrobić CONFIG.MY_CONST zamiast CONFIG.get('MY_CONST').

Wymaga IE9+ lub prawdziwej przeglądarki internetowej.

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

_{* właściwości są tylko do odczytu, tylko jeżeli wartości początkowe są niezmienne.}

JavaScript ES6 (re-)wprowadził const Słowo kluczowe, które jest obsługiwane w wszystkich głównych przeglądarkach.

Zmienne zadeklarowane przez const nie mogą być ponownie zadeklarowane ani ponownie przypisane.

Poza Tym const zachowuje się podobnie do let.

Zachowuje się zgodnie z oczekiwaniami dla prymitywnych typów danych (Boolean, Null, Undefined, Number, String, Symbol):

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

Uwaga: Bądź świadomy pułapek dotyczących obiekty:

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

Jeśli naprawdę potrzebujesz niezmiennego i absolutnie stałego obiektu: po prostu użyj const ALL_CAPS, aby wyrazić swoją intencję jasno. Jest to dobra konwencja do naśladowania dla wszystkich const deklaracji i tak, więc po prostu polegać na nim.

Inna alternatywa to coś w stylu:

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

Wtedy po prostu: var foo = constantMap.MY_CONSTANT

Jeśli miałbyś constantMap.MY_CONSTANT = "bar" nie miałoby to żadnego skutku, ponieważ próbujemy użyć operatora przyporządkowania z getterem, stąd constantMap.MY_CONSTANT === "myconstant" pozostanie prawdą.

W Javascript już istnieją stałe . Definiujesz stałą w ten sposób:

const name1 = value;

To nie może się zmienić poprzez zmianę przydziału.

Słowo kluczowe 'const' zostało zaproponowane wcześniej, a teraz zostało oficjalnie włączone do ES6. Używając słowa kluczowego const, możesz przekazać wartość / ciąg znaków, który będzie działał jako niezmienny ciąg znaków.

Wprowadzenie stałych do JavaScript to w najlepszym wypadku hack.

Dobrym sposobem tworzenia trwałych i globalnie dostępnych wartości w JavaScript byłoby zadeklarowanie obiektu literalnie z niektórymi właściwościami "tylko do odczytu", takimi jak:

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

Wszystkie Twoje stałe zostaną zgrupowane w jednym" moim " obiekcie akcesorium, w którym możesz wyszukać zapisane wartości lub cokolwiek innego, co zdecydowałeś się tam umieścić. Teraz sprawdźmy czy to działa:

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

Jak widać, "my.nieruchomość constant1 zachowała swoją pierwotną wartość. Zrobiłeś sobie ładne "zielone" stałe tymczasowe...

Ale oczywiście to tylko ochroni Cię przed przypadkową modyfikacją, zmianą, unieważnieniem lub opróżnieniem stałej wartości właściwości z bezpośrednim dostępem, jak w podanym przykładzie.

W przeciwnym razie nadal myślę, że stałe są dla manekinów. I nadal uważam, że wymiana twojej wielkiej wolności na mały zakątek zwodniczego bezpieczeństwa to najgorszy interes możliwe.

Rhino.js implementuje const oprócz tego, co zostało wymienione powyżej.