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

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

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.

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

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

Реализованы в	JavaScript 1.0
Версия ECMA	ECMA-262

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

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

Delete

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

Реализована в	JavaScript 1.2, NES 3.0
Версия ECMA	ECMA-262

Операции

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

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

Таблица 5.1 Операции JavaScript

Категория Операции Операция Описание

Арифметические	+	(Сложение) Складывает два числа.
++	(Инкремент) Прибавляет 1 к переменной, представляющей число (возвращая новое или старое значение переменной).
-	(Унарное отрицание, вычитание) Как унарная операция отрицает значение аргумента. Как бинарная - вычитает второй аргумент из первого.
--	(Декремент) Вычитает 1 из переменной, представляющей число (возвращая новое или старое значение переменной).
*	(Умножение) Перемножает два числа.
/	(Деление) Делит одно число на другое.
%	(Modulus) Вычисляет целочисленный остаток от деления двух чисел.
Строковые	+	(Сложение строк/Конкатенация) Объединяет две строки.
+=	Объединяет две строки и присваивает результат первому операнду.
Логические	&&	(Логическое И) Возвращает первый операнд, если он может быть конвертирован в false; иначе возвращает второй операнд. При использовании с Булевыми значениями && возвращает true, если оба операнда true; иначе возвращает false.
||	(Логическое ИЛИ) Возвращает первый операнд, если он может быть конвертирован в false; иначе возвращает второй операнд. При использовании с Булевыми значениями || возвращает true, если любой из операндов true; если оба false, возвращает false.
!	(Логическое НЕ) Возвращает false, если единственный операнд может быть конвертирован в true; иначе возвращает true.
Побитовые	&	(Побитовое И) Возвращает 1 в каждой битовой позиции, если биты обоих операндов равны единице.
^	(Побитовое исключающее ИЛИ) Возвращает 1 в каждой битовой позиции, если бит одного, но не обоих операндов равен 1.
|	(Побитовое ИЛИ) Возвращает 1 в битовой позиции, если бит любого операнда равен 1.
~	(Побитовое НЕ) Инвертирует биты операнда.
<<	(Сдвиг влево) Сдвигает влево первый операнд, в двоичном представлении, на количество битов, специфицированное вторым операндом, заполняя справа нулями.
>>	(Сдвиг вправо с сохранением знака) Сдвигает вправо первый операнд, в двоичном представлении, на количество битов, специфицированное вторым операндом, отбрасывая сдвинутые биты.
>>>	(Сдвиг вправо с заполнением нулями) Сдвигает вправо первый операнд, в двоичном представлении, на количество битов, специфицированное вторым операндом, отбрасывая сдвинутые биты и заполняя нулями слева.
Операции Присвоения	=	Присваивает значение второго операнда первому операнду.
+=	Складывает два числа и присваивает результат первому.
-=	Вычитает два числа и присваивает результат первому.
*=	Умножает два числа и присваивает результат первому.
/=	Делит два числа и присваивает результат первому.
%=	Вычисляет целочисленный остаток от деления двух чисел и присваивает результат первому.
&=	Выполняет побитовое AND и присваивает результат первому операнду.
^=	Выполняет побитовое XOR и присваивает результат первому операнду.
|=	Выполняет побитовое OR и присваивает результат первому операнду.
<<=	Выполняет побитовый сдвиг влево и присваивает результат первому операнду.
>>=	Выполняет побитовый сдвиг вправо с сохранением знака и присваивает результат первому операнду.
>>>=	Выполняет побитовый сдвиг вправо с заполнением нулями и присваивает результат первому операнду.
Операции Сравнения	==	Возвращает true, если операнды равны.
!=	Возвращает true, если операнды не равны.
===	Возвращает true, если операнды равны и одного типа.
!==	Возвращает true, если операнды не равны и/или не одного типа.
>	Возвращает true, если левый операнд больше правого.
>=	Возвращает true, если левый операнд больше правого или равен ему.
<	Возвращает true, если левый операнд меньше.
<=	Возвращает true, если левый операнд меньше правого или равен ему.
Специальные Операции	?:	Выполняет простой оператор "if...then...else"
,	Вычисляет два выражения и возвращает результат второго выражения.
delete	Удаляет объект, свойство объекта или элемент по специфицированному индексу в массиве.
new	Создаёт экземпляр объекта определённого пользователем типа или одного из встроенных типов.
this	Ключевое слово, которое можно использовать для обращения к текущему объекту.
typeof	Возвращает строку, указывающую тип невычисленного операнда.
void	Специфицирует выражение, вычисляемое без возвращения значения.

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

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

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

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

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

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

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

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

var++ или ++var

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

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

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

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

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

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

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

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

Реализованы в	JavaScript 1.0
Версия ECMA	ECMA-262

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

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

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

&&	expr1 && expr2	(Логическое AND/И) Возвращает expr1, если может быть конвертировано в false; иначе возвращает expr2. Таким образом, при использовании с Булевыми значениями, && возвращает true, если оба операнда true; иначе возвращает false.
||	expr1 || expr2	(Логическое OR/ИЛИ) Возвращает expr1, если может быть конвертировано в false; иначе возвращает expr2. Таким образом, при использовании с Булевыми значениями, || возвращает true, если хотя бы один из операндов true; если оба false, возвращает false.
!	!expr	(Логическое NOT/НЕ) Возвращает false, если единственный операнд может быть конвертирован в true; иначе возвращает true.

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

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

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

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

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

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

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

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

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

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

var1 % var2

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

New

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

Реализована в	JavaScript 1.0
Версия ECMA	ECMA-262

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

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

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

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

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

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

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

&&	Если первый операнд (expr1) может быть конвертирован в false, операция && возвращает false, а не значение выражения expr1.
||	Если первый операнд (expr1) может быть конвертирован в true, операция || возвращает true, а не значение выражения expr1.

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

Реализованы в	JavaScript 1.0
Версия ECMA	ECMA-262

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

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

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

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

Реализованы в	JavaScript 1.0
Версия ECMA	ECMA-262

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

Таблица 5.2 Сокращённые Операции Присвоения

Сокращённая операция Значение

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.

Реализованы в	JavaScript 1.0 JavaScript 1.3: добавлены операции === и !==
Версия ECMA	ECMA-262 содержит все операции сравнения, за исключением === и !==

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

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

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

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

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

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

Равно (==)	Возвращает true, если операнды равны. Если операнды имеют разные типы, JavaScript пытается конвертировать операнды в подходящий тип для выполнения сравнения.	3 == var1 "3" == var1 3 == '3'
Не равно (!=)	Возвращает true, если операнды не равны. Если операнды имеют разные типы, JavaScript пытается конвертировать операнды в подходящий тип для выполнения сравнения.	var1 != 4 var1 != "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

1 В этих примерах принимается, что var1 имеет значение 3, а var2 имеет значение 4.

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

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

Реализована в	JavaScript 1.0
Версия ECMA	ECMA-262

Если condition равно true, операция

Если condition равно true, операция возвращает значение expr1; иначе она возвращает значение expr2. Например, для вывода различных сообщений на основе значения переменной isMember Вы можете использовать такой оператор:
document.write ("The fee is " + (isMember ? "$2.00" : "$10.00"))

когда Вам нужно включить несколько

Вы можете использовать операцию "запятая", когда Вам нужно включить несколько выражений в таком месте, где требуется одно выражение. Чаще всего эта операция используется для поддержки нескольких параметров в циклах for.
Например, если a это 2-мерный массив из 10 элементов по измерению, следующий код использует операцию, для инкремента двух переменных за раз. Код печатает значения элементов по диагонали массива:
for (var i=0, j=9; i <= 9; i++, j--)
document.writeln("a["+i+","+j+"]= " + a[i,j])

Четвёртая форма верна только внутри

Четвёртая форма верна только внутри оператора 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. Для определения типа объектов создайте функцию, специфицирующую имя, свойства и методы объекта. Объект может иметь свойства, которые сами являются объектами. См. примеры ниже.
Вы всегда можете добавить свойство к ранее определённому объекту. Например, оператор 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"

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

condition	Выражение, вычисляемое в true или false.
expr1, expr2	Выражения со значениями любого типа.

Любые выражения

expr1, expr2

Любые выражения.

Целое число

objectName	Имя объекта.
property	Удаляемое свойство.
index	Целое число - индекс массива.

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

objectName	Имя нового экземпляра объекта.
objectType	Тип объекта. Должна существовать функция, определяющая тип объекта.
param1...paramN	Значения свойств объекта. Эти свойства являются параметрами, определёнными для функции objectType.

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

Реализованы в	JavaScript 1.0
Версия ECMA	ECMA-262

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

Операнды конвертируются в 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 битов (0 и 1), а не как десятеричное, 16-ричное или 8-ричное число. Например, 10-ричное число 9 имеет двоичное представление 1001. Побитовые операции выполняются над такими двоичными представлениями чисел, но возвращают стандартные числовые значения JavaScript.

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

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

AND	a & b	Возвращает 1 в каждой битовой позиции, где оба бита операндов равны 1.
OR	a | b	Возвращает 1 в каждой битовой позиции, где один или оба бита операндов равны 1.
XOR	a ^ b	Возвращает 1 в каждой битовой позиции, где один, но не оба бита операндов равен 1.
NOT	~ a	Инвертирует биты операнда.
Сдвиг влево	a << b	Сдвигает a в двоичном представлении на b битов влево, заполняя справа нулями.
Сдвиг вправо с сохранением знака	a >> b	Сдвигает a в двоичном представлении на b битов вправо, отбрасывая сдвинутые биты.
Сдвиг вправо с заполнением нулями	a >>> b	Сдвигает a в двоичном представлении на b битов вправо, отбрасывая сдвинутые биты и заполняя слева нулями.

Далее идут примеры операции

Вот примеры операции && (логическое И).
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

и экземпляр объекта. Предположим, вы

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

функция validate проверяет значение свойства

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

верно только внутри оператора

delete objectName
delete objectName.property
delete objectName[index]
delete property // верно только внутри оператора with

new objectType

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

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

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

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

Реализована в	JavaScript 1.0
Версия ECMA	ECMA-262

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

This

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

Реализовано в	JavaScript 1.0
Версия ECMA	ECMA-262

Typeof

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

1. typeof operand
2. typeof (operand)

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

Реализована в	JavaScript 1.1
Версия ECMA	ECMA-262

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

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

?: (условная операция)

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

Реализована в	JavaScript 1.0
Версия ECMA	ECMA-262

Void

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

1. void (expression)
2. void expression

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

Реализована в	JavaScript 1.1
Версия ECMA	ECMA-262

Вы можете использовать операцию 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>

---

---