Как сделать переменную строкой js

Обновлено: 07.07.2024

Для создания строк мы можем как напрямую присваивать переменной или константе строку:

Для работы со строками предназначен объект String , поэтому также можно использовать конструктор String:

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

Объект String имеет большой набор свойств и методов, с помощью которых мы можем манипулировать строками.

Длина строки

Свойство length указывает на длину строки:

Повторение строки

Метод repeat() позволяет создать строку путем многократного повторения другой строки. Количество повторов передается в качестве аргумента:

Поиск в строке

Для поиска в строке некоторой подстроки используются методы indexOf() (индекс первого вхождения подстроки) и lastIndexOf() (индекс последнего вхождения подстроки). Эти методы принимают два параметра:

Подстроку, которую надо найти

Необязательный параметр, который указывает, с какого символа следует проводить поиск подстроки в строке

Оба этих метода возвращают индекс символа, с которого в строке начинается подстрока. Если подстрока не найдена, то возвращается число -1.

Еще один метод - includes() возвращает true, если строка содержит определенную подстроку.

С помощью второго дополнительного параметра можно определить индекс, с которого будет начинаться поиск подстроки:

Выбор подстроки

Для того, чтобы вырезать из строки подстроку, применяются методы substring() и slice() .

Substring

Метод substring() принимает два параметра:

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

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

slice

Еще один метод slice также позволяет получить из строки какую-то ее часть. Она принимает два параметра:

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

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

Можно заметить, что этот метод похож на метод substring() , тем не менее между ними есть небольшие различие. Прежде всего, в slice() начальный индекс должен быть меньше чем конечный. В substring() , если начальный индекс больше конечного, то они меняются местами (то есть substring(5, 1) будет равноценно substring(1, 5) ):

Другое отличие, что slice позволяет использовать отрицательные индексы. Отрицательный индекс указывает на индекс символа относительно конца строки. substring() же отрицательные индексы не поддерживает:

Управление регистром

Для изменения регистра имеются методы toLowerCase() (для перевода в нижний регистр) и toUpperCase() (для перевода в верхний регистр).

Получение символа по индексу

Чтобы получить определенный символ в строке по индексу, можно применять методы charAt() и charCodeAt() . Оба этих метода в качестве параметра принимают индекс символа:

Но если в качестве результата метод charAt() возвращает сам символ, то метод charCodeAt() возвращает числовой код этого символа.

Удаление пробелов

Для удаления начальных и концевых пробелов в стоке используется метод trim() :

Дополнительно есть ряд методов, которые удаляют пробелы с определенной стороны строки:

trimStart() : удаляет пробел с начала строки

trimEnd() : удаляет пробел с конца строки

trimLeft() : удаляет пробел с левой части строки

trimRight() : удаляет пробел с правой части строки

Объединение строк

Метод concat() объединяет две строки:

Замена подстроки

Метод replace() заменяет первое вхождение одной подстроки на другую:

Первый параметр метода указывает, какую подстроку надо заменить, а второй параметр - на какую подстроку надо заменить.

В то же время у этого метода есть одна особенность - он заменяет только первое вхождение подстроки:

Однако еще один метод - replaceAll() позволяет заменить все вхождения подстроки:

Разделение строки

Метод split() разбивает строку на массив подстрок по определенному разделителю. В качестве разделителя используется строка, которая передается в метод:

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

Проверка начала и окончания строки

Метод startsWith() возвращает true, если строка начинается с определенной подстроки. А метод endsWith() возвращает true, если строка оканчивается на определенную подстроку.

При этом играет роль регистр символов, и из примера выше мы видим, что "let" не эквивалентно "Let".

Дополнительный второй параметр позволяет указать индекс (для startsWith - индекс с начала, а для endsWith - индекс с конца строки), относительно которого будет производиться сравнение:

Зполнение строки

Методы padStart() и padEnd() растянуть строку на определенное количество символов и заполнить строку слева и справа соответственно.

Вызов "hello".padStart(8) будет рястягивать строку "hello" на 8 символов. То есть изначально в строке "hello" 5 символов, значит, к ней будет добавлено 3 символа. При чем они будут добавлено в начале строки. По умолчанию добавляемые символы представляют пробелы. Аналогично вызов "hello".padEnd(8) растянет строку на 8 символов, но оставшие символы в виде пробелов будут добавлены в конец строки.

По умолчанию эти методы используют пробелы для заполнения, но в качестве второго параметра мы можем передать методам значение, которым надо дополнить строку:

Если добавляемое количество символов больше добавляемой строки, то добавляемая строка повторяется:


Image by Daniel Dino-Slofer from Pixabay

Создание строк

По сути, в JavaScript есть две категории строк: строковые примитивы и объекты String.

Примитивы

Строковые примитивы создаются следующими способами:

Почти во всех случаях вы должны использовать один из этих методов для создания новой строки.

При определении строкового литерала можно использовать одинарные кавычки ( '' ) или двойные кавычки ( "" ).

Объекты

Вы можете создать объект String, используя ключевое слово new .

Единственное реальное преимущество объекта перед строковым примитивом состоит в том, что вы можете назначить ему дополнительные свойства:

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

Все знакомые вам методы строк являются частью объекта String, а не примитива.

Когда вы вызываете метод для строкового примитива, JavaScript оборачивает примитив в String-объект и вызывает метод этого объекта.

Шаблонные строки

Базовые шаблонные строки

Шаблонные строки позволяют объединять переменные и текст в новую строку с использованием более удобочитаемого синтаксиса.

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

Вы также можете включать выражения в шаблонные строки:

Сейчас браузеры очень хорошо поддерживают работу с шаблонными строками в JavaScript.

  • Chrome: 41+
  • Edge: 13+
  • Firefox: 34+
  • Safari: 9.1+
  • Opera: 29+

Вы также можете вкладывать шаблоны друг в друга, как показано в этом примере из MDN:

Теговые шаблоны

Теговые шаблоны позволяют создать функцию, которая парсит шаблонную строку.

Это может быть действительно мощным инструментом и наиболее наглядно демонстрируется на примере.

Представьте, что у нас есть функция censor() , которая удаляет любые оскорбительные слова в строке, введенной пользователем.

Когда мы хотим подвергнуть строку цензуре, мы можем вручную вызвать censor() для каждого введенного пользователем значения:

Или мы могли бы использовать теговые шаблоны.

Это позволяет нам написать функцию, которая принимает строковые значения из шаблонной строки и все выражения, используемые в шаблоне:

Это означает, что теперь мы можем управлять шаблонной строкой и значениями внутри неё.

Первым аргументом теговой функции всегда является массив строк. Остальные аргументы представляют каждую переменную / выражение, используемые в шаблонной строке.

Теперь у нас есть доступ к шаблонной строке и отдельным аргументам. Мы можем отслеживать каждую переменную, используемую в строке:

Наконец, наша теговая функция должна вернуть обработанную строку.

Для этого мы просто объединяем исходный массив строк и массив (измененных) входных данных в новый массив.

Здесь мы делаем это с помощью .reduce() :

Наша теговая функция теперь готова, и ее можно использовать везде, где нам нужно цензурировать вводимые пользователем данные:

Теговая функция не обязательно должна возвращать строку.

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

Raw-строки в JavaScript

String.raw — это предопределенная теговая функция.

Она позволяет вам получить доступ к строке без обработки каких-либо значений после обратного слэша.

Например, при использовании строки, содержащей \n со String.raw , вместо получения новой строки вы получите фактические символы \ и n:

Это может быть полезно (помимо прочего) для написания строк, в которых вам обычно приходится избегать большого количества символов обратного слэша, таких как пути к файлам:

При использовании string.raw символ \ экранирует последнюю обратную кавычку.

Это означает, что вы не можете заканчивать raw-строку символом \ следующим образом:

Объединение строк


Image by Rudy and Peter Skitterians from Pixabay

Конкатенация строк

Этот подход также можно использовать для разделения создания строки на несколько строк для удобства чтения:

Вы также можете объединять строки с переменными (нестроковые переменные будут преобразованы в строки):

Чтобы создать новую строку, добавив ее в конец существующей, используйте +=:

Вы также можете объединить строки и переменные с помощью метода string.concat(), но это не рекомендуется по соображениям производительности.

Вместо этого используйте операторы + или +=, как показано выше.

Повторение строки

Метод repeat() JavaScript возвращает новую строку, содержащую исходную строку, повторяющуюся несколько раз.

Вы можете использовать string.repeat() в следующих браузерах:

  • Chrome: 41+
  • Edge: 12+
  • Firefox: 24+
  • Safari: 9+
  • Opera: 28+

Объединение строк

Вы можете объединить массив строк в одну, используя метод .join() для массива.

По умолчанию элементы разделяются запятой:

Вы также можете указать строку, используемую для разделения элементов:

Передача пустой строки в string.join объединит элементы, между которыми ничего нет:

Когда toString() используется в массиве, он также возвращает список строк, разделенных запятыми.

Разделение строки

Вы можете разделить строку на массив с помощью метода split().

Типичные варианты использования:

Превращаем предложение в массив слов, разбивая его по пробелам:

…или разделение многострочной строки на отдельные строки:

Вы также можете ограничить количество элементов, которые вы хотите вернуть из split() , передав необязательный второй параметр.

В современных браузерах вместо этого можно использовать spread-оператор:

Сравнение строк

Равенство

Как вы знаете, что сравнивая два строковых примитива, вы можете использовать операторы == или ===:

Если вы сравниваете строковый примитив с чем-то, что не является строкой, == и === ведут себя по-разному.

При использовании оператора == не-строка будет преобразована в строку. Это означает, что JavaScript попытается преобразовать его в строку перед сравнением значений.

Для строгого сравнения, когда не-строки не приводятся к строкам, используйте ===:

То же самое верно и для операторов неравенства != и !==:

Если вы не знаете, что использовать, отдавайте предпочтение строгому равенству ===.

При использовании объектов String два объекта с одинаковым значением не считаются равными строками в JavaScript:

Чувствительность к регистру

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

Однако иногда вам нужно больше контроля над сравнением. Об этом в следующем разделе …

Работа с диакритическими знаками в строках JavaScript

Диакритические знаки — это модификации буквы, например é или ž.

Возможно вы захотите указать, как они обрабатываются при сравнении двух строк.

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

Если вам нужно сравнение без учета регистра, простое преобразование двух строк в один и тот же регистр с помощью toUpperCase() или toLowerCase() не будет учитывать добавление / удаление акцентов и может не дать ожидаемого результата.

Поддержка localeCompare() браузерами:

  • Chrome: 24+
  • Edge: 12+
  • Firefox: 29+
  • Safari: 10+
  • Opera: 15+

Больше / меньше

Это означает, что они сравниваются по буквам в том порядке, в котором они появляются в словаре:

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

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

True или false строки

Пустые строки в JavaScript считаются равными false при сравнении с использованием оператора == (но не при использовании ===).

Сортировка строк


Image by Iván Dequito from Pixabay

Простой Array.sort()

Самый простой способ отсортировать массив строк — использовать метод Array.sort() :

В Unicode заглавные буквы находятся перед строчными.

Это означает, что строки, начинающиеся с заглавной буквы, всегда находятся перед строками, начинающимися со строчных букв:

Вы можете избежать такого поведения, сначала преобразовав все строки в один и тот же регистр, или используя localeCompare (см. ниже), что обычно более эффективно.

localeCompare

Использование localeCompare в качестве функции сортировки позволяет сравнивать строки без учета регистра:

Многострочные строки

Вы можете добавлять новые строки, используя \n :

В шаблонной строке новые строки учитываются внутри обратных кавычек:

В шаблонных строках вы можете избежать разрывов строки, добавив \ в конце строки.

Отступы в строках

Вы можете добавить пробел в начало или конец строки, пока она не достигнет указанной длины, используя padStart() или padEnd() :

Вместо пробела вы можете дополнить целевую строку другой строкой, передав ее в качестве второго параметра.

Эта строка будет повторяться до тех пор, пока не будет достигнута целевая длина (строка будет обрезана, если она не помещается):

Поддержка padStart() и padEnd() браузерами::

  • Chrome: 57+
  • Edge: 15+
  • Firefox: 48+
  • Safari: 10+
  • Opera: 44+

Извлечение части строки

Подстроки

Эти методы принимают индекс первого символа, который вы хотите извлечь из строки.

Они возвращают все от этого символа до конца строки:

Второй (необязательный) аргумент — это символ, на котором вы хотите остановиться.

Этот последний символ не включается в вывод:

Итак, какой из них вы должны использовать?

Они очень похожи, но с небольшими отличиями:

Также существует метод substr() , похожий на slice() и substring() .

Это устаревший API. Хотя вряд ли он будет использоваться в ближайшее время, для работы со строками в JavaScript вам следует использовать один из двух вышеупомянутых методов, где это возможно.

Одиночные символы

Метод charAt() возвращает определенный символ из строки (помните, что индексы начинаются с 0):

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

Доступ к строке как к массиву может привести к путанице, когда строка хранится в переменной.

Использование charAt() более явное:

Изменение регистра строки в JavaScript

Вы можете сделать строку с заглавными буквами следующим образом:


Image by Iwona Olczyk from Pixabay

Или все в нижнем регистре, например:

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

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

Удаление пробелов

Следующие методы удаляют все пробелы, табуляции, неразрывные пробелы и символы окончания строки (например, \n ) из соответствующей части строки:

Однако на момент написания они не поддерживаются в браузере Edge.

Для совместимости во всех современных браузерах используйте trimLeft() и trimRight() :

Поиск текста в строке

Найти позицию подстроки

Вы можете искать строку внутри другой строки в JavaScript с помощью indexOf() .

Этот метод вернет позицию первого упоминания искомой подстроки в строке или -1, если подстрока не найдена:

Вы также можете использовать метод регулярных выражений search(), чтобы сделать то же самое:

Чтобы найти последнее вхождение поискового запроса, используйте lastIndexOf() :

Все эти методы вернут -1, если подстрока не найдена в целевой строке.

Начинается с / заканчивается на

Вы можете использовать методы indexOf() , указанные выше, чтобы проверить, начинается ли строка с поискового запроса или заканчивается им.

Однако ES6 добавил для этого специальные методы:

Поддержка startsWith() и endsWith() браузерами:

  • Chrome: 41+
  • Edge: 12+
  • Firefox: 17+
  • Safari: 9+
  • Opera: 28+

Includes

Если вам не важна конкретная позиция подстроки и важно только, находится ли она вообще в целевой строке, вы можете использовать includes() :

Поддержка includes() браузерами:

  • Chrome: 41+
  • Edge: 12+
  • Firefox: 40+
  • Safari: 9+
  • Opera: 28+

Регулярные выражения

Чтобы найти первое совпадение регулярного выражения, используйте .search() .

Чтобы вернуть массив, содержащий все совпадения регулярного выражения, используйте match() с модификатором /g (global):

(Использование match() без модификатора /g вернет только первое совпадение и некоторые дополнительные свойства, такие как индекс результата в исходной строке и любые именованные группы захвата).

Если вам нужна дополнительная информация о каждом совпадении, включая их индекс в исходной строке, вы можете использовать matchAll .

Этот метод возвращает итератор, поэтому вы можете использовать цикл for … of для результатов. Вы должны использовать регулярное выражение с модификатором /g/ в matchAll() :

Замена символов в строке

Вы можете использовать replace() для замены определенного текста в строке.

Первый аргумент replace() — это текст, который нужно найти и заменить, второй — текст, которым его нужно заменить.

Передача строки в качестве первого аргумента заменяет только первое совпадение:

Если вы хотите заменить все совпадения, вы можете передать регулярное выражение с модификатором ‘greedy’ ( /g ) в качестве первого аргумента:

В JavaScript значения достаточно свободно (явно и неявно) могут быть преобразованы из одного типа в другой. Например, если какой-нибудь оператор ожидает получить значение определённого типа, а ему передаётся значение другого типа, то интерпретатор автоматически попытается выполнить преобразования к нужному типу:

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

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

Для явного преобразования в простые типы используются следующие функции: Boolean() , Number() , String() . При неявном преобразования интерпретатор использует те же функции, что используются для явного преобразования.

Для явного преобразования можно использовать операторы вместо функций. Например, если один из операндов оператора + является строкой, то другой операнд также преобразуется в строку. Унарный оператор + преобразует свой операнд в число. Унарный оператор ! преобразует операнд в логическое значение и инвертирует его. Всё это стало причиной появления следующих своеобразных способов преобразования типов, которые можно встретить на практике:

Преобразование в числа

Функция Number() преобразует значения по следующим правилам:

  • Логические значения true и false преобразуются в 1 и 0 соответственно.
  • Числа возвращаются без изменения.
  • Значение null преобразуется в 0 .
  • Значение undefined преобразуется в NaN .

Для строк действуют особые правила:

  • Если строка содержит только цифры с начальным знаком + или - либо без знака, она всегда преобразуется в целое десятичное число. Начальные нули игнорируются, например "0011" преобразуется в 11.
  • Если строка представляет собой число с плавающей точкой с начальным знаком + или - либо без знака, она преобразуется в соответствующее число с плавающей точкой (начальные нули также игнорируются).
  • Если строка представляет собой число в шестнадцатеричном формате, она преобразуется в соответствующее целое десятичное число.
  • Если строка пустая, она преобразуется в 0 .
  • Если строка содержит что-то отличное от предыдущих вариантов, она преобразуется в NaN .
  • Для объектов вызывается метод valueOf() , а возвращаемое им значение автоматически преобразуется по предыдущим правилам. Если это преобразование даёт в результате NaN , вызывается метод toString() и применяются правила преобразования строк в числа.

Унарные операторы + и - работают по тем же правилам, что и функция Number() .

Преобразование в булевы значения

Функция Boolean() преобразует значение в его логический эквивалент:

  • Следующие значения в результате преобразования дают значение false : undefined , null , 0 , -0 , NaN , "" .
  • Значение false возвращается без изменения.
  • Все остальные значения в результате преобразования дают значение true .

Преобразование в строки

Функция String() преобразует значения по следующим правилам:

  • Для всех значений кроме null и undefined автоматически вызывается метод toString() и возвращается строковое представление значения.
  • Для значения null возвращается строка "null" .
  • Для значения undefined возвращается строка "undefined" .

Преобразование простых типов в объекты

Для преобразования простых значений в объекты используются конструкторы Boolean() , Number() , String() :

Преобразование объектов в простые значения

Все объекты наследуют два метода преобразования: toString() и valueOf() .

Метод toString() возвращает строковое представление объекта. По умолчанию он ничего интересного не возвращает:

Некоторые типы имеют более специализированные версии метода toString() . Например, метод toString() у массива преобразует все его элементы в строки и затем объединяет их в одну строку, вставляя запятые между ними:

Задача метода valueOf() определена не так чётко: предполагается, что он должен преобразовать объект в представляющее его простое значение, если такое значение существует. Объекты по своей сути являются составными значениями, и большинство объектов не могут быть представлены в виде единственного простого значения, поэтому по умолчанию метод valueOf() возвращает не простое значение, а ссылку на него:

При преобразовании объекта в строку интерпретатор JavaScript выполняет следующие действия:

  • Если объект имеет метод toString() , интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует значение в строку (если оно не является строкой) и возвращает результат преобразования.
  • Если объект не имеет метода toString() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода valueOf() . Если этот метод определён, интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует это значение в строку (если оно не является строкой) и возвращает результат преобразования.
  • В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

При преобразовании объекта в число интерпретатор выполняет те же действия, но первым пытается применить метод valueOf() :

  • Если объект имеет метод valueOf() , возвращающий простое значение, интерпретатор преобразует (при необходимости) это значение в число и возвращает результат.
  • Если объект не имеет метода valueOf() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода toString() . Если объект имеет метод toString() , возвращающий простое значение, интерпретатор выполняет преобразование и возвращает полученное значение.
  • В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

Методы toString() и valueOf() доступны для чтения и записи, поэтому их можно переопределить и явно указать, что будет возвращаться при преобразовании:

Переменная — это хранилище, в котором можно держать данные. Переменные похожи на именновые контейнеры — имена можно использовать для доступа к хранимым данным.

В коде ниже переменная num — это контейнер, в котором хранится значение 5 . Чтобы использовать или изменить значение переменной num , понадобится ее имя.

Как объявить переменную

Прежде чем использовать переменную, ее необходимо создать или иначе — объявить. В JavaScript для этого используют два ключевых слова: var и let . Оба они создают переменную.

В чем разница между var и let

Разница между объявлением переменной через var и let существует. Если сейчас она не очень понятна, не переживайте: мы обсудим эту тему позже на более глубоком уровне.

var let
используется в более старых версиях JavaScript новый способ объявляения переменных начиная с ES6 (ES2015)
создает переменную функциональной области видимости создает переменную блочной области видимости

Примечание. Мы рекомендуем использовать let для объявления переменных, но некоторые браузеры не поддерживают это ключевое слово. Проверить, где работает let, можно на странице JavaScript let browser support.

Как инициализировать переменную

После создания переменной в нее можно поместить данные — этот процесс называется инициализацией переменной. Для инициализации используют оператор присваивания = .

В этом коде мы присвоили значение 5 переменной x .

Переменную можно инициализировать и прямо при объявлении:

В JavaScript можно объявлять и инициализировать сразу несколько переменныз на одной строке:

Если переменную не инициализировать, в ней будет хранится значение undefined . Подробнее о том, что это значит, мы расскажем в будущих статьях.

В этом примере мы объявляем переменную x , но не инициализируем ее. Если вывести значение переменной x на экран, мы увидим undefined .

Как изменить значение переменной

Значение, которое хранится в переменной, можно изменить.

Переменная называется так именно потому, что ее значение может меняться.

Правила именования переменных

1. Имена переменных должны начинаться или с буквы, или с подчеркивания _ , или со знака доллара $ .

2. Имена переменных не могут начинаться с цифры.

3. JavaScript чувствителен к регистру, поэтому y и Y — разные переменные.

4. Нельзя использовать ключевые слова в качестве имени переменной.

Совет 1. Вы можете называть переменные как угодно, но лучше стараться давать переменным имя, которое описывает данные, которые в ней хранятся. Если вы используете переменную для хранения количества яблок, лучше использовать apples или numberOfApples , а не просто x или n .

Совет 2. В JavaScript имена переменных обычно пишут в camelCase, если они состоят из нескольких слов. Например, firstName , annualSalary и т.д.

Константы в JS

Для создания констант в JavaScript используют ключевое слово const .

Константы инициализируется сразу после объявления. Менять значение константы позже уже нельзя.

Примечание. const , как и let , появилось в JS только в ES6(ES2015), поэтому в старых версиях может быть недоступно. Узнать, поддерживает ли конкретный браузер const можно на странице JavaScript const browser support.

Совет. Константы стоит использовать, если вы уверены, что значение переменной не будет меняться на протяжении всей программы.

Теперь, когда вы знаете о переменных и константах, приступим к изучению типов данных, которые они могут хранить.

Читайте также: