Главная » Переменные и строгий режим написания кода

Переменные и строгий режим написания кода


23.02.2021, 16:12
Строгий режим "use strict"

В 2009 году появился стандарт ECMAScript 5 (ES5), а вместе с ним появился так называемый "строгий режим" написания кода.

Что это значит?

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

ECMAScript 5 (ES5) добавил в язык новые возможности, но и внёс изменения в некоторые уже существующие. Чтобы устаревший код продолжал работать, по умолчанию новые изменения не применяются, и чтобы их начать использовать, используют директиву "use strict".

Директиву объявляют в начале кода в виде строки и тогда весь сценарий кода работает в "современном режиме":

Код

"use strict";

Можно не объявлять директиву для всего документа, а лишь для отдельных функций, для этого директиву объявляют в теле функции перед всеми другими операторами:

Код

function strict() {
  "use strict";
  alert('Функция в строгом режиме');
}

function noStrict() {
  alert('Функция в обычном режиме');
}

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

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

Переменные в JavaScript и способы их объявления

Использование так называемых переменных в JavaScript подразумевает использование имён (идентификаторов) для представления значений. Привязка имени к значению даёт нам возможность использовать его, ссылаясь на это значение.

Говорится так: объявляем переменную и присваиваем ей значение.

Объявление переменной в современном JavaScript (ES6 и последующие версии) делается с помощью ключевого слова let

Код

let number;

Значение переменной присваивается так (не путать с равенством)

Код

let number = 10;

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

Код

let a = 1, b = 3, c = 4;

При объявлении переменных можно использовать ранее объявленные переменные:

Код

let x = 2, y = x * x;

Если объявить переменную без начального значения, то её начальным значением будет undefined (не определено).

Само название "переменная" говорит о том, что значение её в ходе работы программы может неоднократно изменяться, причём может меняться и тип данных, хранящихся в переменной.

Изменим значение переменной number на другое, для этого уже не нужно объявлять переменную, это делается один раз вначале, теперь мы просто оперируем её именем

Код

let number = 10;
number = 'String';

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

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

Константа в JavaScript объявляется с помощью ключевого слова const

Код

const PI = 3.14;

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

Когда использовать let, а когда const?

Можно использовать две стратегии:

1. Использовать const только для глобальных значений, изменение которых не предвидится абсолютно (например, физические постоянные и т.д.)

2. Использовать const для объявления всего, а затем, при необходимости изменения какого-то значения, изменять const на let.

И всё же прямых констант в JavaScript нет, это можно увидеть на примере. Объявим константу и в качестве её значения укажем объект:

Код

const obj = {
  age: 20
};

пробуем изменить значение для свойства age объекта obj

Код

obj.age = 5;

выведем содержимое объекта в консоль:

Код

console.log(obj);

Смотрим результат в консоли:

[Running] node "c:\Users\psstu\Desktop\project\js\tempCodeRunnerFile.js"
{ age: 5 }

[Done] exited with code=0 in 0.319 seconds

Значение свойства age изменилось, а значит мы смогли изменить значение константы.

Объявление переменных с помощью ключевого слова var

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

Синтаксис var похож на синтаксис let:

Код

var number = 10;
number = 15;

У переменной, объявленной через var, есть одна особенность: она существует в коде ещё до её объявления, это явление называется hoisting (всплытие, подъём). Рассмотрим пример:

Код

console.log(number);
var number = 5;

Мы пытаемся вывести в консоль значение переменной number, которая ещё не объявлена (поскольку объявляется она строкой ниже), но при этом мы не получим ошибки, а получим значение undefined.

Это одна из причин, по которой от использования var отказались. В случае использования let в подобном примере вы получите ошибку, что логически верно, поскольку в современном стандарте языка переменная существует только после того, как она объявлена.

Другой причиной является то, что переменные, объявленные с помощью var, не имеют блочной области видимости. В отличие от let и const, которые видны только в блоке кода, ограниченном фигурными скобками.

Например, в данном коде мы получим ошибку, что переменная result не определена, поскольку не будем иметь доступа к переменной, находяйщейся в фигурных скобках:

Код

{
  let result = 5;
}

console.log(result);

Если заменить в этом коде let на var, то код без проблем выполнится, так как мы будем иметь доступ к переменной result

Код

{
  var result = 5;
}

console.log(result);

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

Деструктурирующее присваивание

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

В итоге, при деструктурирующем присваивании, из значения справа извлекаются (деструктурируются) значения и сохраняются в переменных, которые указаны в левой части.

Рассмотрим примеры:

Код

let [x, y] = [1, 2]; // то же, что и let x = 1, y = 2

Код

[x, y] = [x + 1, y + 1]; // то же, что и x = x + 1, y = y + 1

Код

[x, y] = [y, x]; // значения переменных меняются местами

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

Код

let [x, y] = [1]; // x == 1; y == undefined

Код

let [x, y] = [1, 2, 3]; // x == 1; y == 2

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

Код

let [, x, , y] = [1, 2, 3, 4] // x == 2; y == 4

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

Код

let [x, ...y] = [1, 2, 3, 4]; // x == 1; y == [2, 3, 4]

Деструктурирующее присваивание работает также с вложенными массивами, при этом в левой части должен быть синтаксис, похожий на вложенный литерал массива:

Код

let [a, [b, c] ] = [1, [2, 3], 4]; // a == 1; b == 2; c == 3;

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

Код

let [one, ...two] = "Meguiar's"; // one == M;  
  // two == [ 'e', 'g', 'u', 'i', 'a', 'r', " ' ", 's'];

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

Код

let bgColor = { r: 0, g: 0, b: 0, a: 1.0 }; /* цвет RGBA */
let {r, g, b} = bgColor; // r == 0; g == 0; b == 0;

Требования к именованию переменных

JavaScript - это регистрозависимый язык, поэтому одно и тоже имя переменной, записанное в разных сочетаниях регистра, даст совершенно разные переменные:

number, Number, NUMBER - это три разные переменные

Имя переменной (или по-другому идентификатор) должно начинаться с буквы, подчёркивания (_) или знака доллара ($)

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

Для имён переменных, состоящих из нескольких слов, используются стили:

camelCase
snake_case
kebab-case
PascalCase
UPPER_CASE_SNAKE_CASE

Негласное соглашение для JavaScript по использованию тех или иных стилей:

camelCase для переменных и методов.
PascalCase для типов и классов.
UPPER_CASE_SNAKE_CASE для констант.

КОММЕНТАРИИ (0)

РЕЙТИНГ МАТЕРИАЛА (0.0 / 0)