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

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

Операторы

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

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

operand1 operator operand2

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

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

operator operand operand operator

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

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

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

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

Список операторов присваивания Имя Сокращенный оператор Смысл

Присваивание	x = y	x = y
Присваивание со сложением	x += y	x = x + y
Присваивание с вычитанием	x -= y	x = x - y
Присваивание с умножением	x *= y	x = x * y
Присваивание с делением	x /= y	x = x / y
Присваивание по модулю	x %= y	x = x % y
Присваивание с левым сдвигом	x > y
Присваивание с беззнаковым сдвигом вправо	x >>>= y	x = x >>> y
Присваивание с побитовым AND	x &= y	x = x & y
Присваивание с побитовым XOR	x ^= y	x = x ^ y
Присваивание с побитовым OR	x |= y	x = x | y

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

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

Var foo = ["one", "two", "three"]; // без деструктуризации var one = foo; var two = foo; var three = foo; // с деструктуризацией var = foo;

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

Вы можете использовать оператор 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 , элемент a останется a, a станет undefined.

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

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

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

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

Оператор typeof

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

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

Var theDay = new Date(1995, 12, 17); if (theDay instanceof Date) { // выполняемый код }

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

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

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

Таблица 3.7 Приоритет операторов Тип оператора Операторы

свойство объекта	.
вызов, создание экземпляра объекта	() new
отрицание, инкремент	! ~ - + ++ -- typeof void delete
умножение, деление	* / %
сложение, вычитание	+ -
побитовый сдвиг	> >>>
сравнение, вхождение	< >= in instanceof
равенство	== != === !==
битовое-и	&
битовое-исключающее-или	^
битовое-или	|
логическое-и	&&
логическое-или	||
условный (тернарный) оператор	?:
присваивание	= += -= *= /= %= = >>>= &= ^= |=
запятая	,

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

Выражения

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

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

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

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

Все выражения в 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 для указания на элемент формы, как это показано в следующем примере:

Введите число от 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) y) Упрощенный синтаксис для генераторов.

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

) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; ; // [ "a", "b", "c" ]

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

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

new

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

Var objectName = new objectType();

super

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

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

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

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

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

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

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

Function f(x, y, z) { } var args = ; f(...args);

Выражения в JavaScript представляют собой комбинации операндов и операторов .

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

Рис. 1. Структура выражения в JavaScript

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

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

В зависимости от количества операндов различают следующие типы операторов:
унарный — в операции участвует один операнд;
бинарный — в операции участвуют два операнда;
тернарный — комбинирует три операнда.

Простейшая форма выражения — литерал — нечто, вычисляемое само в себя, например, число 100 , строка "Hellow world" . Переменная тоже может быть выражением, так как она вычисляется в присвоенное ей значение.

Выражения и операторы в JavaScript 1. Арифметические операторы

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

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

Таблица 1. Арифметические операторы Оператор/Операция Описание Приоритет

+ Сложение	Складывает числовые операнды. Если один из операндов — строка, то результатом выражения будет строка.	12
- Вычитание	Выполняет вычитание второго операнда из первого.	12
- Унарный минус	Преобразует положительное число в отрицательное, и наоборот.	14
* Умножение	Умножает два операнда.	13
/ Деление	Делит первый операнд на второй. Результатом деления может являться как целое, так и число с плавающей точкой.	13
% Деление по модулю (остаток от деления)	Вычисляет остаток, получаемый при целочисленном делении первого операнда на второй. Применяется как к целым числам, так и числам с плавающей точкой.	13

var x = 5, y = 8, z; z = x + y; // вернет 13 z = x - y; // вернет -3 z = - y; // вернет -8 z = x * y; // вернет 40 z = x / y; // вернет 0.625 z = y % x; // вернет 3 2. Операторы присваивания

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

var a = 5; // присваиваем переменной a числовое значение 5 var b = "hellow"; // сохраняем в переменной b строку hellow var m = n = z = 10; // присваиваем переменным m, n, z числовое значение 10 x += 10; // равнозначно x = x + 10; x -= 10; // равнозначно x = x - 10; x *= 10; // равнозначно x = x * 10; x /= 10; // равнозначно x = x / 10; x %= 10; // равнозначно x = x % 10; 3. Операторы инкремента и декремента

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

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* в результате вычислений вернет значение z = 12, x = 6, т.е. значение x сначала увеличивается на 1, а после выполняется операция умножения */ s = y++ * 2; /* в результате вычислений вернет значение s = 10, y = 6, т.е. сначала выполняется операция умножения, а после в переменной y сохраняется увеличенное на 1 значение */ k = --m * 2; // вернет значение k = 8, m = 4 l = n-- * 2; // вернет значение l = 10, n = 4 4. Операторы сравнения

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

Если оба операнда не могут быть успешно преобразованы в числа или строки, операторы всегда возвращают false .

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

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

Чаще всего операции сравнения используются при организации ветвлений в программах.

Таблица 4. Операторы сравнения Оператор/Операция Описание Приоритет

== Равенство	Проверяет две величины на совпадение, допуская преобразование типов. Возвращает true , если операнды совпадают, и false , если они различны.	9
!= Неравенство	Возвращает true , если операнды не равны	9
=== Идентичность	Проверяет два операнда на «идентичность», руководствуясь строгим определением совпадения. Возвращает true , если операнды равны без преобразования типов.	9
!== Неидентичность	Выполняет проверку идентичности. Возвращает true , если операнды не равны без преобразования типов.	9
> Больше	Возвращает true , если первый операнд больше второго, в противном случае возвращает false .	10
>= Больше или равно	Возвращает true , если первый операнд не меньше второго, в противном случае возвращает false .	10
	Возвращает true , если первый операнд меньше второго, в противном случае возвращает false .	10
	Возвращает true , если первый операнд не больше второго, в противном случае возвращает false .	10

5 == "5"; // вернет true 5 != -5.0; // вернет true 5 === "5"; // вернет false false === false; // вернет true 1 !== true; // вернет true 1 != true; // вернет false, так как true преобразуется в 1 3 > -3; // вернет true 3 >= "4"; // вернет false 5. Логические операторы

Логические операторы позволяют комбинировать условия, возвращающие логические величины. Чаще всего используются в условном выражении if .

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x > 0); // вернет true, если значение x принадлежит промежутку от 0 до 10 !false; // вернет true 6. Побитовые операторы

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

Таблица 6. Побитовые операторы Оператор/Операция Описание Приоритет

& Побитовый И	Если оба бита равны 1 , то результирующий бит будет равен 1 . В противном случае результат равен 0 .	8
| Побитовый ИЛИ	Если один из операндов содержит в позиции 1 , результат тоже будет содержать 1 в этой позиции, в противном случае результат в этой позиции будет равен 0 .	6
^ Исключающее ИЛИ	Если одно, и только одно значение содержит 1 в какой-либо позиции, то и результат будет содержать 1 в этой позиции, в противном случае результат в этой позиции будет равен 0 .	7
~ Отрицание	Выполняется операция побитового отрицания над двоичным представлением значения выражения. Любая позиция, содержащая 1 в исходном выражении, заменяется на 0 . Любая позиция, содержащая 0 в исходном выражении, становится равной 0 . Положительные числа начинаются с 0 , отрицательные - с -1 , поэтому ~ n == -(n+1) .	14
	Оператор сдвигает биты первого операнда влево на число битовых позиций, установленных вторым операндом. Для заполнения позиций справа используются нули. Возвращают результат того же типа, что левый операнд.	11
>> Побитовый сдвиг вправо	Оператор сдвигает биты первого операнда вправо на число битовых позиций, установленных вторым операндом. Цифры, сдвинутые за пределы диапазона, удаляются. Самый старший бит (32й) не меняется, чтобы сохранить знак результата. Если первый операнд положителен, старшие биты результата заполняются нулями; если первый операнд отрицателен, старшие биты результата заполняются единицами. Сдвиг значения вправо на одну позицию эквивалентен делению на 2 (с отбрасыванием остатка), а сдвиг вправо на две позиции эквивалентен делению на 4 и т. д.	11
>>> Побитовый сдвиг вправо без учета знака	Оператор сдвигает биты первого операнда вправо на число битовых позиций, установленных вторым операндом. Слева добавляются нули независимо от знака первого операнда. Цифры, сдвинутые за пределы диапазона, удаляются.	11

var x = 9, y = 5, z = 2, s = -5, result; // 9 эквивалентно 1001, 5 эквивалентно 0101 result = x & y; // вернет 1 (эквивалентно 0001) result = x | y; // вернет 13 (эквивалентно 1101) result = x ^ y; // вернет 12 (эквивалентно 1100) result = ~ y; // вернет -6 (эквивалентно 1100) result = x > z; // вернет 2 (эквивалентно 10) result = s >>> z; // вернет 1073741822 (эквивалентно 111111111111111111111111111110) 7. Строковые операторы

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

"1" + "10"; // вернет "110" "1" + 10; // вернет "110" 2 + 5 + " цветных карандашей"; // вернет "7 цветных карандашей" "Цветных карандашей " + 2 + 5; // вернет "Цветных карандашей 25" "1" > "10"; // вернет false "10" 10 ? x * 2: x / 2; // возвращает значение x * 2, если x > 10, в противном случае x / 2 9. Комментарии в JavaScript

Однострочный комментарий: перед текстом комментария нужно поставить символы // .

Сначала кратко про выражения в JavaScript.

Выражения JavaScript

В языке JavaScript есть инструкции и выражения.

Инструкции не возвращают значений.

Выражения всегда возвращают какие-то значения. Когда интерпритатор видит выражение, он вычисляет его значение и заменяет выражение его значением.

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

К простым выражениям относятся:

Идентификаторы: someVar (имя переменной);

Литералы: "строка" или 675 (число, или числовой литерал);

Некоторые ключевые слова, например this ;

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

Значение литерала будет таким, каким оно прописано в коде скрипта.

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

Чтобы объединить несколько простых выражений в одно сложное используется операторы.

Операторы бывают:

• Унарные (один операнд).
• Бинарные (два операнда).
• Тернарный оператор ? в JavaScript (три операнда, есть только один тернарный оператор).

Операнд - то простое выражение, к которому применяется оператор.

Например арифметический оператор сложения "+" является бинарным оператором. Он суммирует левый и правый операнд и возвращает сумму.

Var digit = 4 + 7;

Кстати, присваивание происходит при помощи оператора присваивания "=". Этот оператор вычисляет значение правого операнда и присваивает его левому операнду.

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

Var myVar = "7"; document.write(typeof(myVar) + "
"); // Напечатает в документе string myVar = +myVar; document.write(typeof(myVar) + "
"); // Напечатает в документе number

Сначала переменная myVar содержала строку "7", это литерал строкового типа (string), а не числового (number). При помощи оператора унарный плюс мы преобразовали строковой литерал в числовой.

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

Арифметические операции - это всем известные математические действия.

Возможно оператор % (остаток от деления) нуждается в пояснении. 9 делится на 5 с остатком 4, именно этот остаток и возвращает этот оператор. Также его называют взятием по модулю. При использовании целых чисел результат работы этого оператора также будет целое число. При оперировании числами с плавающей точкой результатом будет число с плавающей точкой.

5.5 % 2.2 = 1.1

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

• NaN (Not a Number) - не число.
• Infinity - бесконечность.

Вот к чему приведёт деление на ноль:

Var myVar = 0 / 0; document.write("Значение переменной: " + myVar + ", её тип: " + typeof(myVar) + "
");

Операции сравнения

Операции сравнения используются для сопоставления выражений. Выражение с условным оператором возвращает булево значение - истина или ложь (true / false).

Операции сравнения можно проводить и со строками, об этом речь будет в другом уроке. Единственное условие правильного результата - сопоставлять данные одного и того же типа. Иначе JavaScript попытается перевести данные из одного типа в другой, а это не всегда удаётся. Чтобы избежать ошибок сравнивайте данные только одного типа.

Операции присваивания

Наиболее очевидным примером операции присваивания является простое присваивание (=). Этот оператор (=) используется для присваивания значения переменной.

Но есть ещё ряд операций присваивания, которые являются сокращениями.

Логические операции

Логические операции часто используются с конструкцией if else в JS . Именно на примерах этой конструкции будет продемонстрирована их работа. Но сначала список логических операторов.

Теперь простые примеры:

If (true && true) document.write("Это работает!
"); if (true || false) document.write("Это работает!
"); if (!false) document.write("Это работает!
");

Разберём эти примеры:

Оператор логическое И (&&) вернёт истину, если оба операнда истины.

Оператор логическое ИЛИ (||) вернёт истину, если хоть один операнд является истиной.

Оператор логическое НЕ (!) принимает один операнд и изменяет значение истина/ложь на обратное.

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

Унарные операторы - это операторы с одним операндом. Вот несколько таких операторов:

• ++ - возрастание на 1 (increment). Может быть префиксное и постфиксное, об этом ниже.
• -- - уменьшение на 1 (decrement). Может быть префиксное и постфиксное, об этом тоже ниже.
• + - унарный плюс.
• - - унарный минус.

Унарный минус

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

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

Var myVar = -100; document.write(-myVar + " - унарный минус сработал, но переменная также = " + myVar + ".
"); myVar = -myVar; document.write("Теперь переменная = " + myVar + ".
");

Приведём безсмысленный пример двойного унарного минуса. Думаю в образовательных целях он будет полезен:

Var myVar = -100; document.write(--myVar + " - это инкремент, а не двойной унарный минус.
"); document.write("Теперь переменная = " + myVar + ".
"); document.write(-(-myVar) + " а это двойное применение унарного минуса.
");

Унарный плюс

Унарный плюс не совершает никаких математических действий. Он приводит литерал к числовому типу.

Var myVar = "78687"; document.write(typeof(myVar) + ".
"); myVar = +myVar; document.write(typeof(myVar) + ".
");

Инкремент и декремент

В программировании часто нужно увеличивать или уменьшать значение переменной на единицу. Для этого есть унарные операторы:

• ++ - возрастание на 1 (increment).
• -- - уменьшение на 1 (decrement).

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

Var myVar = 10; document.write(++myVar + ".
"); document.write(myVar + ".
");

Декремент (-- ) действует аналогично.

Теперь рассмотрим префиксное и постфиксное использование этих операторов.

• ++myVar - префиксное возрастание на 1.
• myVar++ - постфиксное возрастание на 1.

Разница такая:

• Префиксное использование этих операторов сначала вычисляет значение унарного оператора, а потом использует результат в выражении.
• Постфиксное использование сначала вычисляет выражение, а потом выполняет унарный оператор (++ или -- ).

В этом вам поможет разобраться простой пример:

Var myVar = 10; document.write((++myVar + 5) + ".

"); var myVar = 10; document.write((myVar++ + 5) + ".
"); document.write("Переменная = " + myVar + ".
");

Инкремент и декремент допускается использовать только с переменными, применять их к числовым литералам нельзя. Проще говоря код ++7 дас ошибку в сценарии.

Другие операторы

В языке JavaScript есть другие операторы:

• Тернарный (с тремя операндами) оператор

Оглавление документа

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

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

• Блок Операторов: { }

• Условные Операторы: if...else и switch

• Операторы Циклов: for, while, do...while, label, break и continue (label сам по себе не является оператором цикла, но часто используется с указанными операторами)

• Операторы Манипуляции Объектами: for...in и with

• Комментарии

• Операторы Обработки Исключений: try...catch и throw

Любое выражение также является оператором. См. в Главе 3 в разделе «Выражения и Операции» полную информацию об операциях.

Используйте символ «точка с запятой» (;) для разделения операторов в коде JavaScript.

См. в книге Ядро JavaScript. Справочник. детали об операторах из этой главы.

1. Блок операторов Блок операторов используется для группирования операторов. Блок ограничен фигурными скобками:

{ statement1 statement2 . . . statementn }

2. Условные операторы Условный оператор является набором команд, которые выполняются, если специфицированное условие - true . JavaScript поддерживает два условных оператора: if...else и switch .2.1. Оператор if...else Этот оператор используется для выполнения определённых операторов, если логическое условие true ; используйте необязательный блок else для выполнения других операторов, если условие false . Оператор if выглядит так:

if (condition ) { statements1 } [ else { statements2 } ]

Условие может быть любым выражением JavaScript, вычисляемым в true или false . Выполняемые операторы могут быть любыми операторами JavaScript, включая вложенные операторы if . Если Вам нужно выполнить более одного оператора после операторов if или else , вы обязаны заключить эти выполняемые операторы в фигурные скобки {}.

Вы не должны использовать простые присвоения в условном операторе. Например, НЕ используйте такой код:

Если Вам нужно использовать присвоение в условном операторе, введите дополнительные скобки вокруг операции присвоения. Например, if((x = y)) .

Не путайте примитивные Boolean -значения true и false со значениями true и false объекта Boolean . Любой объект, чьё значение не undefined , null , zero , **NaN** или пустая строка, включая объект Boolean со значением false , вычисляется в true , когда передаётся условному оператору. Например:

var b = new Boolean (false ) ; if (b ) // это условие вычисляется в true

Пример .

В этом примере функция checkData возвращает true , если количество символов в Text -объекте равно трём; иначе, выводит предупреждение и возвращает false .

function checkData () { if (document . form1 . threeChar . value . length == 3 ) { return true } else { alert (" Enter exactly three characters. " + document . form1 . threeChar . value + " is not valid. " ) return false } }

2.2. Оператор switch Оператор switch позволяет программе вычислять выражение и пытается сопоставить значение выражения значению в метке case. Если совпадение найдено, программа выполняет ассоциированный оператор. Оператор switch выглядит так:

switch (expression ){ case label : statement ; break ; case label : statement ; break ; ... default : statement ; }

Программа сначала ищет label , совпадающий со значением expression , а затем выполняет ассоциированный statement/оператор. Если совпадающий label не найден, программа ищет необязательный default statement /оператор по умолчанию и, если он найден, выполняет ассоциированный оператор. Если default statement не найден, программа продолжает выполнять оператор, следующий после конца оператора switch .

Необязательный оператор break , ассоциированный с меткой case label , гарантирует, что программа прервёт выполнение оператора switch , как только будет выполнен оператор найденного совпадения, и продолжит выполнение с оператора, идущего после оператора switch . Если break отсутствует, программа продолжает выполнение следующего оператора внутри оператора switch .

Пример .

Здесь, если expr вычисляется в “Bananas” , программа находит совпадение с case “Bananas” и выполняет ассоциированный оператор. Если обнаружен break , программа прерывает switch и выполняет оператор после блока оператора switch . Если break отсутствует, оператор в case “Cherries” также будет выполнен.

switch (expr ) { case " Oranges " : document . write (" Oranges are $0.59 a pound.
" ) ; break ; case " Apples " : document . write (" Apples are $0.32 a pound.
" ) ; break ; case " Bananas " : document . write (" Bananas are $0.48 a pound.
" ) ; break ; case " Cherries " : document . write (" Cherries are $3.00 a pound.
" ) ; break ; default : document . write (" Sorry, we are out of " + i + " .
" ) ; } document . write (" Is there anything else you"d like?
" ) ;

3. Операторы циклов Цикл/loop это набор операторов, который выполняется несколько раз, пока выполняется специфицированное условие. JavaScript поддерживает циклические операторы for , do...while и while , а также label (label сам по себе не является оператором цикла, но часто используется с указанными операторами). Кроме того, вы можете использовать операторы break и continue внутри операторов циклов.

Ещё один оператор цикла, for...in , также выполняет свои операторы циклически, но используется для работы с объектами. См. Операторы Манипуляции Объектами.

3.1. Оператор for Цикл for повторяется до тех пор, пока специфицированное значение false . Цикл JavaScript for похож на циклы for Java и C. Оператор for выглядит так:

for ([ initialExpression ] ; [ condition ] ; [ incrementExpression ]) { statements }

Когда цикл for выполняется, происходит следующее:

1. Инициализирующее выражение initialЕxpression , если имеется, выполняется. Это выражение обычно инициализирует один или более счётчиков цикла, и синтаксис разрешает выражения любой сложности. Это выражение также может объявлять переменные.

2. Вычисляется выражение condition/условное. Если значение condition - true , выполняются statements/операторы цикла. Если значение condition - false , цикл for прекращает работу. Если выражение condition полностью отсутствует, принимается, что condition - true.

3. Выполняются statements.

4. Обновляющее выражение incrementExpression , если имеется, выполняется, и управление возвращается к Шагу 2.

Пример .

Эта функция содержит оператор for , который подсчитывает количество выбранных опций в прокручиваемом списке (объект Select , позволяющий выбрать несколько позиций). Оператор for объявляет переменную i и инициализирует её в нуль. Он проверяет, меньше ли i количества опций объекта Select , выполняет оператор if и инкремент переменной i на единицу после каждого прохода цикла.

function howMany(selectObject) { var numberSelected=0; for (var i=0; i < selectObject.options.length; i++) { if (selectObject.options[i].selected==true) numberSelected++; } return numberSelected; }

Choose some music types, then click the button below:
R&B Jazz Blues New Age Classical Opera

3.2. Оператор do...while Оператор do...while повторяется, пока специфицированное выражение - false. Оператор do...while выглядит так:

do { statement } while (condition )

statement выполняется один раз перед проверкой условия/condition. Если condition - true , оператор выполняется снова. В конце каждого выполнения condition проверяется. Если condition - false , выполнение останавливается и управление передаётся оператору после do...while .

Пример.

В этом примере цикл do итерируется минимум один раз и повторяет итерации, пока i меньше 5 .

do { i += 1 ; document . write (i ) ; } while (i < 5 ) ;

3.3. Оператор while Оператор while выполняет свои операторы, пока специфицированное condition/условие - true . Оператор while выглядит так:

while (condition ) { statements }

Если condition становится false , операторы внутри цикла прекращают выполняться и управление передаётся оператору, следующему после цикла.

Проверка условия/condition происходит до выполнения операторов внутри цикла. Если condition возвращает true , операторы выполняются и condition проверяется снова. Если condition возвращает false , выполнение цикла прекращается и управление передаётся оператору, идущему после оператора while .

Пример 1.

Этот цикл while итерирует, пока n меньше 3 :

n = 0 ; x = 0 ; while (n < 3 ) { n ++; x += n ; }

При каждой итерации цикл увеличивает n и прибавляет это значение к переменной x . Следовательно, x и n принимают следующие значения:

• После первого прохода: n = 1 и x = 1

• После второго прохода: n = 2 и x = 3

• После третьего прохода: n = 3 и x = 6

После выполнения трёх проходов цикла, condition n < 3 больше не true, поэтому выполнение цикла прерывается.

Пример 2: Бесконечный цикл.

Убедитесь, что условие цикла когда-нибудь станет false ; иначе цикл никогда не прервётся. Операторы следующего цикла while выполняются бесконечно, поскольку условие никогда не станет false :

while (true ) { alert (" Hello, world " ) }

3.4. Оператор label Оператор label является идентификатором, на который можно ссылаться из любого места программы. Например, вы можете использовать label для идентификации цикла, а затем использовать операторы break или continue для прерывания цикла или продолжения выполнения.

Синтаксис оператора label выглядит так:

label : statement

Значением label может быть любой верный идентификатор JavaScript, не являющийся зарезервированным словом. Оператор/statement, идентифицируемый при помощи label , может быть любым оператором.

Пример.

В этом примере label markLoop идентифицирует цикл while .

markLoop : while (theMark == true ) doSomething () ; }

3.5. Оператор break Используйте оператор break для прерывания цикла switch или оператора с меткой label .

• Если вы используете break без label , он немедленно прерывает ближайший содержащий while , do-while , for или switch и передаёт управление следующему оператору.

• Если вы используете break с label , он прерывает специфицированный помеченный оператор.

Синтаксис оператора break таков:

1 . break 2 . break label

Первый вариант прерывает ближайший содержащий цикл или switch ; второй вариант прерывает специфицированный оператор, имеющий метку.

Пример .

Здесь выполняется итерация по элементам массива, пока не будет найден индекс элемента со значением theValue :

for (i = 0 ; i < a . length ; i ++ ) { if (a [ i ] = theValue ) break ; }

3.6. Оператор continue Оператор continue используется для рестарта операторов while , do-while , for и label .

• Если вы используете continue без label , он прерывает текущую итерацию ближайшего цикла while, do-while или for и продолжает выполнение этого цикла со следующей итерации. В отличие от оператора break, continue не прерывает выполнение цикла полностью. В цикле while он переходит на condition . В цикле for на increment-expression .

• Если вы используете continue с label , он применяется к оператору цикла, идентифицированному этим label .

Синтаксис оператора continue таков:

1 . continue 2 . continue label

Пример 1.

Это пример цикла while с оператором continue , который выполняется, если значение i равно 3 . Таким образом, n получает значения 1, 3, 7 и 12 .

i = 0 ; n = 0 ; while (i < 5 ) { i ++; if (i == 3 ) continue ; n += i ; }

Пример 2.

Оператор, помеченный как checkiandj , содержит оператор, помеченный как checkj . Если обнаружен continue , программа прерывает текущую итерацию checkj и начинает следующую итерацию. Каждый раз при обнаружении continue, checkj начинает итерацию вновь, пока его условие не возвратит false . Если возвращено false , выполняется оставшаяся часть оператора checkiandj и checkiandj реитерирует, пока его условие не возвратит false. Если возвращается false , программа продолжает выполняться с оператора, следующего после checkiandj .

Если continue имеет label для checkiandj , программа продолжит выполнение от начала оператора checkiandj .

checkiandj : while (i < 4 ) { document . write (i + "
" ) ; i += 1 ; checkj : while (j > 4 ) { document . write (j + "
" ) ; j -= 1 ; if ((j % 2 ) == 0 ) continue checkj ; document . write (j + " is odd.
" ) ; } document . write (" i = " + i + "
" ) ; document . write (" j = " + j + "
" ) ; }

4. Операторы манипуляции объектами JavaScript использует операторы for...in и with для манипулирования объектами.4.1. Оператор for...in Оператор for...in итерирует специфицированную переменную по всем свойствам объекта. Для каждого достигнутого свойства JavaScript выполняет специфицированные операторы. Оператор for...in выглядит так:

For (variable in object) {

Пример .

Эта функция принимает в качестве аргумента объект и имя объекта. Затем она итерирует по всем свойствам этого объекта и возвращает строку - список имён свойств и их значений.

function dump_props (obj , obj_name ) { var result = "" ; for (var i in obj ) { result += obj_name + " . " + i + " = " + obj [ i ] + "
" } result += " " ; return result ; }

Для объекта car со свойствами make и model результат будет таким:

car . make = Ford car . model = Mustang

4.2. Оператор with Оператор with устанавливает объект по умолчанию для набора блока операторов. JavaScript просматривает неквалифицированные имена внутри блока операторов и определяет, являются ли имена свойствами объекта по умолчанию. Если неквалифицированное имя является свойством, то это свойство используется в операторе; иначе, используется локальная или глобальная переменная.

Оператор with выглядит так:

with (object ){ statements }

Пример .

Здесь оператор with специфицирует, что объект Math является объектом по умолчанию. Операторы после оператора with обращаются к свойству PI и к методам cos и sin без специфицирования объекта. JavaScript принимает объект Math как объект для этих обращений.

var a , x , y ;; var r = 10 with (Math ) { a = PI * r * r ; x = r * cos (PI ) ; y = r * sin (PI / 2); }

Примечание :

Использование оператора with может значительно замедлить выполнение программы.

5. Комментарии Комментарии обычно разъясняют действия, выполняемые кодом. Комментарии игнорируются интерпретатором. JavaScript поддерживает комментарии в стиле Java и C++:

• Однострочный комментарий с двойным слэшем в начале строки (//).

• Многострочный комментарий с символами /* в начале и с символами */ в конце.

Пример.

Вот пример двух комментариев:

// Это однострочный комментарий. /* А это - многострочный. Он может быть любой длины, и вы можете поместить сюда всё, что угодно. */

6. Операторы обработки исключений Вы можете вызывать исключение оператором throw и обрабатывать его операторами try...catch .

Оператор try...catch используется также для обработки исключений Java. См. разделы «Обработка Исключений Java в JavaScript" и «Обработка Исключений JavaScript в Java».

6.1. Оператор throw Оператор throw используется для вызова исключения. Если вы вызываете исключение, вы специфицируете выражение, содержащее значение исключения:

throw expression

Следующий код вызывает несколько исключений.

throw " Error2 " ; // генерирует исключение со строковым значением throw 42 ; // генерирует исключение со значением 42 throw true ; // генерирует исключение со значением true

При вызове исключения вы можете специфицировать объект. Затем можно обратиться к свойствам объекта в блоке catch . Следующий пример создаёт объект myUserException типа UserException и использует его в операторе throw .

// Создаётся объект типа UserException function UserException (message ) { this . message = message ; this . name = " UserException " ; } // Создаётся и вызывается экземпляр объекта myUserException = new UserException (" Value too high " ) ; throw myUserException ;

6.2. Оператор try...catch Оператор try...catch помечает блок операторов, пытается их выполнить и специфицирует один или более вариантов ответа при возникновении исключения. Если исключение возникло, оператор try...catch отлавливает его.

Оператор try...catch состоит из блока try , который содержит один или более операторов, и нуль или более блоков catch , содержащих операторы, которые специфицируют действия при вызове исключения в блоке try . То есть, если вы хотите выполнить блок try и он не выполняется, вы передаёте управление в блок catch . Если любой оператор блока try (или оператор функции, вызываемой из блока try ) вызывает исключение, управление немедленно передаётся в блок catch . Если исключение не было вызвано, блок catch пропускается. Блок finally выполняется после выполнения блоков try и catch , но до выполнения оператора, идущего после блока оператора try...catch .

В следующем примере используется оператор try...catch . Вызывается функция, которая запрашивает название месяца из массива, базируясь на значении, передаваемом функции. Если значение не соответствует номеру месяца (1-12 ), вызывается исключение со значением «InvalidMonthNo" и операторы блока catch устанавливают переменную в monthName значение “unknown”.

function getMonthName (mo ) { mo = mo - 1 ; // Уточняется номер месяца по индексу массива (1=Jan, 12=Dec) var months = new Array (" Jan " , " Feb " , " Mar " , " Apr " , " May " , " Jun " , " Jul " , " Aug " , " Sep " , " Oct " , " Nov " , " Dec " ) ; if (months [ mo ] != null ) { return months [ mo ] } else { throw " InvalidMonthNo " } } try { // попытка выполнить эти операторы: monthName = getMonthName (myMonth ) // функция может вызвать исключение } catch (e ) { monthName = " unknown " logMyErrors (e ) // объект, вызвавший исключение, передаётся обработчику исключений }

throw ; вы можете использовать этот идентификатор для получения информации о вызванном исключении. JavaScript создаёт этот идентификатор при входе в блок catch ; идентификатор существует только в период выполнения блока catch ; после завершения выполнения блока catch идентификатор больше не доступен.

Например, следующий код вызывает исключение. Если возникает исключение, управление передаётся в блок catch .

try { throw " myException " // генерируется исключение } catch (e ) { // операторы для обработки любого исключения logMyErrors (e ) // исключение передаётся обработчику ошибок }

Несколько блоков catch

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

Например, следующая функция вызывает три другие функции (объявленные в другом месте), которые проверяют её аргументы. Если проверяющая функция определяет, что проверяемый компонент неверен, она возвращает 0, заставляя вызывающую функцию вызывать определённое исключение.

function getCustInfo (name , id , email ) { var n , i , e ; if (! validate_name (name )) throw " InvalidNameException " else n = name ; if (! validate_id (id )) throw " InvalidIdException " else i = id ; if (! validate_email (email )) throw " InvalidEmailException " else e = email ; cust = (n + " " + i + " " + e ) ; return (cust ) ; }

Условные блоки catch управляют вызовом соответствующего обработчика исключений.
" ) { // вызывает обработчик неправильных ids/идентификаторов bad_id_handler (e ) } catch (e if e == " InvalidEmailException " ) { // вызывает обработчик неправильных email-адресов bad_email_handler (e ) } catch (e ){ // незвестное исключение записывается в log-файл logError (e ) }

Блок finally

Блок finally содержит операторы, выполняемые после выполнения блоков try и catch , но до выполнения операторов, идущих после оператора try...catch . Блок finally выполняется независимо от того, было ли вызвано исключение. Если исключение вызывается, операторы блока finally выполняются даже в том случае, если ни один блок catch не обработал исключение.

Вы можете использовать блок finally для корректного завершения скрипта при возникновении исключения; например, Вам может понадобиться освободить ресурс, связанный скриптом. В следующем примере файл открывается и операторы работают с ним (серверный JavaScript даёт возможность доступа к файлам). Если вызывается исключение при открытом файле, блок finally закрывает файл до того, как скрипт потерпит неудачу.

openMyFile () ; try { writeMyFile (theData ) } finally { closeMyFile () // ресурс всегда закрывается }

Вложение операторов try...catch

Вы можете вкладывать один или более операторов try...catch друг в друга. Если внутренний оператор try...catch не имеет блока catch , на совпадение проверяется блок catch содержащего его оператора try...catch.