Все поддерживаемые 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. Оператор умножения имеет больший приоритет, чем оператор сложения, поэтому порядок "строго слева направо" будет нарушен.
Самый низкий приоритет у операторов присваивания. Вот почему сначала вычисляется само выражение, а потом его результат присваивается переменной.
В общем, основной принцип выполнения всех операторов таков: сначала выполняются операторы с более высоким приоритетом, а уже потом — операторы с более низким. Операторы с одинаковым приоритетом выполняются в порядке их следования (слева направо).
В табл. 14.9 перечислены все изученные нами операторы в порядке убывания их приоритетов.
Таблица 14.9. Приоритет операторов (в порядке убывания)
ВНИМАНИЕ!
Запомните эту таблицу. Неправильный порядок выполнения операторов может стать причиной трудно выявляемых ошибок, при которых внешне абсолютно правильное выражение дает неверный результат.
Но что делать, если нам нужно нарушить обычный порядок выполнения операторов? Воспользуемся скобками. При такой записи заключенные в скобки операторы выполняются первыми:
a = (b + c) * 10;
Здесь сначала будет выполнено сложение значений переменных b и c, а потом получившаяся сумма будет умножена на 10.
Операторы, заключенные в скобки, также подчиняются приоритету. Поэтому часто используются многократно вложенные скобки:
a = ((b + c) * 10 — d) / 2 + 9;
Здесь операторы будут выполнены в такой последовательности:
1. Сложение b и c.
2. Умножение полученной суммы на 10.
3. Вычитание d из произведения.
4. Деление разности на 2.
5. Прибавление 9 к частному.
Если удалить скобки:
a = b + c * 10 — d / 2 + 9;
то порядок выполнения операторов будет таким:
1. Умножение c и 10.
2. Деление d на 2.
3. Сложение b и произведения c и 10.
4. Вычитание из полученной суммы частного от деления d на 2.
5. Прибавление 9 к полученной разности.
Получается совсем другой результат, не так ли?
Сложные выражения JavaScript
Сложные выражения получили свое название благодаря тому, что все они составлены из нескольких простых выражений. Сложные выражения выполняются специальным образом и служат для особых целей — в основном, для управления процессом выполнения содержащихся в них простых выражений.
Блоки
JavaScript позволяет нам объединить несколько выражений в одно. Такое выражение называется блочным выражением или просто блоком. Составляющие его выражения заключают в фигурные скобки, например:
{
b = "12";
c = a — b;
}
Как правило, блоки не существуют сами по себе. Чаще всего они входят в состав других сложных выражений.
Условные выражения
Условное выражение позволяет нам выполнить одно из двух входящих в него выражений в зависимости от выполнения или невыполнения какого-либо условия. В качестве условия используется значение логической переменной или результат вычисления логического выражения.
Листинг 14.7 иллюстрирует формат условного выражения.
Листинг 14.7
if (<условие>)
<блок "то">
else
<блок "иначе">
Существует также другая, "вырожденная" разновидность условного выражения,
содержащая только одно выражение, которое выполняется при выполнении условия и пропускается, если условие не выполнено:
