Существуют ли константы в JavaScript?

Есть ли способ использовать константы в JavaScript?

Если нет, то какая общая практика для указания переменных, которые используются в качестве констант?

+1011
источник поделиться
32 ответа
  • 1
  • 2

ES2015, последняя версия JavaScript, имеет понятие const:

const MY_CONSTANT = "some-value";

Это будет работать в почти во всех браузерах, кроме IE 8, 9 и 10. Некоторым может также понадобиться строгий режим.

Вы можете использовать соглашения, такие как ALL_CAPS, чтобы показать, что определенные значения не должны быть изменены, если вы не пишете код ES2015:

var MY_CONSTANT = "some-value";
+923
источник

Вы пытаетесь защитить переменные от модификации? Если это так, то вы можете использовать шаблон модуля:

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

Используя этот подход, значения не могут быть изменены. Но вы должны использовать метод get() для CONFIG: (.

Если вам не нужно строго защищать значение переменных, тогда просто сделайте так, как было предложено, и используйте соглашение ALL CAPS.

+295
источник

Ключевое слово const находится в проекте ECMAScript 6, но до сих пор оно только немного смахивает на поддержку браузера: http://kangax.github.io/compat-table/es6/. Синтаксис:

const CONSTANT_NAME = 0;
+116
источник

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>
+63
источник
"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 только для чтения.

+55
источник

В ECMAScript 5 вводится Object.defineProperty:

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

Он поддерживается в каждом современном браузере (а также IE ≥ 9).

См. также: Object.defineProperty в ES5?

+54
источник

Нет, не в общем. Firefox реализует const, но я знаю, что IE этого не делает.


@John указывает на обычную практику именования для констант, которая в течение многих лет использовалась на других языках, я не вижу причин, по которым вы не мог использовать это. Конечно, это не значит, что кто-то все равно не будет писать значение переменной.:)

+22
источник

Mozillas MDN Web Docs содержат хорошие примеры и пояснения о 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 с константой? Так далеко, наше решение состояло в том, чтобы не поддержите его. Это еще не консенсус поскольку он никогда не был доступен на всех браузерах.

...

В конце концов, это кажется лучшим долгосрочное решение для Интернета - это оставьте это и дождитесь стандартизации для запуска их Конечно.

Они не реализуют его, потому что другие браузеры не реализовали его правильно?! Слишком бояться сделать это лучше? Определения стандартов или нет, константа является константой: устанавливается один раз, никогда не менялась.

И ко всем идеям: каждая функция может быть перезаписана (XSS и т.д.). Таким образом, нет разницы в var или function(){return}. const - единственная действительная константа.

Обновление: IE11 поддерживает const:

IE11 включает поддержку четко определенных и часто используемых функций нового стандарта ECMAScript 6, включая let, const, Map, Set и WeakMap, а также как __proto__ для улучшения взаимодействия.

+19
источник

В JavaScript я предпочитаю использовать функции для возврата постоянных значений.

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


alert(MY_CONSTANT());
+18
источник

с "новым" объектом api вы можете сделать что-то вроде этого:

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

взгляните на этот на Mozilla MDN для более подробной информации. Это не первая переменная уровня, поскольку она привязана к объекту, но если у вас есть область действия, что угодно, вы можете прикрепить ее к этому. this должен работать. Так, например, если сделать это в глобальной области действия, будет объявлено псевдооднозначное значение в окне (это действительно плохая идея, вы не должны объявлять глобальные вары небрежно)

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

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

note: назначение вернет вам назначенное значение в консоли, но значение переменной не изменится

+16
источник

Если вы не против использования функций:

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

Этот подход дает вам функции вместо обычных переменных, но гарантирует * что никто не может изменить значение после его установки.

a = constant(10);

a(); // 10

b = constant(20);

b(); // 20

Я лично считаю это довольно приятным, особенно после того, как привык к этому шаблону от наблюдаемых нокаутом.

* Если кто-то не переопределил функцию constant, прежде чем вы ее вызвали

+16
источник

Групповые константы в структурах, где это возможно:

Пример, в моем текущем игровом проекте, который я использовал ниже:

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

Назначение:

var wildType = CONST_WILD_TYPES.REGULAR;

Comparision:

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 с новым стандартом ES6, который имеет объявление 'const'.
Выше работает в более ранних браузерах, таких как IE8, IE9 и IE10.

+11
источник

Вы можете легко оборудовать свой script механизмом для констант, который можно установить, но не изменить. Попытка изменить их приведет к ошибке.

/* 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  
+10
источник

Однако для этого не существует определенного предопределенного способа перекрестного браузера, вы можете достичь этого, контролируя область переменных, как показано на других ответах.

Но я предлагаю использовать пространство имен, чтобы отличить от других переменных. это уменьшит вероятность столкновения до минимума от других переменных.

Собственные имена, такие как

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

поэтому при использовании будет iw_constant.name или iw_constant.age

Вы также можете заблокировать добавление нового ключа или изменение любого ключа внутри iw_constant с помощью метода Object.freeze. Однако он не поддерживается в устаревшем браузере.

ex:

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


** В обоих примерах вы должны быть очень осторожны с интервалом между именами, чтобы ваш объект или функция не могли быть заменены другой библиотекой. (Если сам объект или функция будет заменена, ваша целая константа будет идти)

+8
источник

Некоторое время я указывал "константы" (которые по-прежнему не были константами) в объектных литералах, переданных в выражения with(). Я думал, что это так умно. Вот пример:

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

В прошлом я также создал пространство имен CONST, где я бы поместил все мои константы. Опять же, с накладными расходами. Sheesh.

Теперь я просто делаю var MY_CONST = 'whatever'; в KISS.

+7
источник

Забудьте IE и используйте ключевое слово const.

+6
источник

Мое мнение (работает только с объектами).

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;
+6
источник

У меня тоже была проблема с этим. И после долгого времени, ища ответ и глядя на все ответы всех, я думаю, что придумал жизнеспособное решение этого.

Похоже, что большинство ответов, с которыми я сталкивался, - это использование функций для хранения констант. Как и многие пользователи форумов MANY, функции могут быть легко записаны пользователями на стороне клиента. Я был заинтригован ответом Кейта Эветта о том, что объект констант не может быть доступен снаружи, но только из функций внутри.

Итак, я придумал это решение:

Поместите все внутри анонимной функции таким образом, чтобы переменные, объекты и т.д. не могли быть изменены на стороне клиента. Также скрыть "реальные" функции, если другие функции вызовут "реальные" функции изнутри. Я также думал об использовании функций для проверки того, была ли функция изменена пользователем на стороне клиента. Если функции были изменены, измените их, используя переменные, которые "защищены" внутри и не могут быть изменены.

/*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 бесплатно.

  • Скопируйте весь код в приведенном выше script и вставьте его в верхнюю область textarea на странице javascriptcompressor.com.
  • Установите флажок Base62 encode, установите флажок Shrink Variables.
  • Нажмите кнопку "Сжать".
  • Вставьте и сохраните все в файле .js и добавьте его на свою страницу в начале страницы.
+5
источник

Очевидно, это указывает на необходимость стандартизованного ключевого слова cross-browser const.

Но пока:

var myconst = value;

или

Object['myconst'] = value;

Оба кажутся достаточными, и что-то еще похоже на стрельбу с помощью базуки.

+5
источник

Хорошо, это уродливо, но это дает мне константу в Firefox и Chromium, непостоянную константу (WTF?) в Safari и Opera и переменную в 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);

Для чего это полезно? Не так много, так как это не кросс-браузер. В лучшем случае, может быть, немного спокойствия, что по крайней мере некоторые браузеры не позволят закладкам или сторонним script изменять значение.

Протестировано с помощью Firefox 2, 3, 3,6, 4, Iron 8, Chrome 10, 12, Opera 11, Safari 5, IE 6, 9.

+4
источник

Если это стоит упомянуть, вы можете определить константы в angular, используя $provide.constant()

angularApp.constant('YOUR_CONSTANT', 'value');
+4
источник

Я использую const вместо var в своих сценариях Greasemonkey, но это потому, что они будут запускаться только на Firefox...
Соглашение о названии может быть и в самом деле - тоже (я делаю оба!).

+3
источник

В JavaScript моя практика заключалась в том, чтобы избегать констант, насколько я могу, и вместо этого использовать строки. Проблемы с константами появляются, когда вы хотите выставить свои константы во внешний мир:

Например, можно реализовать следующий 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", тогда он сразу же очищается.

+3
источник

Вводя константы в JavaScript, в лучшем случае является хаком.

Хорошим способом создания постоянных и общедоступных значений в JavaScript было бы объявление литерала объекта с некоторыми свойствами "только для чтения":

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

у вас будут все ваши константы, сгруппированные в один "мой" вспомогательный объект, где вы можете искать свои сохраненные значения или что-то еще, что вы, возможно, решили поставить там на этот счет. Теперь дайте тест, если он работает:

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

Как мы видим, свойство my.constant1 сохранил свое первоначальное значение. Вы сделали себе приятные "зеленые" временные константы...

Но, конечно, это будет защищать вас от случайного изменения, изменения, обнуления или опорожнения значения константы вашего свойства с помощью прямого доступа, как в данном примере.

В противном случае я все еще думаю, что константы для чайников. И я по-прежнему считаю, что обмен вашей большой свободой на небольшой угол обманчивой безопасности является наихудшей сделкой.

+3
источник

Улучшенная версия ответа Берка, которая позволяет вам делать CONFIG.MY_CONST вместо CONFIG.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;
}());

* Свойства доступны только для чтения, только если начальные значения неизменяемы.

+3
источник

в Javascript уже существует константы. Вы определяете константу следующим образом:

const name1 = value;

Это невозможно изменить с помощью переназначения.

+3
источник

Ключевое слово 'const' было предложено ранее, и теперь оно официально включено в ES6. Используя ключевое слово const, вы можете передать значение/строку, которая будет действовать как неизменяемая строка.

+3
источник

Rhino.js реализует const в дополнение к тому, что было упомянуто выше.

+2
источник
Ключевое слово

const доступно на языке javscript, но оно не поддерживает браузер IE. Оставьте все поддерживаемые браузеры.

+2
источник

Другая альтернатива - это что-то вроде:

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" останется истинным.

+2
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос