JavaScript Core Compiting выражения и операторы

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

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

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

Эта глава (эта статья) объяснит всех операторов JavaScript. Он также объясняет выражения, которые не включают операторы (такие как доступ к элементам массива и функциональные вызовы), а их синтаксис и стиль программирования очень похожи на выражения C -языка.

1. Элемент выражение

Самое простое выражение - «оригинальное выражение», которое является наименьшей единицей выражения - они не содержат другие выражения. Оригинальные выражения в JavaScript содержат константы или прямые количества. Ключевые слова и переменные.

Прямое количество - это постоянное значение, которое непосредственно появляется в программе. Они выглядят как:

Кода -копия выглядит следующим образом:

1.23 // Прямое количество

"Привет" // Стенд прямое количество

/ pattern/ // регулярное выражение прямое количество

Некоторые зарезервированные слова в JavaScript образуют исходное выражение

Кода -копия выглядит следующим образом:

True // логическое значение: true

Ложь // Неверно

null // возвращать значение: пусто

Это // возвращает объект «текущий»

Благодаря изучению главы 3, в отличие от других ключевых слов, это не постоянное, и значения, которые она возвращает в разных частях программы, также различны. Это ключевое слово часто появляется в объектно-ориентированном программировании. Это возвращает объект квадратного метода.

Наконец, третье оригинальное выражение - переменная

Кода -копия выглядит следующим образом:

я // возвращаю значение переменной i

sum // возвращать значение суммы

неопределенная // - глобальная переменная, в отличие от NULL, это не ключевое слово

2. Выражения инициализации объектов и массивов.

Объект и инициализация массива на самом деле являются вновь созданными объектами и массивами. Эти инициализированные выражения иногда называют «прямым количеством объекта» и «прямым количеством массива». Однако, в отличие от логических прямых величин, они не являются оригинальными выражениями, потому что члены или элементы, которые они содержат, являются подкрасками.

Синтаксис выражения инициализации массива очень прост, давайте начнем ниже

Выражение инициализации массива состоит из пары квадратных кронштейнов и разделенного запятой списка. Результатом инициализации является недавно созданный массив. Элементы массива являются запятыми, разделенными ценностями выражений.

[] // пустой массив; [] Оставить пустым в нем означает, что у массива нет элементов

[1+2,3+4] // массив с двумя элементами, первый - 3, второй - 7

Экспрессия инициализации элемента в экспрессии инициализации массива может быть выражением инициализации массива. То есть выражения могут быть вложены

Кода -копия выглядит следующим образом:

var mat = [[1,2,3], [4,5,6], [7,8,9]];

Элементы между списками в массиве могут быть опущены, а пространство будет заполнено неопределенным. Например:

Кода -копия выглядит следующим образом:

var a = [1 ,,,, 5]

Четыре из элементов не определены. Запятая оставлена ​​в конце прямого количества массива, и новый элемент с неопределенным значением не будет создан.

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

Кода -копия выглядит следующим образом:

var p = {x: 2.1, y: -3} // объект с двумя членами атрибута

var q = {}; // пустой объект

qx = 2,1; qy = -3; // атрибут членов Q такие же, как и у P

Объект также может быть вложенным напрямую, например,

Кода -копия выглядит следующим образом:

var anh = {left: {x: 2, y: 3},

Справа: {x: 4, y: 5}}

Когда JavaScript вычисляет значение выражения инициализации объекта, выражения объекта рассчитываются каждый раз, и они не должны включать постоянные значения: они могут быть каким -либо выражением JavaScript. Точно так же имя свойства в прямом количестве объекта может быть строкой вместо идентификатора. (Это очень полезно, когда только зарезервированные слова или некоторые нелегальные идентификаторы используются в качестве имен атрибутов в этой строке)

Кода -копия выглядит следующим образом:

var side = 1;

var square = {"слева": {x: px, y: py},

'right': {x: p.x+side, y: p.y+side}}

Глава 67 также снова обсудит инициализацию выражений объектов и массивов.

3. Функциональные выражения

Экспрессия определения функции определяет функцию JavaScript. Значение выражения - это недавно определенная функция. В некотором смысле выражения определения функции могут стать прямыми величинами функций, а выражения функций можно назвать «величинами прямой функции», после того как все выражения инициализации объекта также называются «Прямыми количествами объектов». Типичное выражение определения функции содержит функцию ключевого слова, за которой следует пара скобок, список, разделенный запятыми, а список содержит 0 или более идентификаторов (имена параметров). Затем следуйте сегменту кода JavaScript (корпус функции), завернутый в кудрявые скобки.

var square = function (x) {return x*x};

Выражения определения функции также могут содержать имя функции. Функции также могут быть определены операторами функций, а не выражением функций. Больше контента будет описано в главе 8.

4. Выражение доступа атрибута

Операция выражения доступа к атрибуту получает значение объекта или элемента массива. JavaScript определяет два метода доступа к свойствам.

Кода -копия выглядит следующим образом:

выражение . СДЕЛКИ

выражение [выражение]

Первый способ - написать выражение, за которым следует период и идентификатор. Выражение указывает объект, а идентификатор указывает атрибут Mingchuan для доступа.

Глава 2 написана с использованием квадратных кронштейнов, которое является выражением (этот метод подходит для объектов и массивов). Второе выражение указывает на свойство Mingchuan, которое будет доступно, или индекс, представляющий доступ к элементу массива. Вот несколько конкретных примеров

Кода -копия выглядит следующим образом:

ox // => 1x атрибут выражения o

oyz // => 3 z Атрибут выражения oy

o. ["x"] // => 1 объект x атрибут x x attribute

a [1] // => 4 элемент с индексом выражения a равен 1

a [2] ["1"] // => 6 элемент с индексом 1 в выражении a [2]

a [0] .x // => 1: x атрибут выражения a [0]

Независимо от формы используемых выражений доступа атрибута, выражения до «». и "[" всегда оцениваются в первую очередь. Если результат оценки является нулевым или неопределенным, выражение выбросит исключение по ошибке типа, потому что ни одно из этих значений не может содержать никаких атрибутов. Если результат операции не является объектом или массивом, JavaScript преобразует его в объект (Глава 3, раздел 6)

Несмотря на то, что. Identifier написан более проще, следует отметить, что этот метод применяется только к имени атрибута, которое будет доступно, и является законным идентификатором. И вам нужно знать имя атрибута к доступу. Если имя свойства является зарезервированным словом или содержит пробелы и знаки препинания и является номером (для массива), должны быть записаны квадратные кронштейны. Когда имя атрибута является значением, полученным от оператора, а не фиксированного значения, должны быть записаны квадратные кронштейны. (Глава 6, 2, 1 бар)

5. Транспортное выражение

Вызывное выражение в JavaScript представляет собой синтаксисное представление вызова (или выполнения) функции или метода. Это начинается с выражения функции, которое относится к функции, которая должна быть вызвана. Выражение функции сопровождается парой скобок, со списком параметров, разделенных запятыми. Может быть 0 параметров или несколько параметров.

F (0) // F - это выражение функции: 0 является выражением параметров.

Math.max (x, y, z) //math.max - функция; x, y и z - параметры

A.sort () //a.sort () - это функция, которая не имеет параметров.

Когда для оценки требуется выражение, сначала вычислите выражение функции, затем вычислите выражение параметра, чтобы получить набор значений параметров. Если значение выражения функции не является вызовочным объектом, исключение типа ошибки добавляется. Значения параметров затем присваиваются формальным параметрам, которые определяются при определении функции. Затем выполните корпус функции. Если функция использует оператор возврата, чтобы дать возвращаемое значение, то это возвращаемое значение является значением всего вызового выражения. В противном случае значение вызового выражения не определен. Подробная информация о вызове функции - включая количество формальных выражений параметров и количество фактических параметров в определении функции - будет подробно объяснено в главе 8.

Любое вызовое выражение содержит пару скобок и выражений перед левыми скобками. Если это выражение является выражением доступа к свойствам, то этот вызов называется «Приглашение метода». При выполнении корпуса функции в вызове метода объект и массив, доступ к которым доступны в виде атрибутов, являются указателем этого в вызовом методе. Эта функция позволяет функциям (чье имя OO «метод») называть их объект хоста (подробнее по главе 9).

6. Выражение создания объекта

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

новый объект ()

новая точка (2,3)

Если выражение создания объекта не требует каких -либо параметров, которые должны быть переданы в конструктор, то эта пара кронштейнов может быть опущена. Более подробная информация о конструкторе будет объяснена в главе 9

новый объект

новая точка

7. Обзор операторов

Операторы в JavaScript используются для расчета выражений таблицы, выражений сравнения, логических выражений, выражения и т. Д.

Следует отметить, что большинство операторов представлены знаками препинания, такими как Delete и ExtanceOF. Будь то операторы ключевых слов или символические операторы, представленные операторы являются обычными операторами, а их синтаксис очень краткий.

Приоритет оператора индекса сортируется, а приоритет предыдущего оператора выше, чем приоритет последующего оператора. Операторы, разделенные горизонтальным Huafeng, имеют разные приоритеты.

A представляет собой обязательный характер оператора.

L слева направо или R (справа налево)

Список заголовка N представляет количество операндов.

Тип представляет тип ожидаемого операнда и тип результата оператора (после символа "→")

я. Количество операндов

Операторы могут быть классифицированы по количеству операндов.

Большинство операторов в JavaScript являются бинарными операторами, которые объединяют два выражения в немного более сложное выражение.

JavaScript также поддерживает некоторых унарных операторов, которые преобразуют одно выражение в другое немного более сложное выражение. Оператор « -» в выражении -x является неариемным оператором. Это найти отрицательное значение для x.

JavaScript поддерживает тройного оператора: оператор условного суждения "?:", Который объединяет три выражения в одно выражение

II Тип операнда и тип результата

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

III.LVALUE

Операторы назначения и другие немногие операторы в таблице ожидают их типа операнда LVAL, LVALUE - древний термин. Это означает, что «выражения могут появляться только в левой стороне оператора назначения». В JavaScript переменные, свойства объекта и элементы массива - все это lvalues. Спецификация ECMASCRIPT позволяет встроенной функции диапазона возвращать LVALUE, но определенные функции не могут вернуть LVALUE.

IIII. приоритет оператора

В приведенной выше таблице показанные операторы сортируются от высокого до низкого приоритета, причем набор операторов в каждом горизонтальном сепараторе имеет одинаковый приоритет. Оператор управляет приоритетом Орден, в котором выполняются операторы. Операторы с высоким (верхняя часть таблицы) всегда выполняются выше, чем операторы с низким приоритетом (нижняя часть таблицы).

Смотрите следующее выражение

w = x+y*z;

Оператор умножения "*" имеет более высокий приоритет, чем добавление "+", поэтому сначала выполняется умножение. Затем, поскольку оператор назначения "=" имеет самый низкий приоритет. Следовательно, операция назначения выполняется после того, как выражение справа вычисляет результат.

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

w = (x + y) * z;

Следует отметить, что приоритет выражений доступа к собственности и вызовов выше, чем у всех операторов в таблице.

typeof my.function [x] (y)

Хотя TypeOF является одним из самых приоритетных операторов, TypeOF также выполняется после двух доступа к свойствам и функциональных вызовов.

На самом деле, если вы действительно не уверены в приоритете оператора, который вы используете, самый простой способ - использовать садовые скобки для приготовления порядка операций. Некоторые важные правила должны быть запомнены: умножение и деление выше, чем добавление и вычитание, а приоритет операций назначения очень низкий и обычно выполняется последним.

IIIIIII.Operationality

В этом разделе столбец под названием A иллюстрирует узлоподобность оператора. L относится к комбинации слева направо, и R относится к комбинации справа налево. Туберкулез определяет порядок операций в нескольких выражениях оператора с одинаковым приоритетом.

Например, операция вычитания выполняется в комбинации слева направо.

Кода -копия выглядит следующим образом:

w = x - y - z

Как этот код:

Кода -копия выглядит следующим образом:

w = ((x - y) - z)

И наоборот, следующее выражение:

Кода -копия выглядит следующим образом:

x = ~ -y;

w = x = y = z;

Q = A? B: C? D: E? F: G;

Точно так же, как этот код

Кода -копия выглядит следующим образом:

x = ~ (-y);

w = (x = (y = z));

Q = A? B: (C? D: (E? F: G))

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

IIIIIIIIII.Operation Order

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

В выражении w = x+y*z выражение w будет сначала рассчитано, затем будет рассчитано x, y и z, а затем значения y будут умножены на z, добавляя значение x. Наконец, переменная или атрибут, упомянутая его выражением W, упоминается. Добавление круговой кронштейны к выражению изменит взаимосвязь между умножением, добавлением и операциями назначения. Но порядок слева направо не изменится.

8. Арифметические выражения

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

Основными арифметическими операторами являются *, /, %, +, -. В дополнение к +дополнение, другие операторы особенно просты. Они просто преобразуются в цифры при необходимости, а затем они могут найти продукт, коэффициент, остаточный (модуль) и разницу. Все те операции, которые не могут быть преобразованы в числа, будут преобразованы в значения NAN. Если операнд (или результат преобразования) является значением NAN, результат арифметической операции также является NAN

Оператор "/" делит второй операнд на первый операнд, если вы использовали языки программирования, которые различают целое число и плавающее значение. Затем, когда вы делите целое число на целое число, желаемый результат также является целым числом. В JavaScript все числа представляют собой числа с плавающей запятой, а результатом операций деления также являются типы с плавающей запятой. Например, результат 5/2 составляет 2,5, а не 2. Результатом операции с делителем 0 является положительная бесконечность или отрицательная бесконечность. И результатом 0/0 является НАН. Все эти операции не будут сообщать об ошибках.

Оператор «%» вычисляет модуль первого операнда ко второму операнду, другими словами, первый операнд делится на оставшуюся часть второго операнда. Символ результата согласуется с первой операцией мышиной (разделенной) символа. Например, результат 5%2 составляет 1, а -5%2 --1.

Операнды оператора остатков обычно являются целыми числами, но они также подходят для чисел с плавающей запятой. 6,5%2,1 Результат составляет 0,2. (0,19999999999999999973)

я. "+" Оператор

Оператор бинарного добавления "+" может добавить два числа или строковые операции CONCATENATE:

Кода -копия выглядит следующим образом:

1+2 // => 3

"Привет" + "" + "там" // => "Привет"

"1"+"2" // => "12"

Когда оба операнда являются числами или являются строками, результаты расчета очевидны. Однако для других случаев требуется некоторая необходимая конверсия типа. И поведение оператора зависит от результата преобразования типа. Технически говоря, поведение оператора добавления:

Если операнд является объектом, объект будет следовать правилу преобразования объекта в исходное значение в исходное значение класса (см. Главу 3, раздел 8, 3). Дата выполняет преобразование в методе Object ToString (), в то время как другие объекты выполняют преобразование с помощью метода ValueOf () (если метод значения () возвращает примитивное значение). Поскольку большинство объектов не имеют доступного значения () метода, они будут использовать метод ToString () для выполнения ползания

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

В противном случае оба операнда будут преобразованы в числа (или NAN), а затем добавлены.

Вот несколько примеров

Кода -копия выглядит следующим образом:

1 + 2 // => 3 добавление

«1" + "2" // => "12" Строковое соединение

"1" + 2 // => "12" цифры преобразуются в строки и объединяются

1 + {} // => "1 [объект объекта]": объект преобразуется в строку, а затем выполняется конкатенация строки.

true + true // => 2 логическое значение преобразуется в число и добавлено

2 + null // => 2 null преобразовано в 0 и сделайте добавление

2 + неопределенная // => nan undefined конвертируется в NAN для добавления

Наконец, важно отметить. Когда операция знака плюс используется в соответствии с строками, следует учитывать влияние добавления на порядок операций. То есть результат работы зависит от оператора оператора, например,

Кода -копия выглядит следующим образом:

1 + 2 + "bmice" // => "3 bmice"

1 + (2 + "bmice") => "12bmice"

II Унарный оператор

Унарный оператор действует на отдельный операнд. и генерировать новое значение. В JavaScript унарные операторы имеют высокий приоритет и все они правы. В этом разделе описывается неарические операторы (+,-, ++ и-), и при необходимости они преобразуют операции в числа. Следует отметить, что + - является унагорным оператором, а также является бинарным оператором.

Один-юань с добавлением+

Оператор Unary добавления преобразует номер операнда в число (или NAN) и возвращает преобразованный номер. Если сам операнд является номером, то число возвращается напрямую.

Одно вычитание-один-юань-

Когда знак - унарочный оператор, он будет преобразовать операнд в число по мере необходимости, а затем изменит символ результата операции.

Приращение ++

Увеличить оператор «++» для увеличения (+1) операнда, а операнд - это lvalue (переменная, элемент массива или атрибут объекта). Оператор преобразует операнды в числа. Затем добавьте 1 к номеру и переназнайте значение после добавления 1 в переменную, элемент массива или атрибут объекта.

Операция Increment ++ Возвращает значение, зависящее от его позиции на операнде.

Когда оператор находится перед номером операнда, он называется оператором «предварительного вступления», который постепенно вычисляет операнд и возвращает рассчитанное значение.

Когда оператор будет после операнда, он называется оператором «после достижения». Он выполняет постепенные расчеты на операнде, но возвращает незамеченное значение, которое используется для постепенных расчетов. нравиться

var i = 1, j = ++ i // значения i и j оба 2

var i = 1, j = i ++; // i is 2, j - 1

Следует отметить, что сумма ++ x = x+1 точно такая же. Оператор "++" никогда не выполняет операции конкатенации строки. Он всегда будет преобразовать операнд в число и увеличить его на 1. Если x - это строка «1», результатом ++ x является число 2, а x+1 - строка "11"

Операции по снижению и увеличению одинаковы, что преобразует операнды в массив, а затем вычитается на 1.

iii. бит оператор

Оператор битов может выполнять битовые операции нижнего уровня на бинарных данных, представленных числами. Хотя они не являются традиционными чистыми математическими операциями, они также классифицируются здесь как арифметические операторы, потому что они действуют при операциях числовых типов и возвратных чисел. Эти операторы не распространены в JavaScript. (Не описано здесь, пожалуйста, используйте Baidu для получения подробной информации ~-~)

9. реляционные выражения

В этом разделе описывается операторы отношений JavaScript. Реляционные операторы используются для проверки взаимосвязи между двумя значениями (равенство, меньше, чем или «атрибуты») и возвращают истину и ложь в соответствии с тем, существует ли отношения. Реляционные выражения всегда возвращают логическое значение и обычно используют реляционные выражения в IF, когда или для операторов (глава 5) для управления процессом выполнения программы.

В следующих нескольких разделах расскажут о равенстве и неравных операциях, операторах сравнения и двух других символах взаимоотношений в JavaScript в и экземпляре

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

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

JavaScript поддерживает операторы "=", "==", "===", вы должны понимать различия между операторами (назначение, равенство, идентификация). И будьте осторожны при программировании. Чтобы уменьшить путаницу, "=" "" следует называться "Get или Ressage", "==" "должен быть назван" равенным ", а" === "следует назвать" строго равным ".

Правила операторов "! =" И "! ==" - это "==", обратное оператора "===" и "!" логический не оператор. Мы называем "! =", "! ==" неравенны и не строго равны.

Сравнение объектов Javascript - это сравнение ссылок, а не сравнение значений. Объекты и самим себе равны, но они не равны людям и объектам. Если два объекта имеют одинаковое количество атрибутов, одинаковые имена атрибутов и значения, они все еще неравны. Элементы массива в соответствующем положении равны, а два массива также неравны.

Оператор строгого равенства "===" сначала рассчитайте значение операнда, а затем сравните эти два значения. В процессе сравнения нет конверсии.

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

Если оба значения являются нулевыми или неопределенными, они не равны

Если оба значения являются логическими истинными или ложными, они равны

Если одним из значений является NAN, или оба являются NAN, они не равны, а NAN и другие значения не равны, включая себя.

Если два значения являются числами и равны, они равны. Если значение равно 0, а значение --0, они также равны.

Если два значения являются строками, а 16-значные числа (см. Главу 3, 2), содержащиеся в соответствующих битах, точно равны, они равны. Если их длина или содержание отличаются, они не равны. Две строки могут иметь точно такую ​​же функцию, а отображаемые символы одинаковы, но имеют 16-битные значения, которые не кодируются. JavaScript не выполняет стандартные преобразования в Unicode, поэтому такие строки не равны по сравнению с операторами "===" и "==". String.localeCompare () в третьей части предоставляет другой способ сравнения строк.

Если два эталонных значения указывают на один и тот же объект, массив или функцию, они равны. Если указывать на разные объекты, они являются неравенством, хотя эти два объекта обладают одинаковыми свойствами.

Оператор равенства "==" похож на оператора идентификации, но оператор равенства не сравнивается строго. Если два числа не имеют одного и того же типа, оператор равенства пытается сделать какое -то преобразование типа, а затем сравнивает.

Если две операции одинаковы, правила сравнения для операторов равенства, выше, одинаковы. Если строго равны, то результаты сравнения равны. Если они не являются строго равными, результаты сравнения не равны.

Если два типа операций различны, равный оператор «==» также сочтет их равными. Обнаружение равенства будет следовать следующим правилам и конверсии типа:

Если тип нулевой, а другой - не определен, они равны

Если одно значение - это число, а другое - строка, сначала преобразуйте строку в число, а затем используйте конвертированное значение для сравнения.

Если значение верно, оно преобразуется в 1, а затем сравнивается. Если значение неверно, оно преобразуется в 0 и сравнивается.

Если одно значение является объектом, а другое - это число или строка, используйте правила преобразования метода в главе 3, раздел 8, 3, чтобы преобразовать объект в исходное значение, а затем сравнить его. Объект преобразуется в исходное значение с помощью метода ToString () или метода ValueOF (). Встроенные классы в основе языка JavaScript сначала пытаются использовать ValueOf (), а затем попытаются использовать toString (). В дополнение к классу даты, класс даты может быть преобразован только через ToString (). Объекты, которые не находятся в ядре языка JavaScript, преобразуются в исходные значения с помощью методов, определенных в реализации.

Сравнения между другими типами не равны

Вот небольшой пример равного суждения

"1" == true

Результатом этого выражения является истина, что указывает на то, что результаты сравнения совершенно разных типов значений равны. Логическое значение верно сначала преобразовано в число 1, а затем выполняется сравнение. Далее строка «1» также преобразуется в число 1, поскольку значения двух чисел равны, поэтому результат верно.

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

Меньше, чем (<)

Если первый операнд мень.

Меньше или равна (<=)

Больше, чем (>)

Больше или равно (> =)

.... (нет подробного введения в значение)

Операнды оператора сравнения могут быть любого типа. Тем не менее, только числа и строки могут фактически выполнять операторы сравнения, поэтому те операции, которые не являются числами и строками, будут конвертированы типом. Правила конверсии типа следующие:

Если операнд является объектом, он будет преобразован в исходное значение в соответствии с правилами преобразования, описанными в разделе 3, раздел 8, 3: если значение () возвращает примитивное значение, тогда используйте это исходное значение напрямую. В противном случае используйте результат конверсии ToString () для сравнения.

После конвертации в исходное значение, если оба операнда являются строками, две строки будут сравниваться в порядке алфавита. «Порядок алфавита», упомянутый здесь, является индексным порядком 16-битных символов Unicode, которые составляют две строки.

После того, как объект преобразуется в исходное значение, если хотя бы один операнд не является строкой, оба операнда будут сравнивать значения чисел. 0 и -0 равны. Любое другое число в бесконечной стене большое (кроме самого самого), -infinty меньше любого числа (кроме самого себя). Если операнд (или преобразован) является NAN, символ сравнения всегда возвращает ложь

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

Кода -копия выглядит следующим образом:

1 + 2 // => 3 добавление, результат 3 - 3

"1" + "2" // Подключить строку, результат "12"

"1" + 2 // Подключить строку, 2 преобразуется в "2", результат - "12"

11 <3 // Сравнение числа, результат верен

"11" <"3" // Сравнение стойки, результат верен

"11" <3 // Сравнение чисел "11" преобразуется в 11, и результат правда

«Один» <3 // Сравнение номеров, «один» преобразуется в NAN, и результат является ложным

Наконец, следует отметить, что при оценке равенства операторы «<=» и «> =» не полагаются на оператора равенства и правила сравнения операций строгого равенства. Напротив, оператор ZHI, который меньше или равен, является просто «не больше, чем», в то время как операция, которая больше или равна, является только «не меньше, чем». За одним исключением, когда операнд (после конвертированного) - NAN, все 4 оператора сравнения вернут Fasle.

III.in оператор

Оператор In хочет, чтобы его левый операнд был строкой или может быть преобразован в строку, и надеется, что это объект справа. Если объект справа имеет имя атрибута, называемое значением левого операнда, выражение возвращает true. Например

Кода -копия выглядит следующим образом:

var point = {

x: 1,

Y: 1

} // Определить объект

"x" в точке // => true У объекта есть свойство с именем x

«z» в точке // => false У объекта нет атрибута имени Z

"ToString" в точке // => истинном объекте наследует метод ToString

VAR DATA = [7, 8, 8]

"0" в data // => true, массив содержит 0

1 в data // => true преобразовать номер в строку

3 в Data // => Fase No Element с индексом 3

IIII.INSTANCE OPERATOR

Оператор экземпляра хочет, чтобы левый оператор был объектом, а правый операнд указывает класс объекта. Если объект слева является экземпляром класса справа, выражение возвращает true; Это несет ответственность за возврат false. Глава 9 расскажет об этом. Классы объектов Javascript определяются путем инициализации их конструкторов. Таким образом, правильный операнд экземпляра должен быть функцией. например:

Кода -копия выглядит следующим образом:

var d = new Date (); // построить новый объект

D экземпляр даты; // Результат расчета верно, D создается датой ()

d instanceof Object //计算结果为true ,所有的对象都是Object的实例

d instanceof Number //计算结果为false，d不是一个Number对象

var a = [1,2,3] //数组直接量创建数组

a instanceof Array //计算结果true a为数组

a instanceof Object //true 所有的数组都是对象

a instanceof RegExp //fasle 数组不是正则表达式

需要注意的是，所有对象都是Object的实例。当通过instanceof盘对一个对象是否为一个类的实例的时候，这个判断也叫“父类”(superclass)的检测，如果instanceof的左侧操作对象不是对象的话，instanceof返回false。如果右侧操作不是函数，则抛出类型错误的异常。

为了理解instanceof运算符是如何工作的，必须首先理解“原型类”（prototype chain），原型链作为javascript的继承机制，将在6章2节2小节详细描述。

为了计算表达式o instanceof f ,javascript笔仙首先计算f.prototyoe,然后在原型链中查询o,如果找到，那么o是f（或者f的父类）的一个实例，那么返回true。反之false

10.逻辑表达式

逻辑运算符"&&"、“||”、“!”是对操作进行布尔算术运算，经常和关系运算符一起配合使用，逻辑运算符将多个关系表达式组合起来组成一个更复杂的表达式。

я. Logic and

"&&"运算符可以从三个不同的层次进行理解。最简单一层理解是，当操作数都是布尔值是，“&&”对两个布尔值执行布尔与（AND）操作，只有在第一个操作数和第二个操作数都是true的时候，它才返回true.如果其中有一个操作数为false.则它返回false.

"&&"长用来连接两个关系表达式

x == 0 && y == 0; //只有在x和y都是0时，才返回true

关系表达式总是返回true或false,因此当这样使用的时候，“&&”本身也返回true或false。关系运算符的优先级要比"&&"（和“||”）要高，因此类似这种表达式可以放心地书写，而不用补充园括号。

"&&"操作数并不一定是布尔值，回想一下，有些值是可以当做“真值”和“假值”的。（如3章3节，假值是:false null undefined 0 -0 NaN和""，所有和其它的值包括所有的对象都是真值）。对“&&”第二层理解是，“&&”是可以对真值和假值进行布尔与（AND）操作。如果两个操作数都是真值的，则那么返回一个真值；否则，至少一个操作数是假值的。javascript中在任何使用布尔值的地方的时候，表达式语句都会将其当做真值或假值来对待，因此实际上“&&”并不总是返回true和false.但也并无大碍。

需要注意的是，上文提到了运算符返回“真值”和“假值”，但并没说说明这个“真值”或者“假值”到底是什么值，为此我们深入讨论对“&&”第三层的理解。运算符首先计算左操作数的值，即首先计算“&&”左侧的表达式，如果计算结果是假值，那么整个表达式的结果一定是假值，因此“&&”这时简单的返回左操作的值，而并不会对右边的操作数进行计算。

Кода -копия выглядит следующим образом:

var o = {

x: 1

};

var p = null;

o && ox; //=>1 : 1:0是真值，因此返回值是ox

p && px //= null :p是假值，因此将其返回，而并不计算px

这对于理解“&&”可能不计算右操作数的情况至关重要，在上述代码中，变量P的值是null，而如果计算px的话则会抛出一个异常错误，因此，只有p为真值（不能是null或undefined）的情况下才计算px

"&&"的行为有时候被称为“短路”（short circuiting）,我们经常能看到很多代码利用了这一也行来有条件的执行代码。例如下面的两条代码是等价的

Кода -копия выглядит следующим образом:

if (a == b) stop(); //只有a==b时才能调运stop()

(a == b) && stop(); //同上

一般来讲，当“&&”右侧的表达式具有副作用的时候（赋值，递增，递减和函数调用表达式）要格外小心。因为这些带有副作用的表达式的执行时候，依赖于左操作鼠的计算结果。

尽管“&&”可以按照第二层和第三层的理解进行一些复杂的表达式运算，但大多数的情况下，“&&”仅用来对真值和假值的做布尔计算。

II Logical or (||)

"||"运算符对两个操作数做布尔或（OR）运算。如果其中一个为真值，则返回真值，两个操作数都为假值，返回假值。

尽管“||”运算符大多情况下只是做简单的布尔或（OR）运算，和“&&”一样，也具备一些更复杂的行为，它首先计算第一个操作数的值，也就是说回首先计算左侧的表达式，如果计算结果为真，则返回真值，否则，再计算第二个值。

和“&&”一样，用于应该避免右操作数包含一些具有副作用的表达式，除非你目地明确在右侧使用带副作用的表达式，而有可能不会计算右侧的表达式。

这个运算符最常用的方式是用来从一组备选的表达中选取第一个真值的表达式。

Кода -копия выглядит следующим образом:

//如果max_width已经定义了，则直接使用它。赋值在preferences对象中查找max_width

//如果没有定义它，则使用一个写死的常量。

var max =max_width || preferences.max_windth || 500;

这种贯用法通常在函数体内，用来给参数提供默认值。

Кода -копия выглядит следующим образом:

//将o成功的属性复制到p中，并返回p

function copy(o, p) {

p = p || {}; //如果向参数p没有传入任何对象，则使用一个新创建对象。

//函数体内的主逻辑

iii.逻辑非(!)

"!"运算符是一元运算符，它放置在一个单独操作数之前。它的目的是将操作数的布尔值求反。

Unlike the "&&" and "||" operators, the "!" operator first converts its operands into a Boolean value (see the Rules in Chapter 3), and then inverses the Boolean value. То есть, "!" always returns true and false. Furthermore, the Boolean value of a value can be obtained by using two logical non-operations: (!!x, refer to Section 8, Section 2, Chapter 3)

“!”具有很高的优先级，并且和操作数紧密的绑在一起，如果希望对p && q，则需要园括号!(p && q)。如下代码：

Кода -копия выглядит следующим образом:

!(p && q) === !p || !q

!(p || q) === !p && !q

对于p和q取任何值，这两个表达式永远成立。

11.赋值表达式

javascript使用"="运算符给变量或者属性来赋值，例如：

Кода -копия выглядит следующим образом:

i = 0 //将变量i设置为0

ox = 1 //将对象o的属性x 设置为1

“=”运算符希望它的左操作数为一个左值：一个变量或者对象属性（或数组元素），它的右操作鼠可以是任意的类型的任意值。赋值表达式的值就是右操作数的值。赋值表达式的副作用是，右操作数的值赋值给左侧的变量或对象属性。这样的话，后续对这个变量和对象的属性的引用都将得到这个值。

尽管赋值表达式的值非常简单，但有时候会看到一些复杂表达式包含赋值表达式的情况。例如：将赋值和检测操作放在一个表达式中：

Кода -копия выглядит следующим образом:

(a = b) == 0

如果这样的话，应该清楚地知道"="和"=="区别！，需要注意的是，“=”有非常低的优先级，通常在一个较长的表达式中用到一条赋值语句时，需要补充园括号以保障正确的运算顺序。

赋值操作符的结合性是从右至左，也就是说，一个表达式中出现了多个赋值运算符，运算顺序也从右至左，因此，可以通过以下方式对多个变量赋值。

Кода -копия выглядит следующим образом:

i=j=k=0; //把三个变量初始化为0

带操作的赋值运算：

除了常规的赋值运算外，javascript还支持需要其他的赋值运算符，这些运算符将赋值运算符合其他的运算符连接起来。提供一种更为快捷的运算方式。例如+=运算符执行的是加法运算符和赋值操作，下面的表达式：

total += salaes_tax;

和下面的表达式等价的

total = total + salaes_tax

运算符“+=”可以作用于数字或字符串，如果其操作是数字，它将执行加法运算和赋值操作；如果是字符串，他就执行字符串的连接和赋值操作。

此类型的运算符还包括，"-=","*=","&="等，如下表赋值运算符

运算符示例等价于

+=a+=ba=a+b

-=a-=ba=ab

*=a*=ba=a*b

/=a/=ba=a/b

%=a%=ba=a%b

<<=a<<=ba=a<<b

>>=a>>=ba=a>>b

>>>=a>>>=ba=a>>>b

&=a&=ba=a&b

|=a|=ba=a|b

^=a^=ba=a^b

大多数情况下，表达式为

a op =b

这里的op代表一个运算符，这个表达式等价于

a =a op b

在第一行中，表达式a计算了一次，在第二行中，表达式a计算了两次。

只有a包含具有副作用的表达式（比如函数调用和赋值操作）的时候，两者才不等价。如下两个表达式不等价

Кода -копия выглядит следующим образом:

data[i++] *= 2;

data[i++] = data[i++] * 2

12.表达式计算

和很多解释性语言一样，javascript同样可以解释运行由javascript源代码组成的字符串，并产生一个值。javascript通过全局函数eval()来完成这个工作。

eval("3+2") //=>5

动态判断源代码中的字符串是一种强大语言的特性，几乎没有必要在实际中应用。如果你使用了eval()，你应该仔细考虑真的需要它。

下面降价eval()基础用法，并介绍两种严格使用它的方法，从代码优化的角度来讲，这两种方法对原有的代码影响是最小的。

i.eval （eval()是一个函数，但由于它已经被当做运算符来对待了。）

eval()只有一个参数，如果传入的参数不是字符串，它直接返回这个参数。如果参数是字符串，它会把字符串当成javascript进行编译(parse)，如果编译失败则抛出一个语法错误(SyntaxError)。如果编译成功，则开始执行这段代码，并返回字符串中最后一个表达式或语句的值，如果最后一个表达式没有语句或者值，则最终返回undefined。如果字符串抛出一个异常，这个异常把该调用的传给eval()

关于eveal()最重要的是，它使用了调用它的变量作用域环境，也就是说，它查找变量的值和定义新变量和函数的操作和局部的代码作用域中的代码一样。如果一个函数定义了一个局部变量x,然后调用了eval("x"),它会返回局部变量的值。如果它调用eval("x=1"),它会改变局部变量的值。如果函数调用了eval("var y=3;")它声明一个新的局部变量y。同样的，一个函数可以通过如下代码声明一个局部函数：

eval("function f(){return x+1;}");

如果最顶层的代码中调用了eval()。当然它会作用于全局变量和全局函数。

II Global eval()

eval()具有改变局部变量的能力，这对javascript优化器来说，是一个很大的问题，然而作为一种权宜之计，javascript征对那行调用了eval()函数所做的优化并不多。但当脚本定义了一个别名，并且用令一个名称来调用它，javascript解释器又如何工作呢，为了javascript解释器更加简化。ECMAScipt3标准规定了任何解释器都不允许对eval()赋予别名。如果eval()使用别的别名来调用的话，则会抛出EvalError异常。

实际上，大多数的实现并不是这样做的。当通过别名调用时，eval()会将其字符串当成顶层的全局代码来执行。执行代码可能会定义新的全局变量和全局函数。执行的代码可能会定义新的全局变量和全局函数，或者给全局变量赋值。但却不能修改或修改主调函数中的局部变量，因此这不会影响到函数内的代码优化。

ECMAScript5是反对使用EvalError的，并且规范了eval()的行为。“直接的eval”，当直接使用非限定的“eval”名称，来调用eval()函数时，它总共是在它的上下文作用域内支线。其它间接调用则使用全局函数为其上下文作用域。并且无法读、写、定义局部变量和函数。下面有一段代码实例：

Кода -копия выглядит следующим образом:

var geval = eval; //使用别名调用eval将是全局eval

var x = "global",

y = "global"; //两个全局变量

function f() { //函数内执行的局部eval

var x = "local" //定于局部变量

eval("x += 'changed';"); //直接eval更改了局部变量的

возврат x; //Return the changed local variable

}

function g() { //这个函数执行了全局eval

var y = "local" //定义了局部变量

geval("y += 'changed';"); //间接改变了局部变量的值

return y; //返回未更改的局部变量

}

console.log(f(), x); //更改了局部变量，输出local changed global

console.log(g(), y); //更改了全局变量，输出local globalchanged

13.其它运算符。

javascript支持很多其它各种各样的运算符。

я. Conditional operator (?:)

The conditional operator is the only ternary operator in javascript. Usually this operator is written as "?:". This operator has the third operand, the first operand is before "?", and the second operand is between "?" и ":". The third operand is long after ":", e.g.

x > 0 ? x : -x; //求x的绝对值

条件运算符的操作数可以是任意类型。第一个操作数当成布尔值，如果它是真值，那么将计算第二个操作数，并返回计算结果。赋值如果第一个值操作数是假值，那么将计算第三个操作数。并返回计算结果。第二个和第三个操作数总会计算其中之一。不可能两者同时进行。其实使用if语句也达到同样的效果(5.4.1),“?:”运算符只是提供了一种简写形式。这里是一个"?:"的典型使用场景，判断一个变量是否有定义，如果有定义则使用它，如果无定义，则使用一个默认值。

Кода -копия выглядит следующим образом:

grett = "hello" + (username ? username : "three");

和以下的代码是等价的，但上面的更加简洁

Кода -копия выглядит следующим образом:

grett = "hello";

if (username)

grett += username;

еще

grett + "three"

ii.typeof()运算符

typeof是一元运算符，放在单个操作数前面，操作数可以是任何类型，返回值表示操作类型的一个字符串。

Кода -копия выглядит следующим образом:

x __ typeof x

undefined __ "undefined"

null __ "object"

ture或false __"boolean"

任意数字或NaN __ "Number"

任意字符串__ "String"

任意函数__ "function"

任意内容对象（非函数）__ "object"

任意宿主对象__ 由编译器各自实现的字符串，但不是"undefined" "boolean" "number" "string"

typeof最常用的用法写在表达式中们就像这样

(typeof value == "string") ? "" + value + "":value;

typeof运算符同样在swith语句中（5.4.3）非常有用，需要注意的是，typeof运算可以带上园括号。这样让typeof看起来像一个函数名，而非关键字

typeof(i)

iii.delete运算符

delete是一元操作符，它用来删除对象的属性或者数组的元素。就像赋值、递增、递减运算符一样。delete也是具有副作用的。它是用来做删除操作的。不是用来返回一个值的。

Кода -копия выглядит следующим образом:

var o = {

x: 1,

y: 2

}

delete ox;

"x" in o; //=>false

var a = [1, 2, 3];

delete a[2]; // 删除数组中最后一个元素

2 in a; //=> false 元素2已经在数组中不存在了

a.length; //=>3,注意，数组长度并没有改变，尽管上一行删除了这个元素，但删除操作留下了一个洞。实际上并没有修改数组的长度，因此a的长度仍然为3

需要注意的是，删除属性或删除数组元素不仅仅设置了一个undefined值，当删除一个属性时，这个属性不复存在。读取一个不存在的值将会返回undefined.关于delete删除还有严格模式下的一些情况，需要学习的人自己试验，这里给一些例子。

Кода -копия выглядит следующим образом:

var o = {x: 1,y: 2};

delete ox; //删除一个对象属性，返回true

typeof ox; //属性不存在，返回"undefined"

delete ox; //删除不存在的属性，返回true;

delete o; //不能删除通过var关键字声明的变量，返回false

delete 1; //参数不是一个左值。

this.x = 1;// 给全局定义一个属性，这里没有使用var

delete x ; //试图删除它，在非严格模式下返回true

//在严格模式下回抛出异常，这时使用"delete this.x"来代替

x; //运行时出错，没有定义x

6章第三节还有关于delete的讨论。

iii.void运算符。

void是一元运算符，在出现操作数之前，操作数可以是任何类型。这个运算符并不是经常使用：操作数会照常计算，但会忽略计算结果并返回undefined。由于void会忽略操作数的值，因此在操作数具有副作用时使用void来程序更有意义。

这个最常用的带客户端url.在url写带有副作用的表达式，而void则让浏览器不显示在这个表达式的运算结果。

Кода -копия выглядит следующим образом:

<a href="javascript:void window.open();">new</a>

iiii.逗号运算符。(,)

逗号运算符是二元运算符，它的操作数可以是任意类型。它首先计算左操作数，然后计算右操作数。

Кода -копия выглядит следующим образом:

i = 0, j = 1, k = 2;

它和下面的代码基本上等价的

i = 0; j = 1; k = 2;

总是会计算左侧的表达式，但计算结果忽略掉，也就是说，只有左侧表达式具有副作用，才会使用逗号运算让代码变得更通畅。逗号运算符最常用的场景是for循环中，这个for循环通常有多个循环变量。

Кода -копия выглядит следующим образом:

//for循环中的第一个逗号是var语句的一部分

//第二个逗号是逗号运算符

//它将两个表达式(i++和j++)放在一条(for循环中)语句中

for (var i = 0, j = 10; i < j; i++, j--);

console.log(i + j);