const
Значение констант не может быть изменено новым присваиванием, а также не может быть переопределено. Константы ( const ) подчиняются области видимости уровня блока так же, как переменные, объявленные с использованием ключевого слова let .
Синтаксис
const name1 = value1 [, name2 = value2 [, . [, nameN = valueN]]];
Имя константы. Подчиняется тем же правилам, что и идентификаторы обычных переменных.
Значение константы. Может быть любым из тех типов, которые могут быть для переменных, включая функцию.
Описание
Это объявление создаёт константу, чья область действия может быть как глобальной, так и локальной внутри блока, в котором она объявлена. Глобальные константы не становятся свойствами объекта window, в отличие от var -переменных. Инициализация константы обязательна; необходимо указать значение одновременно с объявлением (смысл в том, что потом это значение изменить уже нельзя).
const создаёт константу (новую именованную ссылку на область памяти), доступную только для чтения. Это не означает, что указываемое значение неизменно, но это означает, что идентификатор не может быть переназначен. Например, если константа указывает на объект, то сам объект может быть изменён.
Все соображения по поводу временных мёртвых зон, применимы и к let и к const .
Имена констант не могут совпадать с именами функций или переменных той же области видимости.
Примеры
Ниже описаны примеры, демонстрирующие поведение const . Попробуйте их выполнить в простом JavaScript-редакторе или в консоли браузера.
// Примечание: Идентификаторы констант могут быть объявлены как в верхнем, // так и в нижнем регистре. Но правилом хорошего тона является использование // верхнего регистра. // определим MY_FAV как константу и присвоим ей значение 7 const MY_FAV = 7; // данное присваивание выдаст ошибку - Uncaught TypeError: Assignment to constant variable. MY_FAV = 20; // напечатает 7 console.log("my favorite number is: " + MY_FAV); // попробуем переопределить константу, будет брошено исключение - Uncaught SyntaxError: Identifier 'MY_FAV' has already been declared const MY_FAV = 20; // имя MY_FAV зарезервировано константой выше, данная операция // выкинет исключение var MY_FAV = 20; // здесь также будет ошибка let MY_FAV = 20; // Важно отметить свойства области видимости уровня блока if (MY_FAV === 7) // Всё нормально. Создать константу или переменную MY_FAV можно. // (работает так же как и let при объявлении в блоке переменных, которые не const) const MY_FAV = 20; // MY_FAV теперь 20 console.log("my favorite number is " + MY_FAV); // это попадёт в глобальный контекст и выдаст ошибку var MY_FAV = 20; > // MY_FAV все ещё имеет значение 7 console.log("my favorite number is " + MY_FAV); // Выдаст ошибку, потому что константа не инициализирована - Uncaught SyntaxError: Missing initializer in const declaration const FOO; // const также работает с объектами const MY_OBJECT = "key": "value">; // Попытка переопределить ссылку на объект вызовет исключение - Uncaught TypeError: Assignment to constant variable. MY_OBJECT = "OTHER_KEY": "value">; // но, свойства объекта (ключи) можно изменять MY_OBJECT.key = "otherValue"; // Используйте Object.freeze() для того, чтобы сделать объект неизменяемым // То же самое применимо к массивам const MY_ARRAY = []; // Например, можно добавлять элементы в массив MY_ARRAY.push("A"); // ["A"] // Но менять ссылку на объект массива нельзя. Это вызовет исключение - Uncaught TypeError: Assignment to constant variable MY_ARRAY = ["B"]
Спецификация
| Specification |
|---|
| ECMAScript Language Specification # sec-let-and-const-declarations |
Совместимость с браузерами
BCD tables only load in the browser
Смотрите также
- var
- let
- Константы в справочнике JavaScript
Указатели с ключевыми словами const и volatile
Константы и переменные ключевое слово изменяют способ обработки указателей. Ключевое слово const указывает, что указатель не может быть изменен после инициализации; указатель будет защищен от изменения.
Ключевое слово volatile указывает, что значение, связанное с именем, следующим образом, может быть изменено действиями, отличными от действий в пользовательском приложении. Таким образом, volatile ключевое слово полезно для объявления объектов в общей памяти, к которым можно обращаться с помощью нескольких процессов или глобальных областей данных, используемых для взаимодействия с подпрограммами службы прерываний.
Когда имя объявляется как volatile , компилятор перезагружает значение из памяти каждый раз, когда он обращается к программе. Это значительно сокращает возможности оптимизации. Однако если состояние объекта может неожиданно изменяться, то это единственный способ гарантировать предсказуемую производительность программы.
Чтобы объявить объект, на который указывает указатель, или const volatile используйте объявление формы:
const char *cpch; volatile char *vpch; Чтобы объявить значение указателя , то есть фактический адрес, хранящийся в указателе, как const или volatile используйте объявление формы:
char * const pchc; char * volatile pchv; Язык C++ запрещает назначения, позволяющие изменять объект или указатель, объявленный как const . Такие присваивания могут удалить информацию, с которой был объявлен объект или указатель, и тем самым подменить смысл исходного объявления. Рассмотрим следующее объявление:
const char cch = 'A'; char ch = 'B'; Учитывая предыдущие объявления двух объектов ( cch типа const char и ch типа char), допустимы следующие объявления и инициализации:
const char *pch1 = &cch; const char *const pch4 = &cch; const char *pch5 = &ch; char *pch6 = &ch; char *const pch7 = &ch; const char *const pch8 = &ch; Следующие объявления и инициализации вызывают ошибки.
char *pch2 = &cch; // Error char *const pch3 = &cch; // Error В объявлении pch2 задается указатель, при помощи которого может быть изменен постоянный объект, поэтому это объявление запрещено. Объявление pch3 указывает, что указатель является константой, а не объектом; объявление запрещено по той же причине pch2 , что объявление запрещено.
В следующих восьми примерах демонстрируется присваивание через указатель и изменение значения указателя для приведенных выше объявлений. Здесь мы предполагаем, что инициализация указателей pch1 – pch8 была выполнена без ошибок.
*pch1 = 'A'; // Error: object declared const pch1 = &ch; // OK: pointer not declared const *pch2 = 'A'; // OK: normal pointer pch2 = &ch; // OK: normal pointer *pch3 = 'A'; // OK: object not declared const pch3 = &ch; // Error: pointer declared const *pch4 = 'A'; // Error: object declared const pch4 = &ch; // Error: pointer declared const Указатели, объявленные как volatile или как смесь const и volatile , подчиняются тем же правилам.
Указатели на const объекты часто используются в объявлениях функций следующим образом:
errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource ); Предыдущая инструкция объявляет функцию, strcpy_s, где два из трех аргументов имеют указатель char типа. Так как аргументы передаются по ссылке, а не по значению, функция может быть свободна для изменения обоих strDestination и strSource , если strSource они не были объявлены как const . Объявление как const гарантирует вызывающий strSource объект, который strSource не может быть изменен вызываемой функцией.
Так как существует стандартное преобразование из имени типа в имя* типа* const , оно является законным для передачи аргумента типа char * в strcpy_s. Однако обратное не верно; для удаления атрибута const из объекта или указателя не существует неявного преобразования.
const Указатель заданного типа можно назначить указателю того же типа. Однако указатель, который не const может быть назначен указателю const . В следующем коде показано одно верное и одно неверное присваивание.
// const_pointer.cpp int *const cpObject = 0; int *pObject; int main() < pObject = cpObject; cpObject = pObject; // C3892 >В следующем примере показано, как объявить объект как const, когда имеется указатель на указатель на объект.
// const_pointer2.cpp struct X < X(int i) : m_i(i) < >int m_i; >; int main() < // correct const X cx(10); const X * pcx = &cx; const X ** ppcx = &pcx; // also correct X const cx2(20); X const * pcx2 = &cx2; X const ** ppcx2 = &pcx2; >const (C++)
При изменении объявления данных ключевое слово указывает, const что объект или переменная не изменяются.
Синтаксис
declarator :
ptr-declarator
noptr-declarator parameters-and-qualifiers trailing-return-type
ptr-declarator :
noptr-declarator
ptr-operator ptr-declarator
noptr-declarator :
declarator-id attribute-specifier-seq необ.
noptr-declarator parameters-and-qualifiers
noptr-declarator [ constant-expression opt ] attribute-specifier-seq opt
( ptr-declarator )
parameters-and-qualifiers :
( parameter-declaration-clause ) cv-qualifier-seq необ.
ref-qualifier opt noexcept-specifier opt attribute-specifier-seq opt
trailing-return-type :
-> type-id
ptr-operator :
* attribute-specifier-seq opt cv-qualifier-seq opt
& attribute-specifier-seq необ.
&& attribute-specifier-seq необ.
nested-name-specifier * attribute-specifier-seq opt cv-qualifier-seq opt
cv-qualifier-seq :
cv-qualifier cv-qualifier-seq необ.
cv-qualifier :
const
volatile
ref-qualifier :
&
&&
declarator-id :
. необ. id-expression
Значения const
Ключевое слово const указывает, что значение переменной является константой и сообщает компилятору, чтобы предотвратить изменение программистом.
// constant_values1.cpp int main() < const int i = 5; i = 10; // C3892 i++; // C2105 >В C++можно использовать const ключевое слово вместо #define директивы препроцессора для определения константных значений. Значения, определенные с const помощью, подвергаются типу проверка и могут использоваться вместо константных выражений. В C++можно указать размер массива с переменной const следующим образом:
// constant_values2.cpp // compile with: /c const int maxarray = 255; char store_char[maxarray]; // allowed in C++; not allowed in C В языке C константные значения по умолчанию имеют внешнюю компоновку, поэтому они могут использоваться только в файлах исходного кода. В языке C++ константные значения по умолчанию имеют внутреннюю компоновку, которая позволяет использовать их в файлах заголовков.
Ключевое слово const также можно использовать в объявлениях указателя.
// constant_values3.cpp int main() < char this_char, that_char; char *mybuf = &this_char, *yourbuf = &that_char; char *const aptr = mybuf; *aptr = 'c'; // OK aptr = yourbuf; // C3892 > Указатель на переменную, объявленную как const можно назначить только указателю, который также объявлен как const .
// constant_values4.cpp #include int main() < const char *mybuf = "test"; char *yourbuf = "test2"; printf_s("%s\n", mybuf); const char *bptr = mybuf; // Pointer to constant data printf_s("%s\n", bptr); // *bptr = 'a'; // Error >Указатели на данные-константы можно использовать в качестве параметров функций, чтобы функция не могла изменять параметр, переданный посредством указателя.
Для объектов, объявленных как const , можно вызывать только функции-члены констант. Компилятор гарантирует, что объект константы никогда не изменяется.
birthday.getMonth(); // Okay birthday.setMonth( 4 ); // Error Можно вызывать функции-члены констант или неконстантных для неконстантного объекта. Можно также перегрузить функцию-член с помощью const ключевое слово; эта функция позволяет вызывать другую версию функции для постоянных и неконстантных объектов.
Вы не можете объявлять конструкторы или деструкторы с const помощью ключевое слово.
const функции-члены
Объявление функции-члена с const помощью ключевое слово указывает, что функция является функцией только для чтения, которая не изменяет объект, для которого он вызывается. Функция-член констант не может изменять нестатические элементы данных или вызывать какие-либо функции-члены, которые не являются константами. Чтобы объявить функцию-член константы, поместите const ключевое слово после закрывающей скобки списка аргументов. В const объявлении и определении требуется ключевое слово.
// constant_member_function.cpp class Date < public: Date( int mn, int dy, int yr ); int getMonth() const; // A read-only function void setMonth( int mn ); // A write function; can't be const private: int month; >; int Date::getMonth() const < return month; // Doesn't modify anything >void Date::setMonth( int mn ) < month = mn; // Modifies data member >int main() < Date MyDate( 7, 4, 1998 ); const Date BirthDate( 1, 18, 1953 ); MyDate.setMonth( 4 ); // Okay BirthDate.getMonth(); // Okay BirthDate.setMonth( 4 ); // C2662 Error >Различия C и C++ const
При определении переменной const в файле исходного кода C это делается так:
const int i = 2; Затем эту переменную можно использовать в другом модуле следующим образом:
extern const int i; Но чтобы получить такое же поведение в C++, необходимо определить const переменную следующим образом:
extern const int i = 2; Как и в C, эту переменную можно использовать в другом модуле следующим образом:
extern const int i; Если вы хотите определить extern переменную в файле исходного кода C++ для использования в файле исходного кода C, используйте следующее:
extern "C" const int x=10; для предотвращения изменения имени компилятором C++.
Замечания
При выполнении списка параметров функции-члена ключевое слово указывает, const что функция не изменяет объект, для которого он вызывается.
Дополнительные сведения const см. в следующих статьях:
- const указатели и volatile указатели
- Квалификаторы типов (справочник по языку C)
- volatile
- #define
Квалификатор const в С++
Квалификатор типов const (от анг. type qualifier) – зарезервированное ключевое слово в языке программирования С++, которое не даёт модифицировать значения переменных. Отсюда и возникло в программировании такое понятие, как константы или константные переменные, то есть неизменные. Необходимо запомнить, что при объявлении константы, её нужно инициализировать.
//Синтаксис объявления константы const /*тип данных*/ /*имя переменной*/ = /*инициализатор ( значение) */; // объявление константной переменной
Объявление константной переменной от обычной переменной отличается ключевым словом const , которое ставится перед типом данных объявляемой переменной. Рассмотрим фрагмент кода объявления константной переменной.
// объявление и инициализация константной переменной типа int с именем value const int value = 8;
Была объявлена константа целого типа с именем value и инициализирована значением 8. Если убрать инициализатор и откомпилировать программу, то компилятор выдаст ошибку похожую на эту (см. Рисунок 1).
Рисунок 1- Квалификатор const в С++
В зависимости от компилятора сообщение об ошибке может быть другим, но суть ошибки не поменяется. Данное сообщение было сгенерировано компилятором MVS2010. Компилятор сообщает, что константную переменную value необходимо инициализировать.
Допустим мы захотели изменить значение в константе value , для этого дописали ниже строку, в которой переменной value присваивается значение .
// попытка изменить значение в конста value const int value = 8; // объявление константы value = 16; // присваиваем константе value значение 16
В этом случае, компилятор сгенерирует сообщение (см. Рисунок 2).
Рисунок 2 — Квалификатор const в С++
Как видно из рисунка 2 нам не удалось изменить значение в переменной value . Вот в этом и заключается суть квалификатора const , а именно, как уже выше было сказано, квалификатор const не даёт модифицировать значение переменной, потому-то такие переменные и называются константами. Но всё это было предопределено, программистом, который писал этот фрагмент кода. То есть мы специально пытались перезаписать значение в переменной value , тогда какой смысл в квалификаторе const , если специально не пытаться изменить значение константы? А смысл такой, что квалификатор const предотвращает случайное изменение значений переменных. Случайное изменение значений не только возможно, но и трудно заметно. В итоге, программа сработала, а результат работы программы получился неправильный. Чаще всего случайное изменение значений переменных происходит из-за логических ошибок. Например, рассмотрим фрагмент кода, в котором есть скрытая логическая ошибка.
int value = 8; if (value = 1 ) // логическая ошибка в этой строке coutВ строке 1 объявлена, переменна целого типа, но не константная. В строке 2 проверяется условие в операторе условного выбора if else . От того какое условие, истинное или ложное, выполнится третья или пятая строка. Результат работы программы (см. Рисунок 3).
CppStudio.com
*
Для продолжения нажмите любую клавишу . . .Рисунок 3 — Квалификатор const в С++
Как видно из рисунка 3 условие оператора условного выбора if else истинно, так как напечаталась одна звёздочка. Хотя на первый взгляд кажется, что условие ложно. Так вот, дело в том, что в условии оператора if else вместо знака отношения == стоит знак присвоить. Переменной value присваивается значение 1. А как нам уже известно, что 1- это логическая истина. Если бы переменная value была объявлена как константа, то компилятор нам бы сразу сообщил о допущенной логической ошибке.
Когда пишутся большие программы, где тысячи строк кода, то такую ошибку будет очень сложно отследить. Таким образом, если нет необходимости изменять значение переменной, то лучше подстраховаться и объявить эту переменную как константу.
К сожалению, для данной темы пока нет подходящих задач. Если у вас есть таковые на примете, отправте их по адресу: admin@cppstudio.com. Мы их опубликуем!