Книги-online

Глава 5
Операции

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

В таблице дано резюме по операциям JavaScript.

+

++

-

--

*

/

%

&

^

|

~

<<

>>

>>>

=

+=

-=

*=

/=

%=

&=

^=

|=

<<=

>>=

>>>=

?:

,

delete

new

this

typeof

void

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

Операция присвоения присваивает значение левому операнду на основе значения правого операнда.

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

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

В нестандартных ситуациях оператор присвоения не идентичен значению из колонки "Значение" Таблицы 5.2. Если левый операнд операции присвоения сам содержит операцию присвоения, он вычисляется только однократно. Например:

a[i++] += 5         //i вычисляется только один раз
a[i++] = a[i++] + 5 //i вычисляется дважды

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

Операция сравнения сравнивает операнды и возвращает логическое значение на основе того, является ли сравнение true.

Операнды могут быть числами или строками. Строки сравниваются на основе стандартного лексикографического (словарного) порядка с использованием Unicode-значений.

Булево значение возвращается как результат сравнения.

• Две строки равны, если они имеют одинаковые последовательности символов, одинаковые размеры и одинаковые символы в соответствующих позициях.
• Два числа равны, если они равны численно (имеют одинаковые числовые значения). NaN не равно ничему, включая само NaN. Положительные и отрицательные нули равны.
• Два объекта равны, если они ссылаются на один Object.
• Два Булевых операнда равны, если они оба true или оба false.
• Типы Null и Undefined равны.

В таблице дано резюме по операциям сравнения.

3 == var1
"3" == var1
3 == '3'

var1 != 4
var1 != "3"

3 === var1

var1 !== "3"
3 !== '3'

var2 > var1

var2 >= var1
var1 >= 3

var1 < var2

var1 <= var2
var2 <= 5

Использование Операций Равенства

Стандартные операции равенства (== и !=) сравнивают два операнда без учёта типа. Операции строгого равенства (=== и !==) выполняют сравнение операндов одного типа. Используйте операции строгого равенства если операнды и значения обязаны иметь специфический тип, а также если имеет значение определённый тип операндов. Иначе используйте стандартные операции равенства, которые дают возможность сравнивать два операнда, даже если они имеют разные типы.

Если необходима конвертация типов, JavaScript конвертирует операнды String, Number, Boolean или Object так:

• При сравнении числа и строки - строка конвертируется в число. JavaScript пытается конвертировать числовой литерал строки в значение типа Number. Сначала математическое значение получается из числового литерала строки. Затем это значение округляется до ближайшего значения типа Number.
• Если один из операторов имеет тип Boolean, Boolean-операнд конвертируется в 1, если он true, и в +0, если он false.
• Если объект сравнивается со строкой или числом, JavaScript пытается вернуть значение по умолчанию для объекта. Делается попытка конвертировать объект в примитивное значение, String в Number, с использованием методов valueOf и toString объекта. Если попытка конвертации терпит неудачу, генерируется ошибка времени выполнения.

Обратная Совместимость

Поведение стандартных операций сравнения (== и !=) зависит о версии JavaScript.

JavaScript 1.2. Стандартные операции сравнения (== и !=) не выполняют конвертацию типов перед выполнением сравнения. Операции строго равенства (=== и !==) недоступны.

JavaScript 1.1 и более ранние версии. Стандартные операции сравнения (== и !=) выполняют конвертацию типов перед выполнением сравнения. Операции строго равенства (=== и !==) недоступны.

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

Арифметические операции принимают в качестве операндов числовые значения (литералы или переменные) и возвращают единственное числовое значение. Стандартные арифметические операции: сложение (+), вычитание (-), умножение (*) и деление (/).

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

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

% (Modulus/целочисленный остаток)

Операция modulus используется так:

var1 % var2

Операция modulus возвращает первый операнд modulo второй операнд, то есть var1 modulo var2, как в вышеприведённом операторе, где var1 и var2 это переменные. Функция modulo это целочисленный остаток от деления var1 на var2. Например, 12 % 5 возвращает 2.

++ (Инкремент)

Операция инкремента выполняется так:

var++ или ++var

Эта операция выполняет инкремент (прибавляет 1) операнда и возвращает его значение. Если это постфикс, когда операция находится после операнда (например, x++), возвращается значение, которое было до выполнения инкремента. Если используется префикс (например, ++x), возвращается значение, полученное после выполнения инкремента.

Например, если x равен 3, то оператор y = x++ устанавливает в y 3 и выполняет инкремент x до 4. Если x равен 3, то оператор y = ++x выполняет инкремент x до 4 и устанавливает в переменную y значение 4.

-- (Декремент)

Операция декремента используется так:

var-- или --var

Эта операция выполняет декремент (вычитает 1) операнда и возвращает его значение. Если это постфикс, когда операция находится после операнда (например, x--), возвращается значение, которое было до выполнения декремента. Если используется префикс (например, --x), возвращается значение, полученное после выполнения декремента.

Например, если x равен 3, оператор y = x-- устанавливает в y значение 3 и выполняет декремент x до 2. Если x равен 3, оператор y = --x выполняет декремент x до 2 и устанавливает в переменную y значение 2.

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

Операция унарного отрицания находится впереди операнда и выполняет его отрицание. Например, y = -x отрицает (меняет знак) значения x и присваивает его переменной y; то есть, если x равен 3, y получает значение -3, а значение x остаётся равным 3.

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

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

a & b

a | b

a ^ b

~ a

a << b

a >> b

a >>> b

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

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

• Операнды конвертируются в 32-битные целые числа и выражаются сериями битов (0 и 1).
• Каждый бит первого операнда образует пару с битом второго операнда в этой же позиции: первый с первым, второй со вторым и т.д.
• Операция выполняется для каждой пары битов, и результат конструируется побитно.

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

• 15 & 9 даёт 9 (1111 & 1001 = 1001)
• 15 | 9 даёт 15 (1111 | 1001 = 1111)
• 15 ^ 9 даёт 6 (1111 ^ 1001 = 0110)

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

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

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

<< (Сдвиг влево)

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

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

>> (Сдвиг вправо с сохранением знака)

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

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

>>> (Сдвиг вправо с заполнением нулями)

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

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

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

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

Логические операции описаны в следующей таблице.

expr1 && expr2

expr1 || expr2

!expr

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

Хотя операции && и || могут использоваться с не-Булевыми операндами, они (операции) считаются всё же Булевыми, поскольку их return-значения всегда могут быть конвертированы в Boolean.

Сокращённый цикл вычислений. Поскольку логические выражения вычисляются слева направо, они проверяются на возможность "сокращённого/short-circuit" вычисления по следующим правилам:

• false && anything сокращённо вычисляется в false.
• true || anything сокращённо вычисляется в true.

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

Обратная Совместимость

JavaScript 1.0 и 1.1. Операции && и || работают так:

Примеры

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

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, принимающая три операнда. Эта операция часто используется как аббревиатура оператор if.

Синтаксис

condition ? expr1 : expr2

Параметры

condition

expr1, expr2

Описание

Если condition равно true, операция возвращает значение expr1; иначе она возвращает значение expr2. Например, для вывода различных сообщений на основе значения переменной isMember Вы можете использовать такой оператор:

document.write ("The fee is " + (isMember ? "$2.00" : "$10.00"))

, (Операция "запятая")

Операция "запятая" вычисляет оба операнда и возвращает значение второго операнда.

Синтаксис

expr1, expr2

Параметры

expr1, expr2

Описание

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

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

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

Удаление элементов массива. Если вы удаляете элемент массива, размер массива не изменяется. Например, если Вы удаляете 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) {
   // этот участок кода будет выполняться
}

new

Операция new создаёт экземпляр объекта пользовательского типа или объекта одного из встроенных типов, имеющих функцию-конструктор.

Синтаксис

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

Параметры

objectName

objectType

param1...paramN

Описание

Создание пользовательского типа объектов требует выполнения двух шагов:

Для определения типа объектов создайте функцию, специфицирующую имя, свойства и методы объекта. Объект может иметь свойства, которые сами являются объектами. См. примеры ниже.

Вы всегда можете добавить свойство к ранее определённому объекту. Например, оператор car1.color = "black" добавляет свойство color к car1 и присваивает этому свойству значение "black". Однако это не влияет на другие объекты. Чтобы добавить новое свойство во все объекты данного типа, Вы обязаны добавить свойство в определение типа объектов car.

Вы можете добавить свойство к ранее определённому типу объектов, используя свойство Function.prototypefor. Оно определяет свойство, которое используется совместно всеми объектами, созданными этой функцией, а не только одним экземпляром этого типа. Следующий код добавляет свойство color во все объекты типа car, а затем присваивает значение свойству color объекта car1. См. дополнительно prototype, for.

Car.prototype.color=null
car1.color="black"
birthday.description="The day you were born"

Примеры

Пример 1: Тип объекта и экземпляр объекта. Предположим, вы хотите создать тип объекта для автомобилей/cars. Вы хотите, чтобы этот тип назывался car и чтобы он имел свойства make/изготовлен, model/модель и year/год. Для этого вы должны написать следующую функцию:

function car(make, model, year) {
   this.make = make
   this.model = model
   this.year = year
}

Теперь можно создать объект mycar:

mycar = new car("Eagle", "Talon TSi", 1993)

Этот оператор создал mycar и присвоил специфицированные значения его свойствам. Теперь значением свойства mycar.make является строка "Eagle", mycar.year - целое число 1993 и т.д.

Вы можете создать любое количество объектов типа car путём вызова операции new. Например,

kenscar = new car("Nissan", "300ZX", 1992)

Пример 2: Свойство объекта, само являющееся другим объектом. Предположим, Вы определили объект person:

function person(name, age, sex) {
   this.name = name
   this.age = age
   this.sex = sex
}

а затем инстанциируете (создаёте экземпляры) два новых person-объекта:

rand = new person("Rand McNally", 33, "M")
ken = new person("Ken Jones", 39, "M")

Затем Вы можете переписать определение типа car для включения свойства owner, принимающего объект person:

function car(make, model, year, owner) {
   this.make = make; 
   this.model = model;
   this.year = year;
   this.owner = owner;
}

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

car1 = new car("Eagle", "Talon TSi", 1993, rand);
car2 = new car("Nissan", "300ZX", 1992, ken)

Вместо того чтобы передавать строковой литерал или целочисленное значение при создании объектов, вышеприведённые операторы передают объекты rand и ken в качестве параметров для свойства owner. Чтобы найти имя owner/владельца машины car2, Вы можете получить доступ к следующему свойству:

car2.owner.name

this

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

Синтаксис

this[.propertyName]

Примеры

Предположим, функция 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)">

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 object
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) вычисляется в 0, но не вызывает никаких действий в JavaScript.

<A href="books-page-javascript-javascript_13-javascript:void(0)">Click here to do nothing</A>

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

<A href="books-page-javascript-javascript_13-javascript:void(document.form.submit())">
Click here to submit</A>

Дата последнего обновления: 28 мая 1999 года.
Copyright (c) 1999 Netscape Communications Corporation