++r;
При выполнении этого выражения в переменной r окажется ее значение, увеличенное на единицу. А если записать вот так:
s = ++r;
то значение r, увеличенное на единицу, будет помещено еще и в переменную s.
Операторы инкремента и декремента можно ставить как перед операндом, так и после него. Если оператор инкремента стоит перед операндом, то значение операнда сначала увеличивается на единицу, а уже потом используется в дальнейших вычислениях. Если же оператор инкремента стоит после операнда, то его значение сначала вычисляется, а уже потом увеличивается на единицу. Точно так же ведет себя оператор декремента.
Бинарные операторы всегда имеют два операнда и помещают результат в третью переменную. Вот примеры выражений с бинарными операторами:
l = r * 3.14;
f = e / 2;
x = x + t / 3;
Оператор объединения строк
Оператор объединения строк + позволяет соединить две строки в одну. Например, сценарий:
s1 = "Java";
s2 = "Script";
s = s1 + s2;
поместит в переменную s строку JavaScript.
Операторы присваивания
Оператор присваивания = нам уже знаком. Его еще называют оператором простого присваивания, поскольку он просто присваивает переменной новое значение:
a = 2;
b = c = 3;
Второе выражение в приведенном примере выполняет присвоение значения 3 сразу двум переменным — b и c.
JavaScript также поддерживает операторы сложного присваивания, позволяющие выполнять присваивание одновременно с другой операцией:
a = a + b;
a += b;
Два этих выражения эквивалентны по результату. Просто во втором указан оператор сложного присваивания +=.
Все операторы сложного присваивания, поддерживаемые JavaScript, и их эквиваленты приведены в табл. 14.3.
Таблица 14.3. Операторы сложного присваивания
Операторы сравнения
Операторы сравнения сравнивают два операнда согласно определенному условию и выдают (или, как говорят программисты, возвращают) логическое значение. Если условие сравнения выполняется, возвращается значение true, если не выполняется — false.
Все поддерживаемые JavaScript операторы сравнения приведены в табл. 14.4.
Пример:
a1 = 2 < 3;
a2 = -4 > 0;
a3 = r < t;
Переменная a1 получит значение true (2 меньше 3), переменная a2 — значение false (число –4 по определению не может быть больше нуля), а значение переменной a3 будет зависеть от значений переменных r и t.
Можно сравнивать не только числа, но и строки:
a = "JavaScript"!= "Java";
Переменная a получит значение true, т. к. строки "JavaScript" и "Java" не равны.
На двух последних операторах из табл. 14.4 — "строго равно" и "строго не равно" — нужно остановиться подробнее. Это операторы так называемого строгого сравнения. Обычные операторы "равно" и "не равно", если встречают операнды разных типов, пытаются преобразовать их к одному типу (о преобразованиях типов см. далее в этой главе). Операторы строгого равенства и строгого неравенства такого преобразования не делают, а в случае несовпадения типов операндов всегда возвращают false.
Пример:
a1 = 2 == "2";
a2 = 2 === "2";
Переменная a1 получит значение true, т. к. в процессе вычисления строка "2" будет преобразована в число 2, и условие сравнение выполнится. Но переменная a2 получит значение false, т. к. сравниваемые операнды принадлежат разным типам.
Логические операторы
Логические операторы выполняют действия над логическими значениями. Все они приведены в табл. 14.5. А в табл. 14.6 и 14.7 показаны результаты выполнения этих операторов.
Основная область применения логических операторов — выражения сравнения (о них см. далее в этой главе). Приведем примеры таких выражений:
a = (b > 0) && (c + 1!= d);
flag =!(status = 0);
Таблица 14.5. Логические операторы
Таблица 14.6. Результаты выполнения операторов И и ИЛИ
Таблица 14.7. Результаты выполнения оператора НЕ
Оператор получения типа typeof
Оператор получения типа typeof возвращает строку, описывающую тип данных операнда. Операнд, тип которого нужно узнать, помещают после этого оператора и заключают в круглые скобки:
s = typeof("str");
В результате выполнения этого выражения в переменной s окажется строка "string", обозначающая строковый тип.
Все значения, которые может вернуть оператор typeof, перечислены в табл. 14.8.
Таблица 14.8. Значения, возвращаемые оператором typeof
Совместимость и преобразование типов данных
Настала пора рассмотреть еще два важных вопроса: совместимость типов данных и преобразование одного типа к другому.
Что получится, если сложить два числовых значения? Правильно — еще одно числовое значение. А если сложить число и строку? Трудно сказать… Тут JavaScript сталкивается с проблемой несовместимости типов данных и пытается сделать эти типы совместимыми, преобразуя один из них к другому. Сначала он пытается преобразовать строку в число и, если это удается, выполняет сложение. В случае неудачи число будет преобразовано в строку, и две полученные строки будут объединены. Например, в результате выполнения Web-сценария из листинга 14.6 значение переменной b при сложении с переменной a будет преобразовано в числовой тип; таким образом, переменная c будет содержать значение 23.
Листинг 14.6
var a, b, c, d, e, f;
a = 11;
b = "12";
c = a + b;
d = "JavaScript";
e = 2;
f = d + e;
Но поскольку значение переменной d нельзя преобразовать в число, значение e будет преобразовано в строку, и результат — значение f — станет равным "JavaScript2".
Логические величины преобразуются либо в числовые, либо в строковые, в зависимости от конкретного случая. Значение true будет преобразовано в число 1 или строку "1", а значение false — в 0 или "0". И наоборот, число 1 будет преобразовано в значение true, а число 0 — в значение false. Также в false будут преобразованы значения null и undefined.
Видно, что JavaScript изо всех сил пытается правильно выполнить даже некорректно написанные выражения. Иногда это получается, но чаще все работает не так, как планировалось, и, в конце концов, выполнение Web-сценария прерывается в связи с обнаружением ошибки совсем в другом его месте, на абсолютно верном операторе. Поэтому лучше не допускать подобных казусов.
Приоритет операторов
Последний вопрос, который мы здесь разберем, — приоритет операторов. Как мы помним, приоритет влияет на порядок, в котором выполняются операторы в выражении.
Пусть имеется следующее выражение:
a = b + c — 10;
В этом случае сначала к значению переменной b будет прибавлено значение c, а потом из суммы будет вычтено 10. Операторы этого выражения имеют одинаковый приоритет и поэтому выполняются строго слева направо.
Теперь рассмотрим такое выражение:
a = b + c * 10;
Здесь сначала будет выполнено умножение значения c на 10, а уже потом к полученному произведению будет прибавлено значение b. Оператор умножения имеет больший приоритет, чем оператор сложения, поэтому порядок "строго слева направо" будет нарушен.
Самый низкий приоритет у операторов присваивания. Вот почему сначала вычисляется само выражение,
