JavaScript에는 상수가 있습니까?

JavaScript 에서 상수를 사용하는 방법이 있습니까?

그렇지 않은 경우 상수로 사용되는 변수를 지정하는 일반적인 방법은 무엇입니까?

ES2015 이후 JavaScript는 다음과 같은 개념을 가지고 있습니다 const.

const MY_CONSTANT = "some-value";

이것은 IE 8, 9 및 10을 제외한 거의 모든 브라우저 에서 작동 합니다. 일부는 엄격한 모드를 사용해야 할 수도 있습니다 .

varALL_CAPS와 같은 규칙을 사용 하여 이전 브라우저를 지원해야하거나 레거시 코드로 작업하는 경우 특정 값을 수정해서는 안됨을 표시 할 수 있습니다 .

var MY_CONSTANT = "some-value";

변수가 수정되지 않도록 보호하려고합니까? 그렇다면 모듈 패턴을 사용할 수 있습니다.

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

이 방법을 사용하면 값을 수정할 수 없습니다. 그러나 CONFIG :(.)에서 get () 메소드를 사용해야합니다.

변수 값을 엄격하게 보호 할 필요가 없으면 제안 된대로 수행하고 모든 CAPS 규칙을 사용하십시오.

const키워드에 ECMA 스크립트 (6) 초안 하지만 지금까지 유일한 브라우저 지원의 겉 핥기 즐깁니다 : http://kangax.github.io/compat-table/es6/를 . 구문은 다음과 같습니다.

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

Object.freeze를 참조하십시오 . 참조를 읽기 전용으로 만들려는 경우 사용할const 수 있습니다 constants.

IE는 다음과 같은 상수를 지원합니다.

<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는 다음을 소개합니다 Object.defineProperty:

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

그것은있어 모든 현대적인 브라우저에서 지원 (물론 IE ≥ 9).

ES5의 Object.defineProperty 도 참조하십시오 .

아니요, 일반적으로 아닙니다. Firefox는 구현 const하지만 IE는 그렇지 않습니다.

@ 존 다른 언어로 년 동안 사용되어왔다 consts에 대한 일반적인 명명 연습 점, 나는 당신이 그것을 사용할 수없는 이유가 없습니다. 물론 이것이 누군가가 변수의 값을 덮어 쓰지 않는다는 것을 의미하지는 않습니다. :)

JavaScript에서는 함수를 사용하여 상수 값을 반환하는 것이 좋습니다.

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


alert(MY_CONSTANT());

Mozillas MDN 웹 문서 에는에 대한 좋은 예와 설명이 들어 있습니다 const. 발췌 :

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

그러나 IE9 / 10이 여전히 지원하지 않는 것은 슬픈 일입니다 const. 그리고 그것이 터무니없는 이유 :

그래서 IE9는 const로 무엇을하고 있습니까? 지금까지 우리의 결정은 그것을지지하지 않는 것이 었습니다. 모든 브라우저에서 사용할 수 없었기 때문에 아직 컨센서스 기능이 아닙니다.

...

결국, 웹을위한 최상의 장기 솔루션은 웹을 떠나 표준화 프로세스가 진행될 때까지 기다리는 것 같습니다.

다른 브라우저가 올바르게 구현하지 않았기 때문에 구현하지 않습니까?! 더 나아 질까 두려운가요? 표준 정의 여부에 관계없이 상수는 상수입니다. 한 번 설정하면 절대 변경되지 않습니다.

그리고 모든 아이디어에 : 모든 기능을 덮어 쓸 수 있습니다 (XSS 등). 따라서 var또는에 차이가 없습니다 function(){return}. const유일한 상수입니다.

업데이트 : IE11 은 const 다음을 지원합니다 .

IE11은하자를 포함한 신흥 인 ECMAScript 6 표준의 잘 정의 일반적으로 사용되는 기능에 대한 지원이 포함 const, Map, Set, 및 WeakMap뿐만 아니라 __proto__향상된 상호 운용성.

함수를 사용하지 않아도되는 경우 :

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

이 방법을 사용하면 대신 일반 변수의 기능 제공하지만, 그것은 보장 ^* 아무도 그것의 설정하면 값을 변경할 수 없음.

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

나는 개인적으로 녹아웃 옵저버 블 에서이 패턴에 익숙해지면 다소 유쾌하게 생각합니다.

^{_{* 누군가가 함수 constant를 호출하기 전에 함수 를 재정의하지 않은 경우}}

"새"Object API를 사용하면 다음과 같은 작업을 수행 할 수 있습니다.

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

한 번 봐 가지고 이 더 구체적인 내용 모질라 MDN에 있습니다. 객체에 첨부되어 있기 때문에 첫 번째 수준 변수는 아니지만 범위가 있으면 무엇이든 연결할 수 있습니다. this잘 작동합니다. 예를 들어 전역 범위 에서이 작업을 수행하면 의사 상수 값이 창에 선언됩니다 (실제로 나쁜 생각이므로 전역 변수를 부주의하게 선언해서는 안됩니다)

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

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

참고 : 할당하면 콘솔에서 할당 된 값이 다시 표시되지만 변수 값은 변경되지 않습니다.

가능한 경우 상수를 구조로 그룹화하십시오.

예를 들어, 현재 게임 프로젝트에서 아래를 사용했습니다.

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

할당:

var wildType = CONST_WILD_TYPES.REGULAR;

비교 :

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

더 최근에는 비교를 위해 사용하고 있습니다.

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

IE11에는 'const'선언이있는 새로운 ES6 표준이 있습니다.
위의 IE8, IE9 및 IE10과 같은 이전 브라우저에서 작동합니다.

설정할 수는 있지만 변경할 수없는 상수에 대한 메커니즘을 스크립트에 쉽게 장착 할 수 있습니다. 변경하려고하면 오류가 발생합니다.

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

IE를 잊고 const키워드를 사용하십시오 .

그러나 브라우저 간 사전 정의 된 정확한 방법은 없지만 다른 답변에 표시된대로 변수 범위를 제어하여이를 달성 할 수 있습니다.

그러나 다른 변수와 구별하기 위해 네임 스페이스를 사용하는 것이 좋습니다. 이렇게하면 다른 변수와의 충돌 가능성이 최소화됩니다.

적절한 이름 공간

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

그래서 그것을 사용하는 동안 iw_constant.name또는iw_constant.age

Object.freeze 메소드를 사용하여 iw_constant 내에서 새 키를 추가하거나 키를 변경하는 것을 차단할 수도 있습니다. 그러나 레거시 브라우저에서는 지원되지 않습니다.

전의:

Object.freeze(iw_constant);

구형 브라우저의 경우 고정 방법에 polyfill 을 사용할 수 있습니다 .

함수 호출에 문제가 없으면 다음과 같이 상수를 정의하는 가장 좋은 브라우저 간 방법입니다. 자체 실행 함수 내에서 객체의 범위를 정하고 상수에 대한 get 함수를 반환합니다.

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

       };

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

// 값을 얻 iw_constant('name')거나iw_constant('age')

** 두 예제에서 이름 간격에 매우주의하여 객체 또는 함수를 다른 라이브러리를 통해 교체해서는 안됩니다 (객체 또는 함수 자체가 교체되면 전체 상수가 이동합니다)

잠시 동안, 나는 with()문에 전달 된 객체 리터럴에 "상수"(실제로 상수는 아님)를 지정했습니다 . 나는 그것이 너무 영리하다고 생각했다. 예를 들면 다음과 같습니다.

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

과거에는 CONST모든 상수를 넣을 네임 스페이스 도 만들었습니다 . 다시, 오버 헤드로. esh.

자, 난 그냥 할 var MY_CONST = 'whatever';에 KISS .

내 의견 (객체와 만 작동).

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

시험! 그러나 이해하십시오-이것은 객체이지만 단순한 변수는 아닙니다.

또한 시도하십시오 :

const a = 9;

나도 이것에 문제가 있었다. 그리고 꽤 오랫동안 답변을 찾고 모든 사람들의 모든 답변을 살펴본 후에 나는 이것에 대한 실용적인 해결책을 생각해 냈습니다.

내가 본 대부분의 답변은 상수를 유지하는 함수를 사용하는 것 같습니다. 많은 MANY 포럼 사용자가 게시 한 것처럼 클라이언트 측의 사용자가 기능을 쉽게 덮어 쓸 수 있습니다. Keith Evetts의 답변에 따르면 상수 객체는 외부에서 액세스 할 수 없으며 내부의 함수에서만 액세스 할 수 있습니다.

그래서 나는이 해결책을 생각해 냈습니다.

클라이언트 측에서 변수, 객체 등을 변경할 수 없도록 익명 함수 안에 모든 것을 넣습니다. 또한 다른 함수가 내부에서 '실제'함수를 호출하도록하여 '실제'함수를 숨 깁니다. 또한 클라이언트 측의 사용자가 기능을 변경했는지 확인하기 위해 함수를 사용하는 방법을 생각했습니다. 기능이 변경된 경우 내부에서 '보호'되어 있으며 변경할 수없는 변수를 사용하여 다시 변경하십시오.

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

또한 보안은 실제로 문제가되는 것으로 보이며 클라이언트 측에서 프로그래밍을 '숨길'수있는 방법이 없습니다. 저에게 좋은 생각은 프로그래머를 포함한 모든 사람이 읽고 이해하기가 어렵도록 코드를 압축하는 것입니다. 당신이 갈 수있는 사이트가 있습니다 : http://javascriptcompressor.com/ . (이것은 내 사이트가 아니며, 광고하지 않는다고 걱정하지 마십시오.)이 사이트는 Javascript 코드를 무료로 압축하고 난독 처리 할 수있는 사이트입니다.

1. 위 스크립트의 모든 코드를 복사하여 javascriptcompressor.com 페이지의 상단 텍스트 영역에 붙여 넣습니다.
2. Base62 인코딩 확인란을 선택하고 변수 축소 확인란을 선택하십시오.
3. 압축 버튼을 누릅니다.
4. 모든 파일을 .js 파일에 붙여 넣은 다음 페이지 헤드의 페이지에 추가하십시오.

분명히 이것은 표준화 된 크로스 브라우저 const 키워드의 필요성을 보여줍니다.

그러나 지금은 :

var myconst = value;

또는

Object['myconst'] = value;

둘 다 충분 해 보이고 다른 것은 바주카포로 비행하는 것과 같습니다.

Greasemonkey 스크립트 const대신에 사용 var하지만 Firefox에서만 실행되기 때문입니다.
이름 규칙도 실제로 갈 수 있습니다 (두 가지 모두를 수행하십시오!).

JavaScript에서 내 연습은 가능한 한 상수를 피하고 대신 문자열을 사용하는 것입니다. 상수를 외부 세계에 노출하려고 할 때 상수 문제가 나타납니다.

예를 들어 다음과 같은 Date API를 구현할 수 있습니다.

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

그러나 간단하게 작성하는 것이 훨씬 짧고 자연 스럽습니다.

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

이 방법으로 "일"과 "시간"은 실제로 상수처럼 작동합니다. "시간"이 나타내는 초 수를 외부에서 변경할 수 없기 때문입니다. 하지만 쉽게 덮어 쓸 수 MyModule.Date.HOUR있습니다.

이러한 종류의 접근 방식은 디버깅에도 도움이됩니다. Firebug가 말하면 action === 18그것이 의미하는 바를 알아내는 것은 매우 어렵지만, 볼 때 action === "save"즉시 분명합니다.

좋아, 이것은 추악하지만 Firefox와 Chromium에 상수, Safari와 Opera의 불변 상수 (WTF?) 및 IE의 변수를 제공합니다.

물론 eval ()은 악의적이지만 IE가 없으면 스크립트가 실행되지 못하게하는 오류가 발생합니다.

Safari와 Opera는 const 키워드를 지원하지만 const의 값을 변경할 수 있습니다 .

이 예제에서 서버 측 코드는 페이지에 JavaScript를 작성하여 {0}을 값으로 대체합니다.

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

이것이 좋은 점은 무엇입니까? 크로스 브라우저가 아니기 때문에 별로는 아닙니다. 기껏해야 적어도 마음의 평화가 일부 브라우저는 북마크 나 타사 스크립트가 값을 수정하도록 허용하지 않을 수도 있습니다.

Firefox 2, 3, 3.6, 4, Iron 8, Chrome 10, 12, Opera 11, Safari 5, IE 6, 9에서 테스트되었습니다.

언급 할 가치가있는 경우 다음을 사용하여 상수를 각도로 정의 할 수 있습니다$provide.constant()

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

대신 Burke의 답변 을 개선했습니다 .CONFIG.MY_CONSTCONFIG.get('MY_CONST')

IE9 + 또는 실제 웹 브라우저가 필요합니다.

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

_{* 초기 값을 변경할 수없는 경우에만 속성이 읽기 전용입니다.}

JavaScript ES6 는 모든 주요 브라우저 에서 지원되는 const키워드 를 다시 도입했습니다 .

via를 통해 선언 된 변수는 const다시 선언하거나 재 할당 할 수 없습니다.

그 외에도에서, const유사 동작합니다 let.

기본 데이터 유형 (부울, 널, 정의되지 않음, 숫자, 문자열, 기호)에 대해 예상대로 작동합니다.

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

주의 : 물체와 관련된 함정에 유의 하십시오.

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

불변이고 절대적으로 일정한 객체가 정말로 필요한 경우 : const ALL_CAPS의도를 명확하게하기 위해 사용하십시오. const어쨌든 모든 선언 을 따르는 것이 좋은 규칙 이므로 그에 의존하십시오.

다른 대안은 다음과 같습니다.

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

그런 다음 간단히 : var foo = constantMap.MY_CONSTANT

당신이 인 경우에 constantMap.MY_CONSTANT = "bar"우리는 게터와 할당 연산자를 사용하려는으로 영향을 미치지 않을 것이다 그것은, 따라서 constantMap.MY_CONSTANT === "myconstant"진정한 남아있을 것입니다.

Javascript에는 이미 상수가 있습니다. 다음과 같이 상수를 정의하십시오.

const name1 = value;

재 할당을 통해 변경할 수 없습니다.

키워드 'const'는 이전에 제안되었으며 현재 공식적으로 ES6에 포함되었습니다. const 키워드를 사용하면 불변 문자열로 작동하는 값 / 문자열을 전달할 수 있습니다.

JavaScript에 상수를 도입하는 것은 최선의 방법입니다.

JavaScript에서 지속적으로 전역 적으로 액세스 가능한 값을 만드는 좋은 방법은 다음과 같은 "읽기 전용"속성으로 객체 리터럴을 선언하는 것입니다.

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

모든 상수는 하나의 "my"액세서리 객체로 그룹화되어 저장된 값 또는 해당 사안에 대해 결정한 다른 것을 찾을 수 있습니다. 이제 작동하는지 테스트 해 봅시다.

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

보다시피, "my.constant1"속성은 원래 값을 유지했습니다. 당신은 멋진 '녹색'임시 상수를 만들었습니다 ...

물론 이것은 주어진 예제에서와 같이 직접 액세스하여 속성 상수 값을 실수로 수정, 변경, 무효화 또는 비우는 것만 방지합니다.

그렇지 않으면 여전히 상수가 인형을위한 것이라고 생각합니다. 그리고 난 여전히기만적인 안보의 작은 구석에 대한 당신의 큰 자유를 교환하는 것이 가능한 최악의 거래라고 생각합니다.

Rhino.jsconst위에서 언급 한 것 외에도 구현합니다 .