AMP версия сайта
Электронная библиотека

Программисту веб-дизайнеру

Другие материалы

Ядро JavaScript 1.5. Руководство по Использованию

Глава 3   Выражения и Операции

В этой главе рассматриваются выражения и операции JavaScript, в том числе: операции присвоения, сравнения, арифметические, побитовые, логические строковые и специальные.

Глава состоит из разделов:
 

Выражения

Выражение это правильный набор литералов, переменных, операторов  и выражений, который вычисляется в одно значение; это значение может быть числом, строкой или логическим значением.

Концептуально есть выражения двух видов: присваивающие значение переменной и просто имеющие значение. Например, выражение x = 7 это выражение, в котором x получает значение 7. Это выражение вычисляется в 7. Такие выражения используют операции присвоения. С другой стороны, выражение 3 + 4 просто вычисляется в 7; оно не выполняет присвоения значения. Операции, используемые в таких выражениях, называются просто операциями.

В JavaScript имеются следующие типы выражений:
 

Операции

В этом разделе рассмотрены операции и содержится информация о приоритете выполнения операций.
В JavaScript имеются следующие типы операций:
 

В JavaScript имеются бинарные и унарные операции. Для выполнения бинарной операции необходимы два операнда: один до знака операции и один - после:

операнд1 операция операнд2

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

Для выполнения унарной операции необходим один операнд, до или после знака операции:

операция операнд
 

или

операнд операция
 

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

Кроме того, в JavaScript есть условная тернарная операция. Она требует наличия трех операндов.

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

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

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

Таблица 3.1    Операции Присвоения

Сокращенное обозначение --- Значение

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 = 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

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

Таблица 3.2  Операции Сравнения
 

Операция --- Описание --- Примеры, возвращающие true¹

Равно (==) --- Возвращает true, если операнды равны. Если операнды разных типов, JavaScript пытается конвертировать операнды до типа, пригодного для сравнения. --- 3 == var1
"3" == var1
3 == '3'

Не равно (!=) --- Возвращает true, если операнды не равны. Если операнды разных типов, JavaScript пытается конвертировать операнды до типа, пригодного для сравнения. --- var1 != 4
var2 != "3"

Строго равно (===) --- Возвращает true, если операнды равны и одного типа.

3 === var1

Строго не равно (!==) --- Возвращает true, если операнды не равны и/или не одного типа. --- var1 !== "3"
3 !== '3'

Больше (>) --- Возвращает true, если левый операнд больше правого.

var2 > var1

Больше или равно (>=) --- Возвращает true, если левый операнд больше правого или равен ему. --- var2 >= var1
var1 >= 3

Меньше (<) --- Возвращает true, если левый операнд меньше правого. --- var1 < var2

Меньше или равно (<=) --- Возвращает true, если левый операнд меньше правого или равен ему. --- var1 <= var2
var2 <= 5 

¹Эти примеры предполагают, что переменной var1 присвоено значение 3, а переменной var2 значение 4.

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

Арифметические операции принимают числовые значения (литералы или переменные) в качестве операндов и возвращают одиночное числовое значение. Стандартными арифметическими операциями являются сложение (+), вычитание (-), умножение (*) и деление (/). Эти операции работают так же, как и во многих других языках программирования, но операция / в JavaScript возвращает результат деления с плавающей точкой, а не округленное частное, как в языках программирования C или Java. Например:

1/2 //возвращает 0.5 в JavaScript
1/2 //возвращает 0 в Java

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

Таблица 3.3  Арифметические Операции

Операция --- Описание --- Пример

%
(Modulus) --- Бинарная операция. Возвращает целочисленный остаток от деления двух операндов. ---

12 % 5 возвращает 2.

++
(Инкремент) --- Унарная операция. Добавляет 1 к операнду. Если используется как префикс (++x), добавляет единицу и возвращает значение операнда; если используется как постфикс (x++), возвращает значение операнда и затем прибавляет единицу. --- Если x равен 3, то ++x устанавливает x в 4 и возвращает 4; а x++ устанавливает x в 4 и возвращает 3.

--
(Декремент) --- Унарная операция. Вычитает единицу из операнда. Возвращаемое значение аналогично значению для операции инкремента. --- Если x равен 3, то --x устанавливает x в 2 и возвращает 2; а x-- устанавливает x в 2 и возвращает 3.

-
(Унарное отрицание) ---

Унарная операция. Возвращает операнд с измененным знаком. ---

Если x равен -3, то -x возвращает 3.

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

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

В таблице резюмируется информация о побитовых операциях JavaScript.

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

Операция --- Использование --- Описание ---

Побитовое И --- a & b ---

Возвращает 1 в каждой битовой позиции, где соответствующие биты обоих операндов равны 1.

Побитовое ИЛИ --- a | b ---

Возвращает 1 в каждой битовой позиции, где соответствующие биты одного или обоих операндов равны 1.

Побитовое исключающее ИЛИ --- a ^ b ---

Возвращает 1 в каждой битовой позиции, где соответствующие биты одного но не обоих операндов равны 1.

Побитовое НЕ --- ~ a ---

Инвертирует биты операнда.

Сдвиг влево --- a << b ---

Сдвигает двоичное представление a на b битов влево, заполняя справа нулями.

Сдвиг вправо с сохранением знака --- a >> b ---

Сдвигает двоичное представление a на b битов вправо, отбрасывая смещенные биты.

Сдвиг вправо с заполнением нулями --- a >>> b ---

Сдвигает двоичное представление a на b битов вправо, отбрасывая смещенные биты и заполняя нулями слева.

Побитовые Логические Операции

Концептуально побитовые логические операции работают так:
 

Например, бинарное представление 9 это 1001, а бинарное представление 15 это 1111. Итак, если побитовая операция применяется к этим двум числам, результаты будут такими:
 

Побитовые Операции Сдвига

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

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

Операции сдвига  перечислены в таблице.

Таблица 3.5  Побитовые Операции Сдвига

Операция --- Описание --- Пример

<<
(Сдвиг влево) --- Эта операция сдвигает первый операнд на специфицированное количество битов влево. Излишние биты, смещенные влево, отбрасываются. Справа биты заполняются нулями. ---

9<<2 дает 36, поскольку 1001, смещенное на 2 бита влево, становится 100100, то есть 36.

>>
(Сдвиг вправо с сохранением знака) --- Первый операнд сдвигается на специфицированное количество битов вправо. Излишние биты, смещенные вправо, отбрасываются. Копии самого левого бита вдвигаются слева. ---

9>>2 дает 2, поскольку 1001, смещенное на 2 бита вправо, становится 10, то есть 2. Аналогично, -9>>2 дает -3, поскольку знак сохраняется.

>>>
(Сдвиг вправо с заполнением нулями) --- Первый операнд сдвигается на специфицированное количество битов вправо. Излишние биты, смещенные вправо, отбрасываются. Слева биты заполняются нулями.

--- 19>>>2 дает 4, поскольку 10011, смещенное на 2 бита вправо, становится 100, то есть 4. Для неотрицательных чисел, сдвиг вправо с заполнением нулями дает тот же эффект, что и сдвиг вправо с сохранением знака.

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

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

Таблица 3.6  Логические Операции

Операция --- Использование --- Описание

&& --- expr1 && expr2 --- (Логическое И) Возвращает expr1, если оно может быть конвертировано в false; иначе возвращает expr2. Таким образом, при использовании с Boolean-значениями, && возвращает true, если оба операнда true; иначе возвращает false.

|| --- expr1 || expr2 --- (Логическое ИЛИ) Возвращает expr1, если оно может быть конвертировано в true; иначе возвращает expr2. Таким образом, при использовании с Boolean-значениями, || возвращает true, если хотя бы один из  операндов true; если оба операнда false, возвращает false.

! --- !expr

(Логическое НЕ) Возвращает false если ее единственный операнд может быть конвертирован в true; иначе возвращает true.

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

Вот примеры операции && (логическое И):

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

Примеры операции || (логическое ИЛИ):

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

Примеры операции ! (логическое НЕ):

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

Сокращенное Вычисление

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

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

Строковые Операции

Помимо операций сравнения, может применяться операция конкатенации/объединения (+) значений двух строк, возвращающее новую строку, которая является результатом объединения двух строк-операндов. Например, "my " + " string" возвращает строку "my string".

Сокращенная форма записи операции += также может использоваться для конкатенации строк. Например, если переменная mystring имеет значение "alpha," то выражение mystring += "bet" вычисляется до "alphabet" и это значение присваивается переменной mystring.

Специальные Операции

В JavaScript имеются следующие специальные операции:
 

Условная Операция

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

condition ? val1 : val2
 

Если condition - true, операция имеет значение val1. Иначе - значение val2. Вы можете использовать условную операцию в любом месте, где может использоваться стандартная операция.

Например,

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

Этот оператор присваивает значение "adult" переменной status, если age равен 19 или более. Иначе переменной status присваивается значение "minor".

Операция "запятая"

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

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

for (var i=0, j=9; i <= 9; i++, j--)
   document.writeln("a["+i+","+j+"]= " + a[i*10 +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  (может удалить, если myobj объявлен неявно)

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

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

Если операция delete удаляет элемент массива, этот элемент больше не присутствует в массиве. В следующем примере trees[3] удаляется с помощью delete.

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

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

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

in

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

propNameOrNumber in objectName
 

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

Некоторые примеры использования операции in:

// Массивы
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
myString=new String("coral")
"length" in myString  // возвращает true

// Специальные объекты
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 выполняются.

theDay=new Date(1995, 12, 17)
if (theDay instanceof Date) {
// выполняемые операторы
}

new

Вы можете использовать операцию new для создания экземпляра объекта пользовательского типа или экземпляра одного из предопределенных типов объекта: Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp или String. На сервере Вы можете также использовать ее с DbPool, Lock, File или SendMail. Используйте new так:

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

Вы можете также создать объекты, используя инициализаторы объектов, как описано в "Использовании Инициализаторов Объектов".

См. new в книге ЯдроJavaScript. Справочник.

this

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

this[.propertyName]
 

Пример 1.

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

function validate(obj, lowval, hival) {
   if ((obj.value < lowval) || (obj.value > hival))
      alert("Invalid Value!")
}

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

<B>Enter a number between 18 and 99:</B>
<INPUT TYPE = "text" NAME = "age" SIZE = 3
   onChange="validate(this, 18, 99)">
 

Пример 2.

При соединении со свойством формы, this может ссылаться на родительскую форму текущего объекта. В следующем примере форма myForm содержит Text-объект и кнопку. Если пользователь щелкает на кнопке, значением Text-объекта становится имя формы. Обработчик onClick кнопки использует this.form для обращения к родительской форме myForm.

<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
<P>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value=this.form.name">
</FORM>

typeof

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

1. typeof operand
2. typeof (operand)
 

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

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

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

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

typeof myFun is function
typeof shape is string
typeof size is number
typeof today is object
typeof dontExist is undefined
 

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

typeof true is boolean
typeof null is object
 

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

typeof 62 is number
typeof 'Hello world' is string
 

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

typeof document.lastModified is string
typeof window.length is number
typeof Math.LN2 is number

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

typeof blur is function
typeof eval is function
typeof parseInt is function
typeof shape.split is function

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

typeof Date is function
typeof Function is function
typeof Math is function
typeof Option is function
typeof String is function

void

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

1. void (expression)
2. void expression
 

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

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

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

<A HREF="javascript:void(0)">Click here to do nothing</A>

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

<A HREF="javascript:void(document.form.submit())">
Click here to submit</A>

Приоритет Операций

Приоритет операций определяет порядок выполнения операций при вычислении выражения. Вы можете переопределить порядок выполнения путем использования скобок.

В таблице описан приоритет операций от низшего к высшему.

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

Тип Операции --- Операции

"запятая" --- ,

присвоение --- = += -= *= /= %= <<= >>= >>>= &= ^= |=

условная --- ?:

логическое ИЛИ --- ||

логическое И --- &&

побитовое ИЛИ --- |

побитовое исключающее ИЛИ --- ^

побитовое И --- &

равенство --- == != === !==

соотношение --- < <= > >= in instanceof

побитовый сдвиг --- << >> >>>

сложение/вычитание --- + -

умножение/деление --- * / %

отрицание/инкремент --- ! ~ - + ++ -- typeof void delete

вызов/создание экземпляра --- () new

член --- . []

Назад   Оглавление   Индекс   Вперед

AMP версия сайта
Мобильная версия

Сайт для компьютера
http://www.mat.net.ua