Основные операторы

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

Термины: «унарный», «бинарный», «операнд»

У операторов есть своя терминология, которая используется во всех языках программирования.

• Операнд — то, к чему применяется оператор. Например: 5 * 2 — оператор умножения с левым и правым операндами. Другое название: «аргумент оператора».
• Унарным называется оператор, который применяется к одному выражению. Например, оператор унарный минус "-" меняет знак числа на противоположный:

   

     

  1	var x = 1;

  2	alert( -x );     // -1, унарный минус

  3	alert( -(x+2) ); // -3, унарный минус применен к результату сложения x+2

  4	alert( -(-3) );  // 3

   

• Бинарным называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:

   

     

  1	var x = 1, y = 3;

  2	alert( y - x ); // 2, бинарный минус

   

Работа унарного "+" и бинарного "+" в JavaScript существенно различается.

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

Арифметические операторы

Базовые арифметические операторы знакомы нам с детства: это плюс +, минус -, умножить *, поделить /.

Например:

Или чуть сложнее:

Более редкий арифметический оператор % интересен тем, что никакого отношения к процентам не имеет. Его результат a % b — это остаток от деления a на b.

Например:

Сложение строк, бинарный +

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

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

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

Это приведение к строке — особенность бинарного оператора "+".

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

Например:

Унарный плюс +

Унарный плюс как арифметический оператор ничего не делает:

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

Тем не менее, он широко применяется, так как его «побочный эффект» — преобразование значения в число.

Например, у нас есть два числа, в форме строк, и нужно их сложить. Бинарный плюс сложит их как строки, поэтому используем унарный плюс, чтобы преобразовать к числу:

Присваивание

Оператор присваивания выглядит как знак равенства =:

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

В строке (*) сначала произойдет вычисление, использующее текущее значение a (т.е. 1), после чего результат перезапишет старое значение a.

Возможно присваивание по цепочке:

Такое присваивание работает справа-налево, то есть сначала вычислятся самое правое выражение2+2, присвоится в c, затем выполнится b = c и, наконец, a = b.

Приоритет

В том случае, если в выражении есть несколько операторов - порядок их выполнения определяетсяприоритетом.

Из школы мы знаем, что умножение в выражении 2 * 2 + 1 выполнится раньше сложения, т.к. егоприоритет выше, а скобки явно задают порядок выполнения. Но в JavaScript — гораздо больше операторов, поэтому существует целая таблица приоритетов.

Она содержит как уже пройденные операторы, так и те, которые мы еще не проходили. В ней каждому оператору задан числовой приоритет. Тот, у кого число меньше — выполнится раньше. Если приоритет одинаковый, то порядок выполнения — слева направо.

Отрывок из таблицы:

Посмотрим на таблицу в действии.

В выражении x = 2 * 2 + 1 есть три оператора: присвоение =, умножение * и сложение +. Приоритет умножения * равен 5, оно выполнится первым, затем произойдет сложение +, у которого приоритет 6, и после них — присвоение =, с приоритетом 17.

Инкремент/декремент: ++, --

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

Для этого существуют даже специальные операторы:

• Инкремент ++ увеличивает на 1:
     

  1	var i = 2;

  2	i++;      // более короткая запись для i = i + 1.

  3	alert(i); // 3

• Декремент -- уменьшает на 1:
     

  1	var i = 2;

  2	i--;      // более короткая запись для i = i - 1.

  3	alert(i); // 1

Вызывать эти операторы можно не только после, но и перед переменной: i++ (называется «постфиксная форма») или ++i («префиксная форма»).

Обе эти формы записи делают одно и то же: увеличивают на 1.

Тем не менее, между ними существует разница. Она видна только в том случае, когда мы хотим не только увеличить/уменьшить переменную, но и использовать результат в том же выражении.

Например:

В строке (*) вызов ++i увеличит переменную, а затем вернет ее значение в a. То есть, в a попадет значение i после увеличения.

Постфиксная форма i++ отличается от префиксной ++i тем, что возвращает старое значение, бывшее до увеличения.

В примере ниже в a попадет старое значение i, равное 1:

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

  1	var i = 0;

  2

  i++;

  3

  ++i;

  4	alert(i); // 2

• Если хочется тут же использовать результат, то нужна префиксная форма:
     

  1	var i = 0;

  2	alert( ++i ); // 1

• Если нужно увеличить, но нужно значение переменной до увеличения — постфиксная форма:
     

  1	var i = 0;

  2	alert( i++ ); // 0

Инкремент/декремент можно использовать в любых выражениях.

При этом он имеет более высокий приоритет и выполняется раньше, чем арифметические операции:

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

Побитовые операторы

Побитовые операторы рассматривают аргументы как 32-разрядные целые числа и работают на уровне их внутреннего двоичного представления.

Эти операторы не являются чем-то специфичным для JavaScript, они поддерживаются в большинстве языков программирования.

Поддерживаются следующие побитовые операторы:

• AND(и) ( & )
• OR(или) ( | )
• XOR(побитовое исключающее или) ( ^ )
• NOT(не) ( ~ )
• LEFT SHIFT(левый сдвиг) ( << )
• RIGHT SHIFT(правый сдвиг) ( >> )
• ZERO-FILL RIGHT SHIFT(правый сдвиг с заполнением нулями) ( >>> )

Вы можете более подробно почитать о них в отдельной статье Побитовые операторы.

Вызов операторов с присваиванием

Часто нужно применить оператор к переменной и сохранить результат в ней же, например:

Эту запись можно укоротить при помощи совмещенных операторов:+=, -=, *=, /=, >>=, <<=, >>>=, &=, |=, ^=.

Вот так:

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

Оператор запятая

Запятая тоже является оператором. Ее можно вызвать явным образом, например:

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

Запятая — единственный оператор, приоритет которого ниже присваивания. В выражении a = (5,6)для явного задания приоритета использованы скобки, иначе оператор '=' выполнился бы до запятой',', получилось бы (a=5), 6.

Зачем же нужен такой странный оператор, который отбрасывает значения всех перечисленных выражений, кроме последнего?

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

Такие трюки используются во многих JavaScript-фреймворках для укорачивания кода.