Выражения и операции
В этой главе:
- Операции присваивания
- Операции сравнения
- Арифметические операции
- Побитовые операции
- Логические операции
- Операции со строками
- Условная операция
- Операции с объектами
- Прочие операции JavaScript
- Приоритет выполнения операций
Выражение – это набор данных, переменных, операторов и других выражений, которые приводятся к общему значению. В простейшем случае выражение может выглядеть так:
x=7;
В данном случае переменной x присваивается значение 7 – такое выражение использует операцию присваивания. Другое выражение, скажем, «4+3», тоже будет приведено к значению 7, но при этом присваивания не произойдет. Такие выражения называются просто операциями.
В JavaScript так же разделяют типы выражений по содержанию – они могут быть арифметическими, строковыми, логическими и объектными – в зависимости от того, какие данные были задействованы в образующих выражение данных.
Что же касается самих операций, то мы уже знаем, что в JavaScript существует 6 основных типов операций и ряд дополнительных, со всеми ими мы здесь и ознакомимся. Кроме того, рассмотрим и такой аспект, как порядок их выполнения.
Операции присваивания
Все операции присваивания являются бинарными, т.е. требуют два операнда. При этом левому операнду присваивается значение правого. В простейшем случае операция присваивания выглядит следующим образом:
X = Y
Здесь переменной X присваивается значение переменной Y. Это – обычная операция присваивания. Но кроме нее, в JavaScript предусмотрен еще целый ряд операций присваивания, являющихся сокращенным форматом записи других стандартных операций. Все они приведены в таблице 4.3.
| Операция | Название | Описание | В полном виде |
|---|---|---|---|
| += | Присваивание со сложением | Левому операнду присваивается сумма левого и правого операндов | x = x + y |
| –= | Присваивание с вычитанием | Вычитает левый операнд из правого и присваивает результат левому | x = x - y |
| *= | Присваивание с умножением | Левому операнду присваивается произведение левого и правого операндов | x = x * y |
| /= | Присваивание с делением | Делит левый операнд на правый и присваивает результат левому | x = x / y |
| %= | Присваивание с остатком от деления | Делит левый операнд на правый и присваивает остаток от деления левому | x = x % y |
| <<= | Присваивание с побитовым сдвигом влево | Производит побитовое смещение для левого операнда влево на количество бит, заданных правым операндом, и присваивает результат левому операнду | x = x << y |
| >>= | Присваивание с побитовым сдвигом вправо | Производит побитовое смещение для левого операнда вправо на количество бит, заданных правым операндом, и присваивает результат левому операнду | x = x >> y |
| >>>= | Присваивание с полным побитовым сдвигом вправо | Производит побитовое смещение для левого операнда влево на количество бит, заданных правым операндом, со сдвигом нулей влево и присваивает результат левому операнду | x = x>>>y |
| &= | Присваивание с побитовым сравнением AND | Производит операцию «побитовое И» (&), и присваивает результат левому операнду | x = x & y |
| ^= | Присваивание с побитовым сравнением XOR | Производит операцию «побитовое включающее ИЛИ» (^), и присваивает результат левому операнду | x = x ^ y |
| |= | Присваивание с побитовым сравнением OR | Производит операцию «побитовое включающее ИЛИ» ( | ), и присваивает результат левому операнду | x = x | y |
Таким образом, всего мы имеем 12 различных операций присваивания, 11 из которых являются сокращенными формами выражений, состоящих из простой операции присваивания и другой операции.
Операции сравнения
Подобно операциям присваивания, операции сравнения также требуют наличия двух операндов. Они сравнивают значения левого и правого операндов, и возвращают результат сравнения в виде логического значения, которое может принимать значение false или true (ложь или истина). Операции сравнения могут работать со строками, при этом используется стандартный подход: символы последовательно сравниваются по своим ASCII-кодам (или Unicode-кодам, если используется строковая переменная в формате Unicode). Все операции сравнения перечислены в таблице 4.4.
| Операция | Название | Описание | Пример, дающий true |
|---|---|---|---|
| == | Равно | Возвращает истину (true), когда левый и правый операнды равны. | 1==1 |
| != | Не равно | Возвращает истину, когда левый и правый операнды не равны. | 1!=2 |
| === | Строго равно | Возвращает истину, когда левый и правый операнды равны и относятся к одному типу данных. | "A"==="A"; 2===2 |
| !== | Строго не равно | Возвращает истину, когда левый и правый операнды не равны и (или) относятся к разным типам данных. | "A"!==1; "2"!==2 |
| > | Больше | Возвращает истину, когда левый операнд больше правого. | 2>1 |
| < | Меньше | Возвращает истину, когда левый операнд меньше правого. | 1<2 |
| >= | Больше или равно | Возвращает истину, когда левый операнд больше правого или равен ему. | 1>=0; 1>=1 |
| <= | Меньше или равно | Возвращает истину, когда левый операнд меньше правого или равен ему. | 0<=0; 0<=1 |
Арифметические операции
Арифметические операторы требуют два операнда (литерала или переменных), над которыми производят арифметическое действие, и возвращают результат в виде единичного числового значения.
В языке JavaScript поддерживаются все стандартные арифметические операции, включая сложение (+), вычитание (-), умножение (*) и деление (/), а так же несколько дополнительных операций, например, инкремент (++) и декремент (--). При этом одни арифметические операции являются бинарными (например, сложение или вычитание), в то время как другие – унарными (инкремент или декремент). Все арифметические операции, поддерживаемые языком JavaScript, перечислены в таблице 4.5.
| Операция | Название, тип | Описание | Пример (для x=3, y=2) |
|---|---|---|---|
| 0 | Сложение, бинарная | Возвращает сумму левого и правого операндов | x+y возвращает 5 |
| -0 | Вычитание, бинарная | Возвращает разницу левого и правого операндов | x-y возвращает 1 |
| * | Умножение, бинарная | Возвращает произведение левого операнда на правый операнд | x*y возвращает 6 |
| / | Деление, бинарная | Возвращает результат деления левого операнда на правый операнд. Результат может быть дробным | x/y возвращает 1,5 |
| % | Остаток от деления, бинарная | Возвращает остаток от деления левого операнда на правый операнд | x%y возвращает 1 |
| ++ | Инкремент, унарная | Увеличивает значение операнда на 1, может быть использована как в префиксном (++x), так и в постфиксном (x++) виде | x++ устанавливает x в 4 и возвращает 4, ++x устанавливает x в 4 и возвращает 3 |
| -- | Декремент, унарная | Уменьшает значение операнда на 1, может быть использована как в префиксном (--x), так и в постфиксном (x--) виде | x-- устанавливает x в 2 и возвращает 2, --x устанавливает x в 2 и возвращает 3 |
| -0 | Унарный минус, унарная | Возвращает число, противоположное операнду | -x возвращает -3 |
ВНИМАНИЕ
Обратите внимание, что операция деления двух целых чисел возвращает дробное число. Во многих других языка программирования результатом деления 3 на 2 было бы число 1.
Операции инкремента и декремента являются сокращенным вариантом выражений арифметических выражений с присваиванием. Так, x++ соответствует x=x+1, а x-- соответствует x=x-1. В то же время для операций ++ и -- прямого аналога нет, поскольку в случае выполнения выражения x=x+1 интерпретатор возвратит новое значение x, а для ++x – начальное.
Побитовые операции
Побитовые операции выполняются над 32-х разрядными числами, представленными в двоичном виде (т.е. в виде нулей и единиц). Однако сами операнды могут быть десятичными, шестнадцатеричными, или восьмеричными целыми числами. Например, десятичное число 5 представляется как двоичное 101, десятичное 6 – как 110, а шестнадцатеричное F3 – как двоичное 11110011.
Хотя побитовые операции выполняются над двоичными данными, возвращаемые значения являются стандартными для JavaScript числами. Список всех побитовых операций языка JavaScript приводится в таблице 4.6.
| Операция | Название | Описание | Пример |
|---|---|---|---|
| & | Побитовое И (AND) | Возвращает число, являющееся результатом побитового сравнения «И» | a & b |
| | | Побитовое ИЛИ (OR) | Возвращает число, являющееся результатом побитового сравнения «включающее ИЛИ» | a | b |
| ^ | Побитовое исключающее ИЛИ (XOR) | Возвращает число, являющееся результатом побитового сравнения «исключающее ИЛИ» | a ^ b |
| ~ | Побитовое НЕ (NOT) | Возвращает число, с битами, расположенными в обратном порядке | ~ a |
| << | Сдвиг влево | Сдвигает первый операнд влево на число разрядов, заданных вторым операндом. Освобождающиеся правые биты заполняются нулями | a << b |
| >> | Сдвиг вправо | Сдвигает первый операнд вправо на число разрядов, заданных вторым операндом. Освобождающиеся левые биты отбрасываются | a >> b |
| >>> | Полный сдвиг вправо | Сдвигает первый операнд вправо на число разрядов, заданных вторым операндом. Освобождающиеся левые биты заполняются нулями | a >>> b |
Чтобы явно представить себе, как работают побитовые операции, обратимся к следующему примеру. Допустим, имеется 2 переменных – x и y:
var x=3;
var y=5;
В двоичном представлении число 3 будет выглядеть как 0011, а 5 – как 0101. Теперь посмотрим, какие результаты даст каждая из побитовых операций сравнения и операции отрицания над этими числами:
x | y = 7 0011 | 0101 = 0111
x & y = 1 0011 & 0101 = 0001
x ^ y = 6 0011 ^ 0101 = 0110
~x = 12 ~0011 = 1100
Что касается операций побитового сдвига, то они дадут следующие результаты:
y << 2 = 20 10100
y >> 2 = 1 01
-y >> 2 = -2 -10
y >>> 2 = 1 0001
Логические операции
Типичное использование логических операций заключается в сравнении двух логических значений, каждое из которых может принимать только два значения: «ложь», или «истина» (false или true). Кроме того, допустимо использовать логические операторы для работы с нелогическими выражениями при условии, что результатом их оценки будет логическое значение.
Всего в JavaScript определено 3 вида логических операций – И, ИЛИ и НЕ. С тем, что они собой представляют, можно ознакомиться в таблице 4.7.
| Операция | Название | Описание |
|---|---|---|
| && | Логическое И (AND) | «Выражение1» && «Выражение2». Возвращает «Выражение1», если оно ложно, в противном случае возвращает «Выражение2». В случае с логическими выражениями, возвращает true, когда оба выражения истинны |
| || | Логическое ИЛИ (OR) | «Выражение1» || «Выражение2». Возвращает «Выражение1», если оно истинно, в противном случае возвращает «Выражение2». В случае с логическими выражениями, возвращает true, когда хотя бы одно из них истинно |
| ! | Логическое отрицание (NOT) | Возвращает false, если выражение может быть приведено к истине, в противном случае возвращает true |
ПРИМЕЧАНИЕ
Следует заметить, что в JavaScript не предусмотрено логической операции «исключающее ИЛИ» (XOR), хотя в среди побитовых операций такой тип имеется.
Варианты возвращаемых значений для логических операций приводятся ниже:
true && true // возвращает true
true && false // возвращает false
false && false // возвращает false
true || true // возвращает true
true || false // возвращает true
false || false // возвращает false
!true // возвращает false
!false // возвращает true
Как уже было отмечено, логическому сравнению подлежат не только булевские значения, но и любые другие выражения, которые могут быть к ним приведены. Например, выражение 3==4 может быть использовано в качестве логически сравниваемой единицы, поскольку результатом его оценки будет булево значение (false). Подобно этому, допускается использовать и другие виды значений, например, числа или сроки, поскольку при оценке они неявно выступают как булевское значение истины (true). В результате мы можем дополнить список результатов сравнений такими примерами:
false && (3 == 4) // возвращает false, поскольку сравнение 3==4 ложно
"Кот" && "Пес" // возвращает "Пес" (2-е выражение)
false && "Пес" // возвращает false (сравнивается false && true)
"Кот" && false // возвращает false (сравнивается true && false)
"Кот" && true // возвращает true (сравнивается true && true)
"Кот" || "Пес" // возвращает "Кот" (1-е выражение, соответствующее true)
false || "Пес" // возвращает "Пес" (1-е выражение, соответствующее true)
!"Кот" // возвращает false ("Кот" и true равнозначно)
Из приведенных примеров видно, что хотя в итоге всегда сравниваются булевские значения, результатом сравнения может быть не только ложь или истина, но и одно из самих изначально сравниваемых значений.
Операции со строками
Хотя непосредственно для строк никаких специфических видов операций и не существует, в языке JavaScript допускается использование некоторых стандартных операций применительно к строкам. Помимо уже рассмотренных не примере операций логического сравнения (&&, || и !), совместно со строками можно использовать один арифметический оператор, а именно – оператор сложения. Например, для того чтобы объединить 2 строки в одну, достаточно написать следующее выражение:
var mystr = "Java" + "Script";
В данном случае мы получим переменную mystr, содержащую строку «JavaScript». Сокращенный вариант записи операции сложения так же применим к строкам:
var mystr ="Java";
mystr += "Script";
Результатом такой операции так же будет строка «JavaScript».
ПРИМЕЧАНИЕ
Хотя при склеивании строк применяется тот же знак операции, что и при сложении, на самом деле в случае со строками, как нетрудно догадаться, происходит вовсе не операция сложения, а совершенно другая операция – конкатенация.
Строки могут участвовать и в некоторых других операциях, например, в операциях «обычного» сравнения (==, != и т.д.), а так же в операции условия, которую мы сейчас тоже рассмотрим.
Условная операция
Помимо всех вышеперечисленных операций, в языке JavaScript имеется ряд дополнительных: это операция условия, запятая, а также операции delete, new, this, in, instanceof, typeof и void.
Начнем с условной операции, или операции условия. Она уникальна для JavaScript тем, что задействует сразу три операнда и имеет следующий синтаксис:
(условие) ? выражение1 : выражение2
Здесь условие – это условное выражение, значение которого требуется вычислить. Если результатом вычисления будет истина, то будет выполнено «выражение1», в противном случае – «выражение2». Рассмотрим это на таком примере:
Vendor = (Browser == "Explorer") ? "Microsoft" : "Mozilla";
В данном случае мы вычисляем значение переменной Vendor, для чего сравниваем предопределенную переменную Browser со значением «Explorer». Если результатом такого сравнения будет истина (т.е. если значением переменной Browser является строка «Explorer»), то переменной Vendor будет присвоено значение «Microsoft», в противном случае – «Mozilla».
В действительности, условная операция является ни чем иным, как сокращенным вариантом условного оператора (if), и предыдущий пример можно записать так:
if (Browser == "Explorer")
Vendor = "Microsoft";
else
Vendor = "Netscape";
Хотя такой вариант записи и выглядит несколько более громоздким, для начинающего разработчика он более ясен. Но, так или иначе, со всеми операторами, включая условный, мы ознакомимся несколько позже, а пока для себя отметим, что в языке JavaScript есть как условный оператор, так и условная операция.
Операции с объектами
Для объектов в языке JavaScript предусмотрен целый ряд операций. В частности, это операции для создания и удаления объектов – new и delete. Так, операция new используется для создания экземпляра пользовательского типа объекта, или для создания нового экземпляра предопределенного объекта, например, Array, Date, Function, Image и т.д. Она имеет следующий синтаксис:
ИмяОбъекта = new ТипОбъекта (Параметры);
При использовании оператора new для создания экземпляра предопределенного объекта, достаточно просто указать имя и тип объекта в соответствии с правилами синтаксиса этой операции. Например, для создания экземпляра объекта типа Date (дата), достаточно написать:
var nowdate = new Date();
Таким образом мы получаем переменную nowdate, являющуюся экземпляром объекта Date. Но если операция new должна быть использована для создания определенного разработчиком объекта, то сначала надо такой объект определить. Но вопрос определения собственных объектов мы рассмотрим позже, а пока обратимся к операции delete. Операция delete удаляет из памяти экземпляр указанного объекта, свойство объекта, или элемент массива – в зависимости от того, с каким типом объекта и в каком контексте она используется. Соответственно, синтаксис использования этой операции может немного варьироваться:
delete ИмяОбъекта; //Удаление объекта целиком
delete ИмяОбъекта.Свойство; //Удаление свойства объекта
delete ИмяМассива[ИндексЭлемента]; //Удаление элемента массива
Например, чтобы удалить ранее созданный экземпляр объекта Date, названный nowdate, достаточно написать:
delete nowdate;
ВНИМАНИЕ
Обратите внимание, что операции new и delete работают именно с экземплярами объектов, т.е., фактически, с переменными, являющимися представителями того или иного типа объекта. Сами же объекты создаются (вернее, описываются) при помощи функции, названной как тип объекта.
Теперь, когда нам известно, как создавать и удалять экземпляры объектов, рассмотрим операции, позволяющие с ними взаимодействовать. Для этого в JavaScript предусмотрено еще несколько операций – this, typeof, in и instanceof.
Операция this используется тогда, когда требуется сослаться на текущий объект. К примеру, чтобы при щелчке по кнопке выводилось окно с ее именем, можно использовать такой код:
<form id="Form1">
<input id="Button1" type="Button" value="Посмотреть имя этой кнопки!" onclick="alert(this.id);">
</form>
При щелчке по этой кнопке будет выдано сообщение «Button1». Использование операции this в ряде случаев позволяет существенно упростить написание сценариев, поскольку без нее пришлось бы указывать весть «путь» к объекту, начиная от родительского объекта верхнего уровня. Т.е. для примера с кнопкой пришлось бы указать всю последовательность следования к этому объекту по дереву DOM, начиная с контейнера документа. Например, для наиболее «поддерживаемого» DOM уровня 0 получается такая запись:
alert(document.forms['Form1'].Button1.id);
Если операция this просто ссылается на текущий объект, то операция typeof используется для того, чтобы получить информацию о типе объекта. Например, для строковой переменной будет возвращено значение «string», для числовой – «number», а для экземпляра объекта – «object»:
var str1 = "Строковая переменная";
var str2 = typeof str1;
Здесь переменной str2 будет присвоено значение «string», т.е. тип переменной str1. В иных случаях операция typeof возвращает следующие значения:
var nowdate = new Date();
mytype = typeof nowdate; // mytype = "object"
var size = 100;
mytype = typeof size; // mytype = "number"
var MyFunc = new function("2+2");
mytype = typeof MyFunc; // mytype = "function"
Операцию typeof можно использовать и для встроенных типов языка JavaScript:
mytype = typeof true; // mytype = "boolean"
mytype = typeof null; //mytype= "object"
mytype = typeof eval; //mytype = "function"
mytype = typeof Date; //mytype = "function"
Обратите внимание, что в последнем случае для объекта типа Date мы получили значение типа function, в то время как для экземпляра этого объекта возвращаемым значением операции typeof было object. Это вызвано особенностями реализации поддержки объектов в JavaScript: поскольку язык не является объектно-ориентированным, то поддержка даже внутренних объектов реализуется через функции, о чем честно и сообщает нам операция typeof.
Тем не менее, для обеспечения лучшей работы с объектами, в JavaScript были добавлены 2 дополнительных операции – in и instanceof. Операция in позволяет проверить, есть ли у объекта то или иное свойство, а операция instanceof проверяет экземпляр объекта на принадлежность к тому или иному типу объекта. Обе они возвращают одно из двух значений – false или true, в зависимости от результата проверки:
var MyDate = new Date();
var check1 = "getDay" in MyDate;
// check1 = true (объект Date действительно имеет функцию getDay())
var check2 = "Birthday" in MyDate;
// check2 = false (такого свойства у объекта Date нет)
var check3 = (MyDate instanceof Date);
// check3 = true (MyDate – действительно экземпляр объекта Date)
var check4 = (MyDate instanceof Math);
// check4 = false (MyDate – не экземпляр объекта Math)
Обратите внимание, что для операции in проверяемые названия свойств объектов следует заключать в кавычки.
Прочие операции
Чтобы изучить все операторы языка JavaScript, нам осталось рассмотреть всего 2 оператора – оператор-запятую и пустой оператор void.
Запятая, или операция последовательного выполнения, последовательно вычисляет оба своих операнда. Ее синтаксис:
Выражение1, Выражение2
Данная операция обычно применяется в тех ситуациях, когда по правилам синтаксиса JavaScript допускается только одно выражение, например, объявление двух переменных можно записать так:
var x=5, y=6;
Операция void указывает на то, что выражение, заключенное в нее, не должно возвращать никаких значений:
<a href="javascript:void(document.form.submit())">Отправка</a>
При щелчке по такой ссылке будет отправлена форма. Поскольку указанное действие (document.form.submit) может возвращать какое-либо значение, которое будет подставлено вместо ссылки, то во избежание неприятных ситуаций вызов действия вложен в оператор void, который, при необходимости, «съест» возвращаемое значение.
Приоритет выполнения операций
В завершении ознакомления с операциями языка JavaScript следует ознакомиться с приоритетом и ассоциативностью их выполнения. Приоритет операций имеет смысл только тогда, когда в выражении имеется несколько операций с разным приоритетом. Выражения с большим приоритетом вычисляются первыми. Если все операции в выражении имеют одинаковый приоритет, то их выполнение будет происходить в соответствии с ассоциативностью. В таблице 4.8 приведены все операции в порядке убывания приоритета.
| Класс операций | Обозначения операций | Ассоциативность |
|---|---|---|
| Членство | . [] | Слева направо |
| Вызов и создание объекта | () new | Слева направо |
| Унарные арифметические, побитовое НЕ и операции над объектами | ! - + ++ -- ~ typeof void delete | Справа налево |
| Бинарные арифметические – деление и умножение | * / % | Слева направо |
| Бинарные арифметические – сложение и вычитание | + - | Слева направо |
| Побитовый сдвиг | << >> >>> | Слева направо |
| Отношение | < <= => > in instanceof | Слева направо |
| Сравнение | == != === !== | Слева направо |
| Побитовое И | & | Слева направо |
| Побитовое исключающее ИЛИ | ^ | Слева направо |
| Побитовое ИЛИ | | | Слева направо |
| Логическое И | && | Слева направо |
| Логическое ИЛИ | || | Слева направо |
| Условная операция | ?: | Слева направо |
| Присваивание | = += -= *= /= %= <<= >>= >>>= &= ^= |= | Справа налево |
| Запятая | , | Слева направо |
Рассмотрим прядок действий в следующем выражении:
X = ++radius * 2 – Math.PI + 4;
Сначала будет взято значение числа π из объекта Math (точка, или операция членства, имеет наибольший приоритет), затем значение переменной radius будет увеличено на 1, а результат увеличен вдвое (операция инкремента имеет более высокий приоритет, чем умножение). Наконец, из получившегося результата сначала будет вычтено число π, а затем добавлено 4 (в соответствии с ассоциативностью арифметических операций), после чего итоговое значение будет присвоено переменной X, поскольку операция присваивания, хотя и первая в данном выражении, но имеет наименьший приоритет.
Чтобы изменить порядок выполнения операций, в JavaScript, так же, как и в обычной математике, можно использовать круглые скобки.
2011-07-26 // Есть вопросы, предложения, замечания? Вы можете обсудить это на форуме !
