Синтаксис JavaScript - JavaScript syntax

В синтаксис из JavaScript - это набор правил, которые определяют правильно структурированную программу JavaScript.

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

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

Происхождение

Брендан Эйх обобщил происхождение синтаксиса в первом абзаце спецификации JavaScript 1.1^[1][2] следующее:

JavaScript заимствует большую часть своего синтаксиса у Ява, но также наследуется от Awk и Perl, с некоторым косвенным влиянием Себя в своей системе прототипов объектов.

Основы

Чувствительность к регистру

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

Пример:

вар а=5;консоль.бревно(а); // 5консоль.бревно(А); // выдает ошибку ReferenceError: A не определено

Пробелы и точки с запятой

В отличие от C, пробелы в исходном коде JavaScript могут напрямую влиять на семантика. Точка с запятой конечные операторы в JavaScript. Из-за "автоматического вставка точки с запятой "(ASI), некоторые операторы, которые правильно сформированы при синтаксическом анализе новой строки, будут считаться завершенными, как если бы точка с запятой была вставлена ​​непосредственно перед новой строкой. Некоторые специалисты рекомендуют явно указывать точку с запятой в конце оператора, потому что это может уменьшить нежелательные эффекты автоматическая вставка точки с запятой.^[3]

Есть две проблемы: пять токенов могут либо начинать оператор, либо быть продолжением полного оператора; и пять ограниченных производств, где разрывы строк не разрешены в определенных позициях, что потенциально может привести к неправильному синтаксическому анализу.^[4]

Пять проблемных токенов - открытая скобка "(", открытая скобка"[", косая черта"/", плюс"+", и минус"-". Из них открытая скобка часто встречается в немедленно вызываемое выражение функции шаблон и открытая скобка встречается иногда, в то время как другие встречаются довольно редко. Пример, приведенный в спецификации:^[4]

а = б + c(d + е).фу()// Рассматриваемый как:// a = b + c (d + e) ​​.foo ();

с предложением завершить предыдущий оператор точкой с запятой.

Некоторые предлагают вместо этого использовать ведущий точки с запятой в строках, начинающихся с '(' или же '[', поэтому строка не случайно соединяется с предыдущей. Это известно как защитная точка с запятой, и особенно рекомендуется, потому что иначе код может стать неоднозначным при его изменении.^[4][5] Например:

а = б + c;(d + е).фу()// Рассматриваемый как:// a = b + c;// (d + e) ​​.foo ();

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

Пять ограниченных постановок: возвращаться, бросать, перемена, Продолжить, и постинкремент / декремент. Во всех случаях установка точки с запятой не устраняет проблему, но делает синтаксис понятным, что упрощает обнаружение ошибки. возвращаться и бросать взять необязательное значение, а перемена и Продолжить возьмите необязательную этикетку. Во всех случаях рекомендуется оставлять значение или метку в той же строке, что и оператор. Чаще всего это проявляется в операторе return, где можно вернуть литерал большого объекта, который может быть случайно помещен, начиная с новой строки. Для постинкремента / декремента существует потенциальная двусмысленность с пре-инкрементом / декрементом, и снова рекомендуется просто оставить их в одной строке.

возвращатьсяа + б;// Возвращает undefined. Рассматриваемый как://   возвращаться;// a + b;// Следует записать как:// возврат a + b;

Комментарии

Комментарий синтаксис такой же, как в C ++, Swift и многие другие языки.

// короткий однострочный комментарий/ * это длинный многострочный комментарий  по поводу моего сценария. Пусть однажды  быть великим. * // * Комментарии / * не могут быть вложенными * / Синтаксис ошибка */

Переменные

Переменные в стандартном JavaScript нет тип прилагается, и любое значение может быть сохранено в любой переменной. До ES6 переменные объявлялись только с вар утверждение. Начиная с ES6, версия языка, завершенная в 2015 году, переменные также можно объявлять с помощью позволять или же const которые для уровень блока переменные. Значение, присвоенное const нельзя изменить, но его свойства можно. An идентификатор должен начинаться с буквы, подчеркивания (_) или знак доллара ($); последующие символы также могут быть цифрами (0-9). Поскольку JavaScript чувствителен к регистру, символы верхнего регистра от «A» до «Z» отличаются от символов нижнего регистра от «a» до «z».

Начиная с JavaScript 1.5, ISO 8859-1 или же Unicode буквы (или uXXXX Управляющие последовательности Unicode) могут использоваться в идентификаторах.^[6] В некоторых реализациях JavaScript знак at (@) может использоваться в идентификаторе, но это противоречит спецификациям и не поддерживается в новых реализациях.

Определение объема и подъем

Переменные, объявленные с помощью вар находятся лексически ограниченный в функциональный уровень, а с позволять или же const есть уровень блока объем. Объявления обрабатываются до выполнения любого кода. Это эквивалентно тому, что переменные заявленный форвард в верхней части функции или блока и называется подъем.^[7]

С вар значение переменной неопределенный пока он не будет инициализирован, и прямая ссылка это невозможно. Таким образом вар Икс = 1 оператор в середине функции эквивалентен вар Икс оператор объявления в верхней части функции и Икс = 1 оператор присваивания в этот момент в середине функции - поднимается только объявление, но не присваивание. Переменные, объявленные с помощью позволять или же const не устанавливайте значение на неопределенный, поэтому, пока она не будет инициализирована, обращение к переменной вызовет ошибку.

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

Обязательно поймите это

вар func = функция() { .. } // НЕ будет поднятфункция func() { .. } // будет поднят

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

Декларация и уступка

Переменные, объявленные вне любой функции: Глобальный. Если переменная объявлена ​​в более высокой области видимости, к ней могут получить доступ дочерние функции.

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

Когда назначение идентификатор, JavaScript выполняет точно такой же процесс для получения этого идентификатора, за исключением того, что если он не найден в глобальный масштаб, он создаст "переменную" как свойство глобальный объект.^[8] Как следствие, никогда не объявленная переменная будет глобальной, если она назначена. Объявление переменной (с ключевым словом вар) в глобальный код (т.е. вне тела функции), присвоение никогда не объявляемого идентификатора или добавление свойства к глобальный объект (обычно окно) также создаст новую глобальную переменную.

Обратите внимание, что JavaScript строгий режим запрещает присвоение необъявленной переменной, что позволяет избежать загрязнения глобального пространства имен. Также const не может быть объявлен без инициализации.

Примеры

Вот примеры объявления переменных и области действия:

вар Икс = 0; // Глобальная переменная, потому что ее нет ни в одной функциифункция ж() {  вар z = 'лисы', р = 'птицы'; // 2 локальные переменные  м = 'рыбы'; // глобальный, потому что он нигде раньше не объявлялся  функция ребенок() {    вар р = 'обезьяны'; // Эта переменная является локальной и не влияет на "птички" r родительской функции.    z = 'пингвины'; // Закрытие: дочерняя функция имеет доступ к переменным родительской функции.  }  20 = 20; // Эта переменная объявлена ​​в следующей строке, но может использоваться в любом месте функции, даже до того, как здесь  вар 20;  ребенок();  возвращаться Икс; // Здесь можно использовать x, потому что он глобальный}ж();консоль.бревно(z); // Эта строка вызовет исключение ReferenceError, потому что значение z больше не доступно

за (позволять я=0;я<10;я++) консоль.бревно(я);консоль.бревно(я); // выдает ошибку ReferenceError: i не определен

за (const я=0;я<10;я++) консоль.бревно(я); // выдает TypeError: присвоение постоянной переменнойconst число Пи; // выдает SyntaxError: в объявлении const отсутствует инициализатор

Примитивные типы данных

Язык JavaScript предоставляет шесть примитивные типы данных:

• Неопределенный
• Ноль
• Число
• Нить
• Булево
• Символ

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

Неопределенный

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

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

вар тест;                         // переменная объявлена, но не определена, ...                                  // ... установить значение undefinedвар testObj = {};консоль.бревно(тест);                // тестовая переменная существует, но значения нет ...                                  // ... определено, отображается неопределенноеконсоль.бревно(testObj.myProp);      // testObj существует, а свойства нет, ...                                  // ... отображает undefinedконсоль.бревно(неопределенный == ноль);   // не принудительный тип во время проверки, отображает trueконсоль.бревно(неопределенный === ноль);  // применять тип во время проверки, отображает false

Примечание. Для undefined нет встроенного языкового литерала. Таким образом (Икс == неопределенный) не надежный способ проверить, не определена ли переменная, потому что в версиях до ECMAScript 5 кто-то может написать вар неопределенный = "Я определился сейчас";. Более надежный подход - сравнить, используя (тип Икс === 'неопределенный').

Подобные функции не будут работать должным образом:

функция isUndefined(Икс) { вар ты; возвращаться Икс === ты; }             // так...функция isUndefined(Икс) { возвращаться Икс === пустота 0; }               // ... или второйфункция isUndefined(Икс) { возвращаться (тип Икс) === "неопределенный"; } // ... или третий

Здесь звоню isUndefined (my_var) поднимает ReferenceError если my_var неизвестный идентификатор, тогда как тип my_var === 'неопределенный' нет.

Ноль

В отличие от undefined, ноль часто устанавливается, чтобы указать, что что-то было объявлено, но определено как пустое. В логическом контексте значение null считается ложным значением в JavaScript.

Примечание. Null - это настоящий примитивный тип в языке JavaScript, из которого ноль (обратите внимание на регистр) - это единственное значение. Таким образом, при выполнении проверок, требующих проверки типов, значение NULL не будет равняться другим типам false. Как ни странно, ноль считается объектом тип.

консоль.бревно(ноль == неопределенный);        // не принудительный тип во время проверки, отображает trueконсоль.бревно(ноль === неопределенный);       // применять тип во время проверки, отображает falseконсоль.бревно(тип ноль === 'объект'); // истинный

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

Число

Числа представлены в двоичном виде как IEEE-754 удваивается, что обеспечивает точность почти 16 значащие цифры. Потому что они плавающая точка числа, они не всегда точно представляют действительные числа, в том числе дроби.

Это становится проблемой при сравнении или форматировании чисел. Например:

консоль.бревно(0.2 + 0.1 == 0.3); // отображает false в соответствии со спецификациями ECMASCRIPT 6консоль.бревно(0.94 - 0.01);      // отображает 0,9299999999999999

В результате такая рутина, как toFixed () следует использовать метод округления чисел, когда они отформатирован для вывода.

Числа могут быть указаны в любом из следующих обозначений:

345;    // целое число, хотя в JavaScript есть только один числовой тип34.5;   // число с плавающей запятой3,45e2; // другое число с плавающей запятой, эквивалент 3450b1011; // двоичное целое число, равное 110o377;   // восьмеричное целое число 2550xFF;   // шестнадцатеричное целое число, равное 255, цифры представлены ...        // ... буквы A-F могут быть в верхнем или нижнем регистре

Экстенты +∞, −∞ и NaN (Не число) числового типа можно получить двумя программными выражениями:

бесконечность; // положительная бесконечность (отрицательная, полученная, например, с -Infinity)NaN;      // Значение Not-A-Number, также возвращенное как сбой в ...          // ... преобразование строки в число

Бесконечность и NaN - это числа:

тип бесконечность;   // возвращает "число"тип NaN;        // возвращает "число"

Эти три специальных значения соответствуют и ведут себя как IEEE-754 описывает их.

Конструктор Number или унарный + или - может использоваться для выполнения явного числового преобразования:

вар myString = "123.456";вар myNumber1 = Число(myString);вар myNumber2 = +myString;

При использовании в качестве конструктора числовой обертка объект создан (правда, малопригодный):

myNumericWrapper = новый Число(123.456);

Однако нельзя использовать операторы равенства (== и ===), чтобы определить, является ли значение NaN:

консоль.бревно(NaN == NaN);   // ложныйконсоль.бревно(NaN === NaN);  // ложныйконсоль.бревно(isNaN(NaN));   // истинныйвар а = NaN;консоль.бревно(а == а);       // ложный

Нить

А нить в JavaScript - это последовательность символов. В JavaScript строки можно создавать напрямую (как литералы), помещая серию символов между двойными (") или одинарными (') кавычками. Такие строки должны быть записаны в одной строке, но могут включать в себя экранированные символы новой строки (например, n). Стандарт JavaScript позволяет обратная цитата символ (`, a.k.a. серьезный ударение или обратная кавычка) для цитирования многострочных буквальных строк, но с 2016 года это поддерживается только в определенных браузерах: Firefox и Chrome, но не в Internet Explorer 11.^[9]

вар приветствие = "Привет, мир!";вар другой = «Привет, люди Земли».;

Доступ к отдельным символам в строке можно получить с помощью диаграмма метод (предоставленный String.prototype). Это предпочтительный способ доступа к отдельным символам в строке, потому что он также работает в несовременных браузерах:

вар час = приветствие.диаграмма(0);

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

вар час = приветствие[0];

Однако строки JavaScript неизменный:

приветствие[0] = "ЧАС"; // Ошибка.

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

вар Икс = "Мир";вар сравнить1 = ("Привет, " +Икс == "Привет, мир"); // Здесь compare1 содержит истину.вар сравнить2 = ("Привет, " +Икс == "Привет, мир"); // Здесь compare2 содержит ...                                                 // ... ложь, поскольку ...                                                 // ... первые символы ...                                                 // ... обоих операндов ...                                                 // ... разные случаи.

Цитаты одного типа не могут быть вложены, если они не сбежал.

вар Икс = '"Привет, мир!" он сказал.'; // Просто хорошо.вар Икс = ""Привет, Мир!" он сказал."; //  Фигово.вар Икс = "" Привет, мир!  "Сказал он."; // Работает, экранируя "с "

Можно создать строку, используя Нить конструктор:

вар приветствие = новый Нить("Привет, мир!");

Эти объекты имеют значение метод, возвращающий заключенную в них примитивную строку:

вар s = новый Нить("Привет !");тип s; // Является объектом.тип s.значение(); // Строка.

Равенство между двумя Нить объекты не ведут себя как строковые примитивы:

вар s1 = новый Нить("Привет !");вар s2 = новый Нить("Привет !");s1 == s2; // Ложь, потому что это два разных объекта.s1.значение() == s2.значение(); // Правда.

Булево

JavaScript обеспечивает Логический тип данных с истинный и ложный литералы. В тип оператор возвращает строку "логическое" для этих примитивные типы. При использовании в логическом контексте 0, -0, ноль, NaN, неопределенный, а пустая строка ("") оценить как ложный из-за автоматического принуждение типа. Все остальные значения ( дополнять из предыдущего списка) оценивается как истинный, в том числе струны "0", "ложный" и любой объект. Автоматическое приведение типа операторами сравнения равенства (== и !=) можно избежать, используя операторы сравнения с проверкой типа (=== и !==).

Когда требуется преобразование типа, JavaScript преобразует Булево, Число, Нить, или же Объект операнды следующим образом:^[10]

Число и строка

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

Булево

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

Объект

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

Дуглас Крокфорд защищает термины «правдивость» и «ложь» для описания поведения значений различных типов при оценке в логическом контексте, особенно в отношении крайних случаев.^[11]Бинарные логические операторы возвращали логическое значение в ранних версиях JavaScript, но теперь вместо этого они возвращают один из операндов. Левый операнд возвращается, если его можно вычислить как: ложный, в случае соединение: (а && б), или же истинный, в случае дизъюнкция: (а || б); в противном случае возвращается правый операнд. Автоматическое приведение типов операторами сравнения может отличаться для случаев смешанных логических и числовых операндов (включая строки, которые могут быть оценены как число, или объекты, которые могут быть оценены как такая строка), потому что логический операнд будет сравниваться как числовое значение. Это может быть неожиданно. Выражение может быть явно приведено к логическому примитиву путем удвоения логического оператор отрицания: (!!), с использованием Логический () функцию или используя условный оператор: (с? т: ж).

// Автоматическое приведение типаконсоль.бревно(истинный  ==   2 ); // ложь ... истина → 1! == 2 ← 2консоль.бревно(ложный ==   2 ); // ложь ... ложь → 0! == 2 ← 2консоль.бревно(истинный  ==   1 ); // истина .... истина → 1 === 1 ← 1консоль.бревно(ложный ==   0 ); // истина .... ложь → 0 === 0 ← 0консоль.бревно(истинный  ==  "2"); // ложь ... истина → 1! == 2 ← "2"консоль.бревно(ложный ==  "2"); // ложь ... ложь → 0! == 2 ← "2"консоль.бревно(истинный  ==  "1"); // истина .... истина → 1 === 1 ← «1»консоль.бревно(ложный ==  "0"); // истина .... ложь → 0 === 0 ← «0»консоль.бревно(ложный ==  "" ); // истина .... ложь → 0 === 0 ← ""консоль.бревно(ложный ==  NaN); // ложь ... ложь → 0! == NaNконсоль.бревно(NaN == NaN); // false ...... NaN не эквивалентно ничему, включая NaN.// Сравнение проверенных типов (без преобразования типов и значений)консоль.бревно(истинный === 1); // false ...... типы данных не совпадают// Явное приведение типаконсоль.бревно(истинный === !!2);   // true .... типы данных и значения совпадаютконсоль.бревно(истинный === !!0);   // false ... типы данных совпадают, но значения различаютсяконсоль.бревно( 1  ? истинный : ложный); // true .... только ± 0 и NaN - «ложные» числаконсоль.бревно("0" ? истинный : ложный); // true .... только пустая строка является «ложной»консоль.бревно(Булево({}));    // true .... все объекты «правдивы»

Оператор new может использоваться для создания оболочки объекта для логического примитива. Тем не менее тип оператор не возвращает логический для обертки объекта он возвращает объект. Поскольку все объекты оцениваются как истинный, такой метод как .значение(), или же .нанизывать(), необходимо использовать для получения обернутого значения. Для явного приведения к логическому типу Mozilla рекомендует Логический () функция (без новый) будет использоваться вместо логического объекта.

вар б = новый Булево(ложный);   // Объект false {}вар т = Булево(б);           // логическое значение trueвар ж = Булево(б.значение()); // логическое значение falseвар п = новый Булево(б);       // Не рекомендуетсяп = новый Булево(б.значение()); // Предпочтительноесли (0 || -0 || "" || ноль || неопределенный || б.значение() || !новый Булево() || !т) {  консоль.бревно("Никогда этого");} еще если ([] && {} && б && тип б === "объект" && б.нанизывать() === "ложный") {  консоль.бревно("Всегда это");}

Символ

Новое в ECMAScript6. А Символ уникальный и неизменный идентификатор.

Пример:

Икс=Символ(1);у=Символ(1);Икс==у; // ложныйобр=[Икс,у];обр[Икс]=1;обр[у]=2; // x и y - уникальные ключи для массива arrобр[Икс]; // отображает 1обр[у]; // отображает 2Икс=Символ(3);обр; // отображает [Symbol (1), Symbol (1)]обр[Икс]; // теперь не определеноИкс=Символ(1);обр[Икс]; // неопределенный

Оболочка Symbol также предоставляет доступ к итератору без переменных.

Икс=[1,2,3,4]; // x - это массив и итерируемыйбывший=Икс[Символ.итератор](); // предоставляет итератор для xпока ((exv=бывший.следующий().ценить)!=неопределенный) консоль.бревно(exv); // отображает 1,2,3,4

Родные объекты

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

Множество

An Множество это объект JavaScript, прототипированный из Множество конструктор, специально разработанный для хранения значений данных, индексированных целочисленными ключами. Массивы, в отличие от базового типа Object, имеют прототипы с методами и свойствами, чтобы помочь программисту в повседневных задачах (например, присоединиться, ломтик, и толкать).

Как в Семья C, массивы используют схему индексации с отсчетом от нуля: значение, которое вставляется в пустой массив с помощью толкать занимает 0-й индекс массива.

вар myArray = [];            // Указываем переменную myArray на новый ...                             // ... создан, пустой массивmyArray.толкать("Привет, мир"); // Заполняем следующий пустой индекс, в данном случае 0консоль.бревно(myArray[0]);           // Эквивалент console.log ("hello World");

Массивы имеют длина свойство, которое всегда будет больше, чем самый большой целочисленный индекс, используемый в массиве. Он автоматически обновляется, если создается свойство с еще большим индексом. Запись меньшего числа в длина свойство удалит более крупные индексы.

Элементы МножествоДоступ к s можно получить, используя обычную нотацию доступа к свойствам объекта:

myArray[1];  // второй элемент в myArraymyArray["1"];

Вышеупомянутые два эквивалентны. Невозможно использовать обозначение «точка» или строки с альтернативными представлениями числа:

myArray.1;     // синтаксическая ошибкаmyArray["01"]; // не то же самое, что myArray [1]

Объявление массива может использовать либо Множество буквальный или Множество конструктор:

myArray = [0, 1, , , 4, 5];            // массив длиной 6 и 6 элементов, ...                                       // ... включая 2 неопределенных элементаmyArray = новый Множество(0, 1, 2, 3, 4, 5); // массив длиной 6 и 6 элементовmyArray = новый Множество(365);              // пустой массив длиной 365

Массивы реализованы так, что только определенные элементы используют память; они есть "разреженные массивы ". Параметр myArray[10] = 'что нибудь' и myArray[57] = 'somethingOther' использует пространство только для этих двух элементов, как и любой другой объект. В длина массива по-прежнему будет отображаться как 58.

Можно использовать литерал объявления объекта для создания объектов, которые ведут себя так же, как ассоциативные массивы в других языках:

собака = {цвет: "коричневый", размер: "большой"};собака["цвет"]; // приводит к "коричневому"собака.цвет;    // также дает "коричневый"

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

кошки = [{цвет: "коричневый", размер: "большой"},    {цвет: "чернить", размер: "маленький"}];кошки[0]["размер"];      // приводит к "большим"собаки = {марсоход: {цвет: "коричневый", размер: "большой"},    место: {цвет: "чернить", размер: "маленький"}};собаки["место"]["размер"]; // приводит к "маленькому"собаки.марсоход.цвет;     // приводит к "коричневому"

Дата

А Дата объект хранит подписанный счетчик миллисекунд с нулем, представляющим 1970-01-01 00:00:00 UT, и диапазон ± 10⁸ дней. Есть несколько способов аргументировать Дата конструктор. Обратите внимание, что месяцы отсчитываются от нуля.

новый Дата();                       // создаем новый экземпляр Date, представляющий текущее время / дату.новый Дата(2010, 2, 1);             // создаем новый экземпляр Date, представляющий 01.03.2010 00:00:00новый Дата(2010, 2, 1, 14, 25, 30); // создаем новый экземпляр Date, представляющий 01.03.2010 14:25:30новый Дата("2010-3-1 14:25:30");    // создаем новый экземпляр Date из String.

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

вар d = новый Дата(2010, 2, 1, 14, 25, 30); // 01.03.2010 14:25:30;// Отображает '2010-3-1 14:25:30':консоль.бревно(d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate() + ' '    + d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds());// Встроенный toString возвращает что-то вроде «Mon Mar 01 2010 14:25:30 GMT-0500 (EST)»:консоль.бревно(d);

Ошибка

Пользовательские сообщения об ошибках могут быть созданы с помощью Ошибка учебный класс:

бросать новый Ошибка("Что-то пошло не так.");

Их можно поймать блоками try ... catch ... finally, как описано в разделе, посвященном Обработка исключений.

Математика

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

Свойства объекта Math

Свойство	Возвращаемое значение округлено до 5 цифр	Описание
Math.E	2.7183	е: Основание натурального логарифма
Math.LN2	0.69315	Натуральный логарифм из 2
Math.LN10	2.3026	Натуральный логарифм 10
Math.LOG2E	1.4427	Логарифм к базе 2 из е
Math.LOG10E	0.43429	Логарифм по основанию 10 е
Math.PI	3.14159	π: окружность / диаметр круга
Math.SQRT1_2	0.70711	Квадратный корень из ½
Math.SQRT2	1.4142	Корень квадратный из 2

Методы объекта Math

Пример	Возвращаемое значение округлено до 5 цифр	Описание
Math.abs (-2,3)	2.3	Абсолютная величина: (х <0)? -x: x
Math.acos (Math.SQRT1_2)	0,78540 рад. = 45 °	Арккосин
Math.asin (Math.SQRT1_2)	0,78540 рад. = 45 °	Арксинус
Математический атан (1)	0,78540 рад. = 45 °	Половина круга арктангенс (-π/ 2 в +π/2)
Math.atan2 (-3,7, -3,7)	-2,3562 рад. = -135 °	Арктангенс всего круга (-π к +π)
Math.ceil (1.1)	2	Потолок: круглый до наименьшего целого числа ≥ аргумент
Math.cos (Math.PI / 4)	0.70711	Косинус
Math.exp(1)	2.7183	Экспоненциальная функция: е поднял до этой власти
Математический пол (1.9)	1	Этаж: округлить до наибольшего целого числа ≤ аргумент
Math.log (Math.E)	1	Натуральный логарифм, основание е
Math.max (1, -2)	1	Максимум: (х> у)? х: у
Math.min (1, -2)	-2	Минимум: (х <у)? х: у
Math.pow (-3, 2)	9	Возведение в степень (возведены в степень): Math.pow (х, у) дает х^у
Math.random ()	0.17068	Псевдослучайный число от 0 (включительно) до 1 (исключая)
Математический круг (1.5)	2	Округлить до ближайшего целого числа; половинные дроби округляются в большую сторону (например, 1,5 округления до 2)
Math.sin (Math.PI / 4)	0.70711	Синус
Math.sqrt (49)	7	Квадратный корень
Math.tan (Math.PI / 4)	1	Касательная

Регулярное выражение

Основная статья: Регулярное выражение

/выражение/.тест(нить);     // возвращает логическое значение"нить".поиск(/выражение/); // возвращает номер позиции"нить".заменять(/выражение/, замена);// Вот несколько примеровесли (/Том/.тест("Меня зовут Том")) консоль.бревно("Привет, Том!");консоль.бревно("Меня зовут Том".поиск(/Том/));          // == 11 (буквы перед Томом)консоль.бревно("Меня зовут Том".заменять(/Том/, "Джон")); // == "Меня зовут Джон"

Классы персонажей

//  d - цифра//  D - не цифра//  s - пробел//  S - без пробела//  w - слово char//  W - не слово// [ ] - один из// [^] - одно не из//  -  - классифицироватьесли (/  d /.тест('0'))                   консоль.бревно('Цифра');если (/[0-9]/.тест('6'))                консоль.бревно('Цифра');если (/[13579]/.тест('1'))              консоль.бревно('Нечетное число');если (/  S  S  s  S  S  S  S /.тест('Мое имя')) консоль.бревно("Форматировать ОК");если (/  ш  ш  ш /.тест('Том'))             консоль.бревно("Привет, Том");если (/ [a-zA-Z] /.тест('B'))             консоль.бревно('Письмо');

Соответствие символов

// A ... Z a ... z 0 ... 9 - буквенно-цифровой//  u0000 ...  uFFFF - шестнадцатеричный Unicode//  x00 ...  xFF - шестнадцатеричный ASCII//  t - вкладка//  n - новая строка//  r - CR//. - любой персонаж// | - ИЛИ ЖЕесли (/T.m/.тест('Том')) консоль.бревно ("Привет, Том, Тэм или Тим");если (/ A | B /.тест("А"))  консоль.бревно ('A или B');

Повторители

//? - 0 или 1 совпадение// * - 0 или больше// + - 1 или более// {n} - ровно n// {n,} - n или более// {0, n} - n или меньше// {n, m} - диапазон от n до mесли (/ ab? c /.тест("ac"))       консоль.бревно("OK"); // совпадение: "ac", "abc"если (/ ab * c /.тест("ac"))       консоль.бревно("OK"); // соответствие: «ac», «abc», «abbc», «abbbc» и т. д.если (/ ab + c /.тест("abc"))      консоль.бревно("OK"); // соответствие: «abc», «abbc», «abbbc» и т. д.если (/ ab {3} c /.тест("abbbc"))  консоль.бревно("OK"); // совпадение: "abbbc"если (/ ab {3,} c /.тест("abbbc")) консоль.бревно("OK"); // соответствие: «abbbc», «abbbbc», «abbbbbc» и т. д.если (/ ab {1,3} c /.тест("abc"))  консоль.бревно("OK"); // совпадение: «abc», «abbc», «abbbc»

Якоря

// ^ - строка начинается с// $ - строка заканчивается наесли (/ ^ Мой /.тест("Меня зовут Том"))   консоль.бревно ("Здравствуй!");если (/ Tom $ /.тест("Меня зовут Том"))  консоль.бревно ("Привет том!");

Подвыражение

// () - группирует символыесли (/ вода (знак)? /.тест("водяной знак")) консоль.бревно("Вот вода!"); // совпадение: "вода", "водяной знак",если (/ (Том) | (Джон) /.тест("Джон"))      консоль.бревно("Привет, Том или Джон!");

Флаги

// / g - глобальный// / i - игнорировать верхний / нижний регистр// / m - разрешить совпадениям занимать несколько строкконсоль.бревно("Привет том!".заменять(/ Том / я, "Джон"));  // == "Привет, Джон!"консоль.бревно("рататам".заменять(/ ta /, "ту"));      // == "ратутам"консоль.бревно("рататам".заменять(/тег, "ту"));     // == "ратум"

Продвинутые методы

my_array = my_string.расколоть(my_delimiter);// примерmy_array = "собака, кошка, корова".расколоть(",");      // my_array == ["собака", "кошка", "корова"];my_array = my_string.матч(my_expression);// примерmy_array = «Мы начинаем в 11:30, 12:15 и 16:45».матч(/  д  д:  д  д / г); // my_array == ["11:30", "12:15", "16:45"];

Группы захвата

вар myRe = / ( d {4} -  d {2} -  d {2}) ( d {2}:  d {2}:  d {2}) /;вар полученные результаты = myRe.exec(«Дата и время: 2009-09-08, 09:37:08».);если (полученные результаты) {  консоль.бревно("Соответствует:" + полученные результаты[0]); // Полное совпадение  вар мое свидание = полученные результаты[1]; // Первая группа == "2009-09-08"  вар мое время = полученные результаты[2]; // Вторая группа == "09:37:08"  консоль.бревно("Это " + мое время + " на " + мое свидание);} еще консоль.бревно("Не нашел подходящей даты!");

Функция

Каждая функция в JavaScript является экземпляром Функция конструктор:

// x, y - аргумент. return x + y - это тело функции, последнее в списке аргументов.вар Добавить = новый Функция('Икс', 'y', 'вернуть x + y');вар т = Добавить(1, 2);консоль.бревно(т);  // 3

Вышеупомянутая функция добавления также может быть определена с помощью выражения функции:

вар Добавить = функция(Икс, у) {  возвращаться Икс + у;};вар т = Добавить(1, 2);консоль.бревно(т); // 3

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

функция Добавить(Икс, у) {  возвращаться Икс + у;}вар т = Добавить(1, 2);консоль.бревно(т); // 3

Или же

вар Добавить = ((Икс, у) => {  возвращаться Икс + у;});// или жевар Добавить = ((Икс, у) => Икс + у);вар т = Добавить(1, 2);консоль.бревно(т); // 3

У экземпляра функции есть свойства и методы.

функция вычесть(Икс, у) {  возвращаться Икс - у;}консоль.бревно(вычесть.длина); // 2, ожидаемое количество аргументов.консоль.бревно(вычесть.нанизывать());/*"функция subtract (x, y) {  вернуть x - y;}"*/

Операторы

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

// Объединить 2 строкиконсоль.бревно('Он' + 'llo'); // отображает Hello// Сложим два числаконсоль.бревно(2 + 6);  // отображает 8// Добавление числа и строки приводит к объединениюконсоль.бревно(2 + '2');    // отображает 22консоль.бревно('$' + 3 + 4);  // отображает 34 доллара, но можно было ожидать 7 долларовконсоль.бревно('$' + (3 + 4)); // отображает $ 7консоль.бревно(3 + 4 + '7'); // отображает 77, числа остаются числами, пока не будет добавлена ​​строка// Преобразуем строку в числоконсоль.бревно(+'2' === 2); // отображает истинуконсоль.бревно(+'Привет'); // отображает NaN

Точно так же перегружен оператор '*': он может преобразовывать строку в число.

консоль.бревно(2 + '6'*1);  // отображает 8консоль.бревно(3*'7'); // 21консоль.бревно('3'*'7'); // 21консоль.бревно('Привет'*'Мир'); // отображает NaN

Арифметика

JavaScript поддерживает следующие бинарные арифметические операторы:

+	добавление
-	вычитание
*	умножение
/	деление (возвращает значение с плавающей запятой)
%	по модулю (возвращает остаток)
**	возведение в степень

JavaScript поддерживает следующие унарные арифметические операторы:

+	унарное преобразование строки в число
-	унарное отрицание (меняет знак)
++	приращение (может быть префиксом или постфиксом)
--	декремент (может быть префиксным или постфиксным)

вар Икс = 1;консоль.бревно(++Икс); // x становится 2; отображает 2консоль.бревно(Икс++); // отображает 2; x становится 3консоль.бревно(Икс);  // x равно 3; отображает 3консоль.бревно(Икс--); // отображает 3; x становится 2консоль.бревно(Икс);  // отображает 2; х равно 2консоль.бревно(--Икс); // x становится 1; отображает 1

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

вар Икс = 17;консоль.бревно(Икс%5); // отображает 2консоль.бревно(Икс%6); // отображает 5консоль.бревно(-Икс%5); // отображает -2консоль.бревно(-Икс%-5); // отображает -2консоль.бревно(Икс%-5); // отображает 2

Чтобы всегда возвращать неотрицательное число, повторно добавьте модуль и снова примените оператор по модулю:

вар Икс = 17;консоль.бревно((-Икс%5+5)%5); // отображает 3

Назначение

=	назначать
+=	добавить и назначить
-=	вычесть и присвоить
*=	умножить и присвоить
/=	разделить и назначить
%=	по модулю и присвоить
**=	возведение в степень и назначить

Назначение из примитивные типы

вар Икс = 9;Икс += 1; консоль.бревно(Икс); // отображает: 10Икс *= 30;консоль.бревно(Икс); // отображает: 300Икс /= 6;консоль.бревно(Икс); // отображает: 50Икс -= 3;консоль.бревно(Икс); // отображает: 47Икс %= 7;консоль.бревно(Икс); // отображает: 5

Присвоение типов объектов

/** * Чтобы изучить объекты JavaScript ... */вар объект_1 = {а: 1};		// присваиваем ссылку на вновь созданный объект объекту_1вар объект_2 = {а: 0};вар объект_3 = объект_2;	// object_3 ссылается на тот же объект, что и object_2	 объект_3.а = 2;сообщение();	        	// отображает 1 2 2	 объект_2 = объект_1;		// object_2 теперь ссылается на тот же объект, что и object_1	        	        // объект_3 по-прежнему ссылается на то, на что объект_2 ссылался ранеесообщение();		        // отображает 1 1 2	 объект_2.а = 7;  	        // изменяет объект_1сообщение();		        // отображает 7 7 2объект_3.а = 5;                 // объект_3 не меняет объект_2сообщение();	                // отображает 7 7 5объект_3 = объект_2;	объект_3.а=4;                  // объект_3 изменяет объект_1 и объект_2сообщение();                     // отображает 4 4 4/** * Печатает сообщение console.log */функция сообщение() {	консоль.бревно(объект_1.а + " " + объект_2.а + " " + объект_3.а);}

Назначение деструктуризации

В Mozilla JavaScript, начиная с версии 1.7, деструктурирующее присваивание позволяет назначать части структур данных сразу нескольким переменным. Левая часть присваивания - это шаблон, который напоминает произвольно вложенный литерал объекта / массива, содержащий l-lvalue на своих листьях, которые должны получить подструктуры присвоенного значения.

вар а, б, c, d, е;[а, б, c] = [3, 4, 5];консоль.бревно(а + ',' + б + ',' + c); // отображает: 3,4,5е = {фу: 5, бар: 6, баз: ['Баз', 'Содержание']};вар обр = [];({баз: [обр[0], обр[3]], фу: а, бар: б}) = е;консоль.бревно(а + ',' + б + ',' + обр);	// отображает: 5,6, Baz ,,, Content[а, б] = [б, а];		// меняем местами содержимое a и bконсоль.бревно(а + ',' + б);		// отображает: 6,5[а, б, c] = [3, 4, 5]; // перестановки[а, б, c] = [б, c, а];консоль.бревно(а + ',' + б + ',' + c); // отображает: 4,5,3

Оператор разворота / отдыха

Стандарт ECMAScript 2015 вводит "..."оператор" для связанных понятий "синтаксиса распространения"^[12] и "остальные параметры"^[13]

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

Другими словами, "..."трансформирует"[... фу]" в "[foo [0], foo [1], foo [2]]", и "this.bar (... foo);" в "this.bar (foo [0], foo [1], foo [2]);".

 1вар а = [1, 2, 3, 4]; 2 3// Его можно использовать несколько раз в одном выражении 4вар б = [...а, ...а]; // b = [1, 2, 3, 4, 1, 2, 3, 4]; 5 6// Можно комбинировать с предметами без распространения. 7вар c = [5, 6, ...а, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9]; 8 9// Для сравнения, без оператора спреда 10// создает вложенный массив.11вар d = [а, а]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]1213// То же самое и с вызовами функций14функция фу(arg1, arg2, arg3) {15    консоль.бревно(arg1 + ':' + arg2 + ':' + arg3);16}1718// Вы можете использовать его, даже если он передает больше параметров, чем функция будет использовать19фу(...а); // "1: 2: 3" → foo (a [0], a [1], a [2], a [3]);2021// Можно смешивать с параметрами без спреда22фу(5, ...а, 6); // "5: 1: 2" → foo (5, a [0], a [1], a [2], a [3], 6);2324// Для сравнения, без оператора спреда25// присваивает массив arg1 и ничего другим параметрам.26фу(а); // "1,2,3,4: undefined: undefined"

Когда ... используется в функции декларация, это указывает на остаточный параметр. Остальной параметр должен быть последним указанным параметром в списке параметров функции. Ему будет присвоен Множество содержащие любые аргументы, переданные функции сверх других названных параметров. Другими словами, он получает «остальные» аргументы, переданные функции (отсюда и название).

функция фу(а, б, ...c) {    консоль.бревно(c.длина);}фу(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5]фу('а', 'b'); // «0» → c = []

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

В ... оператор может использоваться только с Множество объекты. (Однако есть предложение расширить его на Объектs в будущем стандарте ECMAScript.^[14])

Сравнение

==	равный
!=	не равный
>	лучше чем
>=	больше или равно
<	меньше, чем
<=	меньше или равно
===	идентичные (одинаковые и однотипные)
!==	не идентичный

Переменные, ссылающиеся на объекты, равны или идентичны, только если они ссылаются на один и тот же объект:

вар obj1 = {а: 1};вар obj2 = {а: 1};вар obj3 = obj1;консоль.бревно(obj1 == obj2);  //ложныйконсоль.бревно(obj3 == obj1);  //истинныйконсоль.бревно(obj3 === obj1); //истинный

Смотрите также Нить.

Логический

JavaScript предоставляет четыре логических оператора:

• унарный отрицание (НЕ =! А)
• двоичный дизъюнкция (ИЛИ = a || б) и соединение (И = a && b)
• тройной условный (с? т: ж)

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

• Струны: "", '',
• Числа: 0, -0, NaN,
• Специальный: ноль, неопределенный,
• Логическое: ложный.

Логическая функция может использоваться для явного преобразования в примитив типа Булево:

// Только пустые строки возвращают falseконсоль.бревно(Булево("")      === ложный);консоль.бревно(Булево("ложный") === истинный);консоль.бревно(Булево("0")     === истинный);// Только ноль и NaN возвращают falseконсоль.бревно(Булево(NaN) === ложный);консоль.бревно(Булево(0)   === ложный);консоль.бревно(Булево(-0)  === ложный); // эквивалент -1 * 0консоль.бревно(Булево(-2)  === истинный);// Все объекты возвращают истинуконсоль.бревно(Булево(это) === истинный);консоль.бревно(Булево({})   === истинный);консоль.бревно(Булево([])   === истинный);// Эти типы возвращают falseконсоль.бревно(Булево(ноль)      === ложный);консоль.бревно(Булево(неопределенный) === ложный); // эквивалент Boolean ()

Оператор NOT оценивает свой операнд как логическое значение и возвращает отрицание. Использование оператора дважды подряд в качестве двойной отрицательный, явно преобразует выражение в примитив типа Boolean:

консоль.бревно( !0 === Булево(!0));консоль.бревно(Булево(!0) === !!1);консоль.бревно(!!1 === Булево(1));консоль.бревно(!!0 === Булево(0));консоль.бревно(Булево(0) === !1);консоль.бревно(!1 === Булево(!1));консоль.бревно(!"" === Булево(!""));консоль.бревно(Булево(!"") === !!"s");консоль.бревно(!!"s" === Булево("s"));консоль.бревно(!!"" === Булево(""));консоль.бревно(Булево("") === !"s");	консоль.бревно(!"s" === Булево(!"s"));

Тернарный оператор также может использоваться для явного преобразования:

консоль.бревно([] == ложный); консоль.бревно([] ? истинный : ложный); // «правда», но для сравнения используется [] .toString ()консоль.бревно([0] == ложный); консоль.бревно([0]? истинный : ложный); // [0] .toString () == "0"консоль.бревно("0" == ложный); консоль.бревно("0"? истинный : ложный); // "0" → 0 ... (0 == 0) ... 0 ← falseконсоль.бревно([1] == истинный); консоль.бревно([1]? истинный : ложный); // [1] .toString () == "1"консоль.бревно("1" == истинный); консоль.бревно("1"? истинный : ложный); // "1" → 1 ... (1 == 1) ... 1 ← trueконсоль.бревно([2] != истинный); консоль.бревно([2]? истинный : ложный); // [2] .toString () == "2"консоль.бревно("2" != истинный); консоль.бревно("2"? истинный : ложный); // «2» → 2 ... (2! = 1) ... 1 ← true

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

консоль.бревно(а || б);  // Когда a истинно, нет причин оценивать b.консоль.бревно(а && б);  // Когда a ложно, нет причин оценивать b.консоль.бревно(c ? т : ж); // Когда c истинно, нет причин для вычисления f.

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

консоль.бревно(а || б); // если a истинно, вернуть a, иначе вернуть bконсоль.бревно(а && б); // если a ложно, вернуть a, иначе вернуть b

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

вар s = т || "(дефолт)"; // присваивает t или значение по умолчанию, если t равно null, пусто и т. д.

Побитовое

JavaScript поддерживает следующие двоичный побитовые операторы:

&	И
|	ИЛИ ЖЕ
^	XOR
!	НЕТ
<<	сдвиг влево (нулевая заливка справа)
>>	сдвиг вправо (распространение знака); копии крайний левый бит (знаковый бит) сдвигается слева
>>>	сдвиг вправо (нулевая заливка слева). Для положительных чисел >> и >>> дают тот же результат.

Примеры:

Икс=11 & 6;консоль.бревно(Икс); // 2

JavaScript поддерживает следующие унарный побитовый оператор:

~	НЕ (инвертирует биты)

Побитовое присвоение

JavaScript поддерживает следующие операторы двоичного присваивания:

&=	и
|=	или же
^=	xor
<<=	сдвиг влево (нулевая заливка справа)
>>=	сдвиг вправо (распространение знака); копии крайний левый бит (знаковый бит) сдвигается слева
>>>=	сдвиг вправо (нулевая заливка слева). Для положительных чисел >>= и >>>= дают тот же результат.

Примеры:

Икс=7;консоль.бревно(Икс); // 7Икс<<=3;консоль.бревно(Икс); // 7->14->28->56

Нить

=	назначение
+	конкатенация
+=	объединить и назначить

Примеры:

ул = "ab" + "CD";  // "abcd"ул += "е";      // "abcde"ул2 = "2" + 2;     // «22», а не «4» или 4.

Структуры управления

Составные заявления

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

Если еще

если (expr) {  //заявления;} еще если (expr2) {  //заявления;} еще {  //заявления;}

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

Условный оператор создает выражение, которое оценивается как одно из двух выражений в зависимости от условия. Это похоже на если оператор, который выбирает один из двух операторов для выполнения в зависимости от условия. То есть, условный оператор для выражений если к заявлениям.

 результат = условие ? выражение : альтернатива;

такой же как:

 если (условие) {  результат = выражение; } еще {  результат = альтернатива; }

в отличие от если оператор, условный оператор не может опустить его "else-ветвь".

Заявление о переключении

Синтаксис JavaScript оператор переключения как следует:

 выключатель (expr) {  дело НЕКОТОРЫЕ ЗНАЧЕНИЕ:   // заявления;   перемена;  дело ДРУГОЕ ЗНАЧЕНИЕ:   // заявления;   перемена;  дефолт:   // заявления;   перемена; }

• перемена; необязательно; однако обычно это необходимо, поскольку в противном случае выполнение кода продолжится до тела следующего блока case.
• Добавьте оператор break в конец последнего случая в качестве меры предосторожности на случай, если позже будут добавлены дополнительные варианты.
• Значения строкового литерала также могут использоваться для значений case.
• Вместо значений можно использовать выражения.
• Случай по умолчанию (необязательный) выполняется, когда выражение не соответствует никаким другим указанным случаям.
• Подтяжки обязательны.

Для цикла

Синтаксис JavaScript для цикла как следует:

 за (исходный; условие; петля утверждение) {  /*   операторы будут выполняться каждый раз   цикл for {} циклов, а   условие выполнено  */ }

или же

 за (исходный; условие; петля утверждение(итерация)) // одна инструкция

For ... in loop

Синтаксис JavaScript для ... в цикле как следует:

за (вар Имя свойства в some_object) {  // операторы, использующие some_object [property_name];}

• Перебирает все перечислимые свойства объекта.
• Перебирает все используемые индексы массива, включая все определенные пользователем свойства объекта массива, если таковые имеются. Таким образом, может быть лучше использовать традиционный цикл for с числовым индексом при итерации по массивам.
• Между различными веб-браузерами существуют различия в том, какие свойства будут отражаться с помощью оператора цикла for ... in. Теоретически это контролируется внутренним свойством состояния, определенным стандартом ECMAscript под названием «DontEnum», но на практике каждый браузер возвращает немного другой набор свойств во время интроспекции. Полезно проверить данное свойство, используя если (some_object.hasOwnProperty(Имя свойства)) { ...}. Таким образом, добавляя метод к прототипу массива с Множество.прототип.newMethod = функция() {...} может привести к для ... в циклы для перебора имени метода.

Пока цикл

Синтаксис JavaScript пока цикл как следует:

пока (условие) {  заявление1;  заявление2;  заявление3;  ...}

Do ... while цикл

Синтаксис JavaScript делать ... пока цикл как следует:

делать {  заявление1;  заявление2;  заявление3;  ...} пока (условие);

С

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

с (документ) {  вар а = getElementById('а');  вар б = getElementById('b');  вар c = getElementById('c');};

• Обратите внимание на отсутствие документ. перед каждым getElementById () призыв.

Семантика аналогична выражению with оператора Паскаль.

Поскольку наличие операторов with снижает производительность программы и, как полагают, снижает ясность кода (поскольку любая заданная переменная на самом деле может быть свойством из включающего с), это утверждение не допускается в строгий режим.

Этикетки

JavaScript поддерживает вложенные метки в большинстве реализаций. Циклы или блоки могут быть помечены для оператора break, а циклы - для Продолжить. Несмотря на то что идти к это зарезервированное слово,^[15] идти к не реализован в JavaScript.

loop1: за (вар а = 0; а < 10; а++) {  если (а == 4) {    перемена loop1; // Останавливаемся после 4-й попытки  }  консоль.бревно('а =' + а);  loop2: за (вар б = 0; б < 10; ++б) {    если (б == 3) {     Продолжить loop2; // Число 3 пропускается    }    если (б == 6) {     Продолжить loop1; // Продолжаем первый цикл, 'готово' не отображается    }    консоль.бревно('b =' + б);  }  консоль.бревно('законченный');}блок1: {  консоль.бревно('Привет'); // Отображает 'Hello'  перемена блок1;  консоль.бревно('Мир'); // Никогда сюда не доберусь}идти к блок1; // Ошибка разбора.

Функции

А функция - это блок со списком параметров (возможно, пустым), которому обычно дается имя. Функция может использовать локальные переменные. Если вы выйдете из функции без оператора возврата, значение неопределенный возвращается.

функция gcd(сегмент А, сегмент B) {  вар разница = сегмент А - сегмент B;  если (разница == 0)     возвращаться сегмент А;  возвращаться разница > 0 ? gcd(сегмент B, разница) : gcd(сегмент А, -разница);}консоль.бревно(gcd(60, 40)); // 20вар mygcd = gcd; // mygcd - это ссылка на ту же функцию, что и gcd. Обратите внимание на аргумент () s.консоль.бревно(mygcd(60, 40)); // 20

Функции объекты первого класса и может быть назначен другим переменным.

Количество аргументов, передаваемых при вызове функции, не обязательно может соответствовать количеству аргументов в определении функции; именованный аргумент в определении, который не имеет соответствующего аргумента в вызове, будет иметь значение неопределенный (который может быть неявно приведен к false). Внутри функции к аргументам также можно получить доступ через аргументы объект; это обеспечивает доступ ко всем аргументам с использованием индексов (например, аргументы[0], аргументы[1], ... аргументы[п]), включая те, которые превышают количество названных аргументов. (Хотя в списке аргументов есть .длина собственность, это нет экземпляр Множество; у него нет таких методов, как .ломтик(), .Сортировать(), так далее.)

функция add7(Икс, у) {  если (!у) {    у = 7;  }  консоль.бревно(Икс + у + аргументы.длина);};add7(3); // 11add7(3, 4); // 9

Примитивные значения (число, логическое значение, строка) передаются по значению. Для объектов это ссылка на объект, который передается.

вар obj1 = {а : 1};вар obj2 = {б : 2};функция фу(п) {  п = obj2; // Игнорирует фактический параметр  п.б = аргументы[1];}фу(obj1, 3); // Совершенно не влияет на obj1. 3 - дополнительный параметрконсоль.бревно(obj1.а + " " + obj2.б); // пишет 1 3

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

вар v = "Вершина";вар бар, баз;функция фу() {  вар v = "фуд";  бар = функция() { консоль.бревно(v) };  баз = функция(Икс) { v = Икс; };}фу();баз("Фугли");бар(); // Неудачный (не fud), хотя foo () завершился.консоль.бревно(v); // Вершина

Объекты

Для удобства типы обычно подразделяются на примитивы и объекты. Объекты - это сущности, которые имеют идентичность (они равны только самим себе) и отображают имена свойств в значения ("слоты" в программирование на основе прототипов терминология). Объекты можно рассматривать как ассоциативные массивы или хеши, и часто реализуются с использованием этих структур данных. Однако у объектов есть дополнительные функции, такие как цепочка прототипов.^{[требуется разъяснение ]}, которых нет в обычных ассоциативных массивах.

В JavaScript есть несколько видов встроенных объектов, а именно Множество, Булево, Дата, Функция, Математика, Число, Объект, RegExp и Нить. Другие объекты - это «хост-объекты», которые определяются не языком, а средой выполнения. Например, в браузере типичные хост-объекты принадлежат DOM (окно, форма, ссылки и т. Д.).

Создание объектов

Объекты можно создавать с помощью конструктора или литерала объекта. Конструктор может использовать либо встроенную функцию Object, либо пользовательскую функцию. По соглашению функциям-конструкторам присваивается имя, начинающееся с заглавной буквы:

// Конструкторвар объект = новый Объект();// Литерал объектавар объектA = {};вар объектA2 = {};  // A! = A2, {} s создают новые объекты как копии.вар объектB = {index1: 'значение 1', index2: 'значение 2'};// Пользовательский конструктор (см. Ниже)

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

вар myStructure = {  имя: {    первый: "Мел",    последний: "Смит"  },  возраст: 33,  увлечения: ["шахматы", "бег трусцой"]};

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

Методы

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

При вызове в качестве метода стандартная локальная переменная это просто автоматически устанавливается в экземпляр объекта слева от ".". (Это также вызов и подать заявление методы, которые могут установить это явно - некоторые пакеты, такие как jQuery делать необычные вещи с это.)

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

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

функция px() { возвращаться это.префикс + "ИКС"; }функция Фу(yz) {  это.префикс = "а-";  если (yz > 0) {    это.пыз = функция() { возвращаться это.префикс + "Y"; };  } еще {    это.пыз = функция() { возвращаться это.префикс + "Z"; };  }  это.m1 = px;  возвращаться это;}вар foo1 = новый Фу(1);вар foo2 = новый Фу(0);foo2.префикс = "б-";консоль.бревно("foo1 / 2" + foo1.пыз() + foo2.пыз());// foo1 / 2 a-Y b-Zfoo1.м3 = px; // Назначает саму функцию, а не результат ее оценки, т.е. не px ()вар баз = {"префикс": "c-"};баз.м4 = px; // Для создания объекта конструктор не нужен.консоль.бревно(«м1 / м3 / м4» + foo1.m1() + foo1.м3() + баз.м4());// м1 / м3 / м4 a-X a-X c-Xfoo1.m2(); // Выдает исключение, потому что foo1.m2 не существует.

Конструкторы

Функции конструктора просто присваивайте значения слотам вновь созданного объекта. Значения могут быть данными или другими функциями.

Пример: манипулирование объектом:

функция MyObject(attributeA, attributeB) {  это.attributeA = attributeA;  это.attributeB = attributeB;}MyObject.staticC = "синий"; // В функции MyObject, а не в объектеконсоль.бревно(MyObject.staticC); // синийобъект = новый MyObject('красный', 1000);консоль.бревно(объект.attributeA); // красныйконсоль.бревно(объект["attributeB"]); // 1000консоль.бревно(объект.staticC); // неопределенныйобъект.attributeC = новый Дата(); // добавляем новое свойствоУдалить объект.attributeB; // удаляем свойство объектаконсоль.бревно(объект.attributeB); // неопределенныйУдалить объект; // удаляем весь объект (используется редко)консоль.бревно(объект.attributeA); // выдает исключение

Сам конструктор упоминается в прототипе объекта конструктор слот. Так,

функция Фу() {}// Использование "новых" наборов слотов прототипов (например, // x = new Foo () установит прототип x в Foo.prototype,// и Foo.prototype имеет слот конструктора, указывающий на Foo).Икс = новый Фу();// Вышеупомянутое почти эквивалентноу = {};у.конструктор = Фу;у.конструктор();// КромеИкс.конструктор == у.конструктор // истинныйИкс экземпляр Фу // истинныйу экземпляр Фу // ложный// прототип y - это Object.prototype, а не// Foo.prototype, поскольку он был инициализирован// {} вместо нового Foo.// Несмотря на то, что Foo установлен в слот конструктора y,// это игнорируется instanceof - только прототип y// рассматривается слот конструктора.

Функции сами по себе являются объектами, которые можно использовать для создания эффекта, аналогичного «статическим свойствам» (с использованием терминологии C ++ / Java), как показано ниже. (Функциональный объект также имеет специальный прототип свойство, как описано в разделе «Наследование» ниже.)

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

Наследование

JavaScript поддерживает иерархии наследования посредством создания прототипов в виде Себя.

В следующем примере Полученный класс наследуется от Основание class.When d создается как Полученный, ссылка на базовый экземпляр Основание копируется в d.base.

Derive не содержит значения для aBaseFunction, поэтому он извлекается из aBaseFunction когда aBaseFunction доступен. Это становится понятным, если изменить значение base.aBaseFunction, что отражается на стоимости d.aBaseFunction.

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

функция Основание() {  это.anOverride = функция() { консоль.бревно("Base :: anOverride ()"); };  это.aBaseFunction = функция() { консоль.бревно("Base :: aBaseFunction ()"); };}функция Полученный() {  это.anOverride = функция() { консоль.бревно("Derived :: anOverride ()"); };}основание = новый Основание();Полученный.прототип = основание; // Должен быть до new Derived ()Полученный.прототип.конструктор = Полученный; // Требуется для работы `instanceof`d = новый Полученный();    // Копирует Derived.prototype в скрытый слот прототипа экземпляра d.d экземпляр Полученный; // истинныйd экземпляр Основание;    // истинныйоснование.aBaseFunction = функция() { консоль.бревно("Base :: aNEWBaseFunction ()"); }d.anOverride();    // Derived :: anOverride ()d.aBaseFunction(); // Base :: aNEWBaseFunction ()консоль.бревно(d.aBaseFunction == Полученный.прототип.aBaseFunction); // истинныйконсоль.бревно(d.__proto__ == основание); // true в реализациях на основе Mozilla и false во многих других.

Ниже наглядно показано, как ссылки на прототипы скопировано при создании экземпляра, но эти изменения в прототипе могут повлиять на все экземпляры, которые к нему относятся.

функция m1() { возвращаться "Один"; }функция m2() { возвращаться "Два"; }функция м3() { возвращаться "Три"; }функция Основание() {}Основание.прототип.м = m2;бар = новый Основание();консоль.бревно("бар.м" + бар.м()); // bar.m Двафункция Вершина() { это.м = м3; }т = новый Вершина();фу = новый Основание();Основание.прототип = т;// Не влияет на foo, * ссылка * на t копируется.консоль.бревно("фу.м" + фу.м()); // foo.m Двабаз = новый Основание();консоль.бревно("baz.m" + баз.м()); // baz.m Трит.м = m1; // Влияет на baz и любые другие производные классы.консоль.бревно("baz.m1" + баз.м()); // baz.m1 Один

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

Обработка исключений

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

В попробуй ... поймай ... наконец заявление улавливает исключения в результате ошибки или оператора throw. Его синтаксис следующий:

пытаться {  // Заявления, в которых могут быть выброшены исключения} ловить(errorValue) {  // Операторы, которые выполняются в случае исключения} наконец-то {  // Операторы, которые выполняются позже в любом случае}

Первоначально выполняются операторы в блоке try. Если генерируется исключение, поток управления скрипта немедленно переходит к операторам в блоке catch, причем исключение доступно в качестве аргумента ошибки. В противном случае блок перехвата пропускается. Блок захвата может бросить (errorValue), если он не хочет обрабатывать конкретную ошибку.

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

Предложение catch или final можно опустить. Аргумент catch является обязательным.

Реализация Mozilla позволяет использовать несколько операторов catch как расширение стандарта ECMAScript. Они следуют синтаксису, аналогичному используемому в Ява:

пытаться { утверждение; }ловить (е если е == «InvalidNameException»)  { утверждение; }ловить (е если е == «InvalidIdException»)    { утверждение; }ловить (е если е == «InvalidEmailException») { утверждение; }ловить (е)                                 { утверждение; }

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

ошибка = функция (errorValue, url, lineNr) {...; возвращаться истинный;};

Собственные функции и методы

(Не относится к веб-браузерам.)

eval (выражение)

Оценивает первый параметр как выражение, которое может включать операторы присваивания. Выражение может ссылаться на переменные, локальные для функций. Тем не мение, оценка представляет собой серьезную угрозу безопасности, поскольку позволяет злоумышленнику выполнить произвольный код, поэтому его использование не рекомендуется.^[16]

(функция фу() {  вар Икс = 7;  консоль.бревно("вал" + оценка(«х + 2»));})(); // показывает val 9.

Смотрите также

• Сравнение редакторов исходного кода на основе JavaScript
• JavaScript

Рекомендации

1. Спецификация JavaScript 1.1
2. «Глава 1. Базовый JavaScript». speakjs.com. Получено 22 сентября 2020.
3. Фланаган, Дэвид (2006). JavaScript: полное руководство. п.16. ISBN  978-0-596-10199-2. Пропуск точки с запятой не является хорошей практикой программирования; вы должны иметь привычку вставлять их.
4. "Вставка точки с запятой в JavaScript: все, что вам нужно знать ", ~ inimino / блог /, Пятница, 28 мая 2010 г.
5. "Точка с запятой в JavaScript не обязательна ", Мислав Марохнич, 7 мая 2010 г.
6. «Значения, переменные и литералы - MDC». Сеть разработчиков Mozilla. 16 сентября 2010. Архивировано с оригинал 29 июня 2011 г.. Получено 1 февраля 2020.
7. "Область видимости и подъема JavaScript ", Бен Черри, Достаточно хорошо, 2010-02-08
8. ECMA-262 5e edition разъясняет это сбивающее с толку поведение, вводя понятие Декларативная запись среды и Запись среды объекта. При таком формализме глобальный объект это Запись среды объекта глобального Лексическая среда (в глобальный масштаб).
9. "Шаблонные литералы". Веб-документы MDN. Получено 2 мая 2018.
10. «Операторы сравнения - MDC Doc Center». Mozilla. 5 августа 2010 г.. Получено 5 марта 2011.
11. «Элементы стиля JavaScript». Дуглас Крокфорд. Получено 5 марта 2011.
12. "Распространение синтаксиса".
13. "остальные параметры".
14. «Экмаскрипт». Архивировано из оригинал 9 августа 2016 г.
15. ECMA-262, издание 3, 7.5.3 Будущие зарезервированные слова
16. "eval ()". Веб-документы MDN. Получено 29 января 2020.

дальнейшее чтение

• Дэнни Гудман: Библия JavaScript, Wiley, John & Sons, ISBN  0-7645-3342-8.
• Дэвид Фланаган, Паула Фергюсон: JavaScript: полное руководство, O'Reilly & Associates, ISBN  0-596-10199-6.
• Томас А. Пауэлл, Фриц Шнайдер: JavaScript: полный справочник, Компании McGraw-Hill, ISBN  0-07-219127-9.
• Аксель Раушмайер: Говоря на JavaScript: подробное руководство для программистов, 460 страниц, O'Reilly Media, 25 февраля 2014 г., ISBN  978-1449365035. (бесплатная онлайн-версия )
• Эмили Вандер Вир: JavaScript для чайников, 4-е издание, Wiley, ISBN  0-7645-7659-3.

внешняя ссылка

• Повторное введение в JavaScript - Центр разработчиков Mozilla
• Циклы JavaScript
• Стандартные ссылки на ECMAScript: ECMA-262
• Интерактивные уроки JavaScript - на основе примеров
• JavaScript на About.com: уроки и объяснение
• Обучение JavaScript
• Основные ссылки Центра разработчиков Mozilla для версий JavaScript 1.5, 1.4, 1.3 и 1.2
• Документация по языку Mozilla JavaScript