Выражения и операторы

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

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

Операторы

В JavaScript есть следующие типы операторов. Данный подраздел описывает каждый тип и содержит информацию об их приоритетах друг над другом.

• Операторы присваивания
• Операторы сравнения
• Арифметические операторы
• Бинарные операторы
• Логические операторы
• Строчные операторы
• Условный(тернарный) оператор
• Оператор запятая
• Унарные операторы
• Операторы отношения

JavaScript поддерживает бинарные и унарные операторы, а также ещё один специальный тернарный оператор - условный оператор. Бинарная операция использует два операнда, один перед оператором и другой за ним:

operand1 operator operand2

Например: 3+4 или x*y.

В свою очередь унарная операция использует один операнд, перед или после оператора:

operator operand

или

operand operator

Например: x++ или ++x.

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

В результате операции присваивания операнду слева от оператора присваивания (знак = ) устанавливается значение , которое берётся из правого операнда. Основным оператором присваивания является  =, он присваивает значение правого операнда операнду находящемуся слева. Таким образом, выражение x = y означает, что x присваивается значение y.

Существуют также составные операторы присваивания, которые используются для сокращенного представления операций, описанных в следующей таблице:

Деструктуризация

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

var foo = ["one", "two", "three"];

// без реструктурирования
var one   = foo[0];
var two   = foo[1];
var three = foo[2];

// с реструктурированием
var [one, two, three] = foo;

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

Оператор сравнения сравнивает свои операнды и возвращает логическое значение, базируясь на равенстве или неравенстве значений операндов. Операнды могут быть числами, строками, логическими величинами или объектами. Строки сравниваются на основании стандартного лексикографического порядка, используя Unicode-значения. В большинстве случаев, если операнды имеют разный тип, JavaScript пробует преобразовать в тип подходящий для сравнения. Данный функционал обычно приводит к сравнению числовых операндов. Исключением из данного правила является сравнение с использованием операторов === и !==, которые производят строгое сравнение на равенство или неравенство. Эти операторы не делают попытки преобразовать операнды перед их сравнением на равенство. Следующая таблица описывает операторы сравнения в контексте следующего примера кода:

var var1 = 3, var2 = 4;

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

Арифметические операторы используют в качестве своих операндов числа (иногда строки или переменные других типов) и в качестве результата возвращают числовую величину. Стандартными арифметическими операторами являются сложение (+), вычитание (-), умножение (*), и деление (/). При работе с дробными числами эти операторы работают аналогично их работе в большинстве других языках программирования (обратите внимание, что деление на ноль возвращает бесконечность Infinity). Например:

console.log(1 / 2); /* возвращает 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */

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

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

Побитовые (поразрядные) операторы

Побитовые операторы обрабатывают свои операнды как последовательности из 32 бит (нулей и единиц), а не как десятичные, шестнадцатеричные или восьмеричные числа. Например, десятичное число 9 имеет двоичное представление 1001. Побитовые операторы выполняют операции над таким двоичным представлением, но результат возвращают как обычное числовое значение JavaScript.

Следующая таблица обобщает битовые операторы JavaScript.

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

Побитовые логические операторы

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

• Операнды преобразуются в 32-битные целые числа и представляются в виде последовательности бит (нулей и единиц). Числа, имеющие более 32 битов будут сокращены. Например, следующее число имеет больше 32 битов и сконвертируется в 32-х битное:

  До    : 11100110111110100000000000000110000000000001
  После :             10100000000000000110000000000001

• Каждый бит первого операнда связывается с соответствующим битом второго операнда: первый бит с первым битом, второй бит - со вторым, и так далее.
• К каждой паре бит применяется заданный оператор, и побитово формируется итоговый результат.

Например, двоичным представлением числа 9 является 1001, а двоичным представлением пятнадцати - 1111. Результаты применения к этим числам побитовых логических операторов выглядят следующим образом:

Обратите внимание, что все 32 бита преобразуются с использованием побитового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двойки).

Побитовые операторы сдвига

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

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

Операторы сдвига перечислены в следующей таблице.

Побитовые операторы сдвига

Логические операторы

Логические операторы обычно используются с булевыми (логическими) величинами; при этом возвращаемая ими величина также является булевой. Однако операторы && и || фактически возвращают величину одного из операндов, поэтому, если эти операторы используются с не булевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.

Примерами выражений, которые могут быть преобразованы в false являются те, значение которых равно null, 0, NaN, пустой строке (""), или undefined.

Следующий код демонстрирует примеры использования оператора && (логическое И).

var a1 =  true && true;     // t && t возвращает true
var a2 =  true && false;    // t && f возвращает false
var a3 = false && true;     // f && t возвращает false
var a4 = false && (3 == 4); // f && f возвращает false
var a5 = "Cat" && "Dog";    // t && t возвращает Dog
var a6 = false && "Cat";    // f && t возвращает false
var a7 = "Cat" && false;    // t && f возвращает false

Следующий код демонстрирует примеры использования оператора || (логическое ИЛИ).

var o1 =  true || true;     // t || t возвращает true
var o2 = false || true;     // f || t возвращает true
var o3 =  true || false;    // t || f возвращает true
var o4 = false || (3 == 4); // f || f возвращает false
var o5 = "Cat" || "Dog";    // t || t возвращает Cat
var o6 = false || "Cat";    // f || t возвращает Cat
var o7 = "Cat" || false;    // t || f возвращает Cat

Следующий код демонстрирует примеры использования оператора ! (логическое НЕ).

var n1 = !true;  // !t возвращает false
var n2 = !false; // !f возвращает true
var n3 = !"Cat"; // !t возвращает false

Проверка на "короткое замыкание"

Так как логические выражения вычисляются слева направо, они проверяются на возможность вычисления "короткого замыкания" с использованием следующих правил:

• false && anything - "короткое замыкание" с результатом false.
• true || anything - "короткое замыкание" с результатом true.

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

Строчные операторы

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

Например,

console.log("my " + "string");  // в консоли выведется строка  "my string".

Сокращенный оператор присваивания += также может быть использован для объединения строк. Например,

var  mystring = "alpha";  mystring += "bet"; // получается значение "alphabet" и присваивается mystring.

Условный (тернарный) оператор

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

condition ? val1 : val2

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

Например,

var status = (age >= 18) ? "adult" : "minor";

Данное выражение присваивает значение "adult" переменной status, если age имеет значение 18 или более. В противном случае переменной status присваивается значение "minor".

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

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

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

for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);

Унарные операторы

Унарная операция - операция только с одним операндом.

delete

Оператор delete выполняет удаление объекта, свойства объекта, или элемента массива с заданным индексом. Синтаксис оператора:

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // допустимо только внутри with

где objectName представляет собой имя объекта, property - свойство объекта, а index - целое число, указывающее на положение элемента в массиве.

Четвертый вариант использования оператора, позволяющий удалить свойство объекта, допустим только внутри with.

Вы можете использовать оператор delete для удаления переменных объявленных неявно, но вы не можете с его помощью удалять переменные объявленные с помощью утверждения var.

После применения оператора delete свойство элемента меняется на undefined. Оператор delete возвращает true если выполнение операции возможно; оператор возвращает false, если выполнение операции невозможно.

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // создаём свойство h
delete x;       // возвращает true (можно удалить переменную объявленную неявно)
delete y;       // возвращает false (нельзя удалить переменную объявленную с помощью var)
delete Math.PI; // возвращает false (нельзя удалить встроенные свойства)
delete myobj.h; // возвращает true (можно удалить пользовательские свойства)
delete myobj;   // возвращает true (можно удалить объект объявленный неявно)

Удаление элементов массива

Удаление элемента массива не влияет на длину массива. Например, если вы удалите a[3], элемент a[4] останется a[4], a[3] станет undefined.

Когда элемент массива удаляется с помощью оператора delete, то из массива удаляется значение данного элемента. В следующем примере элемент trees[3] удален с помощью оператора delete. Однако, элемент trees[3] остается адресуемым и возвращает значение undefined.

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // условие не выполняется
}

Если вы хотите, чтобы элемент оставался в массиве, но имел значение undefined, то используйте ключевое слово undefined вместо оператора delete. В следующем примере элементу trees[3] присвоено значение undefined, но элемент при этом остается в массиве:

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // данный блок кода выполняется
}

Оператор typeof

Оператор typeof используется любым из следующих способов:

1. typeof operand typeof (operand)
   

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

Предположим, вы определяете следующие переменные:

var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();

Оператор typeof возвращает следующие результаты для этих переменных:

typeof myFun;     // возвращает "function"
typeof shape;     // возвращает "string"
typeof size;      // возвращает "number"
typeof today;     // возвращает "object"
typeof dontExist; // возвращает "undefined"

Для дескрипторов true и null оператор typeof возвращает следующие результаты:

typeof true; // возвращает "boolean"
typeof null; // возвращает "object"

Для чисел и строк оператор typeof возвращает следующие результаты:

typeof 62;            // возвращает "number"
typeof 'Hello world'; // возвращает "string"

Для свойств оператор typeof возвращает тип величины данного свойства:

typeof document.lastModified; // возвращает "string"
typeof window.length;         // возвращает "number"
typeof Math.LN2;              // возвращает "number"

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

typeof blur;        // возвращает "function"
typeof eval;        // возвращает "function"
typeof parseInt;    // возвращает "function"
typeof shape.split; // возвращает "function"

Для встроенных объектов оператор operator возвращает следующие результаты:

typeof Date;     // возвращает "function"
typeof Function; // возвращает "function"
typeof Math;     // возвращает "object"
typeof Option;   // возвращает "function"
typeof String;   // возвращает "function"

Оператор void

Оператор void используется любым из следующих способов:

void (expression) void expression

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

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

Следующий код служит примером создания гипертекстовой ссылки, которая бездействует при нажатии на нее пользователем. Когда пользователь нажимает на ссылку, void(0) вычисляется равным undefined, что не приводит ни к каким действиям в JavaScript.

<A HREF="javascript:void(0)">Нажмите здесь, чтобы ничего не произошло</A>

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

<A HREF="javascript:void(document.form.submit())">
Нажмите здесь, чтобы подтвердить отправку формы</A>

Операторы отношения

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

Оператор in

Оператор in возвращает true, если указанный объект имеет указанное свойство. Синтаксис оператора:

propNameOrNumber in objectName

где propNameOrNumber - строка или числовое выражение, представляющее имя свойства или индекс массива, а objectName - имя объекта.

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

// Массивы
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // возвращает true
3 in trees;        // возвращает true
6 in trees;        // возвращает false
"bay" in trees;    // возвращает false (следует указать индекс элемента массива,
                   // а не значение элемента)
"length" in trees; // возвращает true (length является свойством объекта Array)

// Встроенные объекты
"PI" in Math;          // возвращает true
var myString = new String("coral");
"length" in myString;  // возвращает true

// Пользовательские объекты
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // возвращает true
"model" in mycar; // возвращает true

Оператор instanceof

Оператор instanceof возвращает true, если заданный объект является объектом указанного типа. Его синтаксис:

objectName instanceof objectType

где objectName - имя объекта, тип которого необходимо сравнить с objectType, а objectType - тип объекта, например, Date или Array.

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

Например, следующий код использует оператор instanceof для проверки того, является ли объект theDay объектом типа Date. Так как theDay действительно является объектом типа Date, то программа выполняет утверждения содержащиеся в утверждении if.

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // исполняемые утверждения
}

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

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

Приведенная ниже таблица описывает приоритет операторов от наивысшего до низшего.

Более подробная версия данной таблицы, содержащая ссылки и дополнительную информацию по каждому оператору, находится в справочнике JavaScript.

Выражения

Выражением является любой корректный блок кода, который имеет значение.

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

Выражение x = 7  является примером выражения первого типа. Данное выражение использует оператор = для присваивания переменной x значения 7. Само выражение также равняется 7.

Код 3 + 4 является примером выражения второго типа. Данное выражение использует  оператор + для сложения чисел 3 и 4 без присваивания переменной полученного результата 7.

Все выражения в JavaScript делятся на следующие категории:

• Арифметические: равны числу, например: 3.14159 (Используют арифметические операторы).
• Строчные:  равны текстовой строке, например: "Fred" или "234" (Используют строчные операторы).
• Логические:  равны true или false (Используют логические операторы).

• Основные выражения: Базовые ключевые слова и главные выражения в JavaScript.

• Левосторонние выражения: Значениям слева назначаются значения справа.

Основные выражения

Базовые ключевые слова и главные выражения в JavaScript.

Оператор this

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

this["propertyName"] this.propertyName

Предположим, функция validate выполняет проверку свойства value некоторого объекта при заданном объекте, а также верхней и нижней границе величины данного свойства:

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("Неверное значение!");
}

Вы можете вызвать функцию validate для обработчика событий onChange для каждого элемента формы, используя this для указания на элемент формы, как это показано в следующем примере:

<B>Введите число от 18 до 99:</B>
<INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);">

Оператор группировки

Оператор группировки ( ) контролирует порядок выполнения в выражениях. Например, вы можете переопределить порядок - умножение и деление, а потом сложение и вычитание, т.е. например, чтобы сложение выполнялось до умножения.

var a = 1;
var b = 2;
var c = 3;

// обычный порядок
a + b * c     // 7
// выполняется, как обычно, так
a + (b * c)   // 7

// теперь поменяем порядок
// сложение до умножения 
(a + b) * c   // 9

// что эквивалентно следующему
a * c + b * c // 9

Охваты

Охваты экспериментальная возможность JavaScript, которая будет добавлена в будущие версии ECMAScript. Есть 2 версии охватов:

[for (x of y) x]

Охваты массивов.

(for (x of y) y)

Охваты генераторов.

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

[for (i of [ 1, 2, 3 ]) i*i ]; 
// [ 1, 4, 9 ]

var abc = [ "A", "B", "C" ];
[for (letters of abc) letters.toLowerCase()];
// [ "a", "b", "c" ]

Левосторонние выражения

Значениям слева назначаются значения справа.

new

Вы можете использовать оператор new для создания экземпляра объекта пользовательского типа или одного из встроенных объектов. Используйте оператор new следующим образом:

var objectName = new objectType([param1, param2, ..., paramN]);

super

Ключевое слово используется, чтобы вызывать функции родителя объекта. Это полезно и с классами для вызова конструктора родителя, например.

super([arguments]); // вызывает конструктор родителя. super.functionOnParent([arguments]);

Оператор расширения

Оператор расширения позволяет выражению расширяться в местах с множеством аргументов (для вызовов функций) или множестве элементов (для массивов).

Пример: Сегодня, если у вас есть массив и вы хотите создать новый с существующей частью первого, синтаксиса литералов массива больше не достаточно и вы должны писать императивный код, используя комбинацию push, splice, concat и т.д. Но с этим оператором код становится более коротким:

var parts = ['shoulder', 'knees'];
var lyrics = ['head', ...parts, 'and', 'toes'];

Похожим образом оператор работает с вызовами функций:

function f(x, y, z) { }
var args = [0, 1, 2];
f(...args);