Операторы

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

Операторы JavaScript

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

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

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

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

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

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

var1 % var2

Функция modulos это целочисленный остаток от деления 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.

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

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

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

Логические операторы

Логические операторы, как правило, используются с булевыми значениями и возвращают булево значение.

Однако, в javascript операторы && и || возвращают не булево значение, а один из операндов, определивший значение выражения. Конечно, результат в таком случае может быть и не булевым.

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

К false преобразуются, например: null, 0, пустая строка ("") и undefined.

Хотя операторы && и || и могут быть использованы для возвращения небулевых значений, они все же логические, так как возвращаемые значения могут быть приведены к булевому типу.

Оператор ! также используется для быстрого преобразования выражения к булевому значению:

!!"string" = true
!!null = false

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

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

• false && что угодно становится false.
• true || что угодно становится true.

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

a =1
check = 5 || (a=3)

Alert(a) // 1

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

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

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

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

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

• Операнды конвертируются в 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. Для неотрицательных значений сдвиг вправо с заполнением нулями и сдвиг вправо с сохранением знака дают один результат.

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

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

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

Сокращённые Операторы Присвоения

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

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

Операторы Сравнения

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

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

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

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

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

Таблица. Операторы Сравнения

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

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

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

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

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

?: (Условный оператор)

Условный оператор - единственный в JavaScript, принимающий три операнда. Этот оператор часто используется как аббревиатура оператор if.

Синтаксис

condition ? expr1 : expr2

Параметры

condition

Выражение, вычисляемое в true или false.

expr1, expr2

Выражения со значениями любого типа.

Возвращаемое значение

Если condition равно true, оператор возвращает значение expr1; иначе она возвращает значение expr2.

Примеры

Для вывода различных сообщений на основе значения переменной isMember Вы можете использовать такой оператор:

Alert ("The fee is " + (isMember ? "$2.00" : "$10.00"));  //$10.00
var isMember = true;

Alert ("The fee is " + (isMember ? "$2.00" : "$10.00"));  //$2.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])

Аксессоры

Предоставляют доступ к свойствам объекта.

Объект представляет собой обычный ассоциативный массив (словарь, хэш). Ключами этого массива являются имена свойств и методов (свойств, являющихся ссылкой на функцию).

Есть два способа доступа к свойствам: запись с точкой или с квадратными скобками.

Запись с точкой

get = object.property  // получить свойство property
object.property = set  // записать свойство property

Для записи с точкой название свойства должно быть правильным javascript-идентификатором, то есть последовательностью английских букв и цифр, включая подчеркивание "_" и знак доллара "$", которая не начинается с числа.
Например, object.$1 - корректный идентификатор, а object.1 - нет.

document.createElement('pre')

В этом примере из объекта document получено свойство createElement, которое является ссылкой на функцию. Эта функция вызвана с аргументом 'pre' в контексте объекта document.

Запись с квадратными скобками

get = object[property_name]   // получить
object[property_name] = set   // записать

Здесь property_name - строка. Она не обязательна является правильным идентификатором. Может быть любое значение, включая цифры и даже " " (пробел).

document['createElement']('pre')

Этот пример делает в точности то же самое, что и аналогичный предыдущий.

Использование eval

В старых javascript-скриптах иногда используется доступ к свойствам объекта через eval, в то время как гораздо быстрее и правильнее использовать запись с квадратными скобками.

Например, часто попадается такая запись:

x = eval('document.form_name.' + strFormControl + '.value')

Следует максимально избегать вызова eval. Лучше использовать скобочную запись:

x = document.form_name[strFormControl].value

delete

Оператор delete удаляет объект, свойство объекта или элемент массива по специфицированному индексу.

Синтаксис

delete objectName
delete objectName.property
delete objectName[index]
delete property

Четвёртая форма верна только внутри оператора with при удалении свойства объекта.

Параметры

objectName

Имя объекта.

property

Удаляемое свойство.

index

Целое число - индекс массива.

Комментарии

Можно использовать оператор 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) {
	// этот участок кода будет выполняться
}

in

Оператор in возвращает true, только если данное свойство присутствует в объекте или его прототипе.

Синтаксис

prop in object

Параметры

prop

Строка или числовое выражение, являющееся именем свойства или индексом массива

object

Объект для поиска в нем свойства или массив - для проверки индекса

Примеры

obj = {
  a: 5
}

"a" in obj // true
"b" in obj // false
"toString" in obj // true, т.к toString есть в прототипе

Следующий пример иллюстрирует проверку индекса в массиве:

arr = [ "a", "b", "c"]

1 in arr // true
22 in arr // false

delete arr[1]
1 in arr // false : элемент удален

Справа от оператора in должен находится объект, иначе интерпретатор сгенерирует ошибку TypeError.

'a' in "test" // TypeError

instanceof

Оператор instanceof используется для проверки, принадлежит ли объект данному типу

Синтаксис

var isInstance = object instanceof ObjectType

Параметры

object

object

objectType

Конструктор(тип) для сравнения

Описание, комментарии, примеры

В левой части оператора instanceof указывается проверяемый объект, а с правой - функция-конструктор для проверки.

var theDay = new Date(2009, 11, 17);
if (theDay instanceof Date) {
  Alert("Объект класса Date")
  // ...
}

Оператор instanceof учитывает наследование.

Следующий пример демонстрирует, что объекты String и Date принадлежат типу Object.

var myString = new String()
var myDate = new Date()

myString instanceof String  // true
myString instanceof Object  // true
myString instanceof Date    // false

myDate instanceof Date     // true
myDate instanceof Object   // true
myDate instanceof String   // false

То же верно и для типов, объявленных пользователем.

Например, в следующем примере объект типа Honda также принадлежит Car и Object.

function Car(model) {
  this.model = model
}
function Honda(model) {
  this.model = model
  this.isHonda = true
}
Honda.prototype = new Car()

honda = new Honda("Accord")

honda instanceof Honda  // true
honda instanceof Car    // **true**
honda instanceof Object // true

honda instanceof Date   // false

new

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

Синтаксис

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

Параметры

objectName

Имя нового экземпляра объекта.

objectType

Тип объекта. Должна существовать функция, определяющая тип объекта.

param1...paramN

Значения свойств объекта. Эти свойства являются параметрами, определёнными для функции objectType.

Комментарии

Оператор new создает новый объект, используя функцию-конструктор, которая может быть как встроенной в javascript (Date, String), так и определенной пользователем.

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

1. Объявить функцию-конструктор
2. Инстанциировать (сделать экземпляр объекта) вызовом new

После создания вы можете добавить к объекту любые свойства и удалить - почти любые, кроме ряда свойств встроенных javascript-объектов.

Оператор new также задает прототип объекта равным свойству prototype функции-конструктора.

Примеры

Пример 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.property.

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

Есть четыре различных варианта его передачи.

Если ни один из этих способов не задействован, то this указывает на глобальный объект: в браузере это window.

Это происходит при вызове функции без объекта: myFunc(params).

При манипуляциях с DOM при помощи javascript, this обычно используется для работы с событиями. При этом значение this указывает на текущий DOM-элемент, в контексте которого вызван обработчик.

Привязка методов

Так как this не привязано жестко к объекту, то можно привязывать один и тот же метод к любым классам.

walk = function() { this.isWalking = true }

function Bird() { ... }
function Rabbit() { ... }

Bird.prototype.walk = Rabbit.prototype.walk = walk

new Bird().walk()    // в обоих случаях
new Rabbit().walk()  // this будет указывать на текущий объект

Пример

Предположим, функция 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 возвращает строку, содержащую информацию о типе операнда.

Оператор typeof используется в двух формах:

typeof operand
typeof (operand)

Эти формы идентичны: можно использовать скобки, а можно и не использовать - работает одинаково.

Оператор возвращает тип в виде строки, например:

var a = 5
Alert(typeof a) // "number"

var a = 'test'
Alert(typeof a) // "string"

Тип typeof возвращается, исходя из следующей таблицы соответствия типам javascript:

Часто возникают вопросы - почему и зачем таблица именно такая? Ответ простой: потому что так получилось по ходу развития javascript.

В старом javascript-коде можно увидеть применение typeof для проверки существования переменной:

if (typeof(var) == "undefined") { ... }

В современном javascript лучше писать:

if (window.var !== undefined) { ... }

// или, зачастую, подойдет и просто:

if (window.var) { ... }

P.S. Использовать просто if(var) нельзя, так как доступ к неопределенной переменной вызовет ошибку. Ну а обращение к отсутствующему свойству глобального объекта window всего лишь вернет undefined

Кроме того, оператор typeof используется для полиморфизма. Например, следующая функция получает узел DOM или ID узла и в обоих случаях корректно прячет узел.

function hideNode(node) {
  if (typeof node == 'string') {
    node = document.getElementById(node)
  }
  node.style.display = 'none'
}

void

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

void (expression)
void expression

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

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

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

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

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

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