Синтаксис JavaScript

Эта статья поднимает множество проблем. Пожалуйста, помогите улучшить его или обсудите эти проблемы на странице обсуждения . ( Узнайте, как и когда удалить эти сообщения-шаблоны ) Эта статья может быть слишком длинной для чтения и удобной навигации . Размер читаемой прозы - 79 килобайт. Пожалуйста, подумайте о разделении контента на подстатьи, сжатии или добавлении подзаголовков . Пожалуйста, обсудите этот вопрос на странице обсуждения статьи . ( Май 2019 г. ) Эта статья нуждается в обновлении . Причина этого: новые функции / версии теперь в JavaScript. Обновите эту статью, чтобы отразить недавние события или новую доступную информацию. ( Ноябрь 2020 г. ) ( Узнайте, как и когда удалить этот шаблон сообщения )

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

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

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

Истоки [ править ]

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

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

Основы [ править ]

Чувствительность к регистру [ править ]

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

Пример:

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

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

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

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

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

а  =  Ь  +  с ( д  +  е ). foo ()// Рассматривается как: // a = b + c (d + e) ​​.foo ();

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

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

а  =  Ь  +  с ; ( г  +  д ). foo ()// Рассматривается как: // a = b + c; // (d + e) ​​.foo ();

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

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

вернуть a  +  b ;// Возвращает неопределенное значение. Рассматривается как: // return; // a + b; // Должно быть записано как: // return a + b;

Комментарии [ редактировать ]

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

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

Переменные [ править ]

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

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

Определение объема и подъем [ править ]

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

С var, letи constзаявление, только декларация поднято; назначения не поднимаются. Таким образом, оператор в середине функции эквивалентен оператору объявления в верхней части функции и оператору присваивания в этой точке в середине функции. Это означает, что вы не можете получить доступ к значениям до того, как они будут объявлены; прямая ссылка невозможна. Со значением переменной есть до ее инициализации. Переменные, объявленные с помощью или не могут быть доступны до тех пор, пока они не инициализированы, поэтому обращение к переменной вызовет ошибку.var x = 1var xx = 1varundefinedletconst

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

Так, например,

var  func  =  function ()  {  ..  }  // объявление поднимается только function  func ()  {  ..  }  // объявление и присваивание поднимаются

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

Заявление и уступка [ править ]

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

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

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

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

Примеры [ править ]

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

var  x1  =  0 ;  // Глобальная переменная, потому что ее нет ни в одной функции let  x2  =  0 ;  // Также глобальный, на этот раз, потому что он не находится ни в одном блокефункция  f ()  {  var  z  =  'foxes' ,  r  =  'birds' ;  // 2 локальные переменные  m  =  'fish' ;  // глобальный, потому что он нигде раньше не объявлялся функция  child ()  {  var  r  =  'обезьяны' ;  // Эта переменная является локальной и не влияет на "птички" r родительской функции.  z  =  'пингвины' ;  // Закрытие: дочерняя функция может получить доступ к переменным родительской функции.  } двадцать  =  20 ;  // Эта переменная объявлена ​​в следующей строке, но ее можно использовать в любом месте функции, даже раньше, как здесь  var  20 ; ребенок ();  вернуть  x1  +  x2 ;  // Мы можем использовать здесь x1 и x2, потому что они глобальные }f ();консоль . журнал ( z );  // Эта строка вызовет исключение ReferenceError, потому что значение z больше не доступно

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

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

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

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

• Неопределенный
• Число
• BigInt
• Нить
• Логический
• Символ

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

Не определено [ править ]

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

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

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

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

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

функция  isUndefined ( x )  {  var  u ;  вернуть  x  ===  u ;  }  // вот так ... function  isUndefined ( x )  {  return  x  ===  void  0 ;  }  // ... или эта вторая функция  isUndefined ( x )  {  return  ( typeof  x )  ===  "undefined" ;  }  // ... или третий

Здесь вызов isUndefined(my_var)вызывает ошибку ReferenceError, если my_var - неизвестный идентификатор, тогда как нет.typeof my_var === 'undefined'

Номер [ править ]

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

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

консоль . журнал ( 0,2  +  0,1  ===  0,3 );  // отображает ложную консоль . журнал ( 0,94  -  0,01 );  // отображает 0,9299999999999999

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

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

345 ;  // «целое число», хотя в JavaScript 34.5 есть только один числовой тип ;  // число с плавающей запятой 3.45e2 ;  // другое число с плавающей запятой, эквивалент 345 0b1011 ;  // целое двоичное число, равное 11 0o377 ;  // восьмеричное целое число 255 0xFF ;  // шестнадцатеричное целое число, равное 255, цифры, представленные ...  // ... буквами AF, могут быть в верхнем или нижнем регистре

Также в ES2021 появился числовой разделитель _ (подчеркивание):

// Примечание: синтаксис Википедии пока не поддерживает числовые разделители 1 _000_000_000 ;  // Используется с большими числами 1 _000_000 .5 ;  // Поддержка десятичных знаков 1 _000e1_000 ;  // Поддержка с экспонентами// Поддержка двоичного, восьмеричного и шестнадцатеричного форматов 0b0000 _0000_0101_1011 ; 0o0001 _3520_0237_1327 ; 0xFFFF _FFFF_FFFF_FFFE ;// Но вы не можете использовать их рядом с нецифровой частью числа, или в начале или в конце _12 ;  // Переменная не определена (подчеркивание делает ее идентификатором переменной) 12 _ ;  // Синтаксическая ошибка (не может быть в конце чисел) 12 _ .0 ;  // Синтаксическая ошибка (нет смысла ставить разделитель рядом с десятичной точкой) 12. _0 ;  // Синтаксическая ошибка 12 e_6 ;  // Синтаксическая ошибка (рядом с «е» не цифра. Нет смысла ставить разделитель в начале) 1000 ____0000 ;  // Синтаксическая ошибка (рядом с "_", не цифра. Допускается только 1 разделитель за раз

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

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

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

тип  Бесконечности ;  // возвращает «число» typeof  NaN ;  // возвращает "число"

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

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

var  myString  =  "123,456" ; var  myNumber1  =  Число ( myString ); var  myNumber2  =  + myString ;

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

myNumericWrapper  =  новый  номер ( 123,456 );

Однако NaN не равен самому себе:

const  nan  =  NaN ; консоль . журнал ( NaN  ==  NaN );  // ложная консоль . журнал ( NaN  ===  NaN );  // ложная консоль . журнал ( NaN  ! ==  NaN );  // правда console . журнал ( нан  ! ==  нан );  // правда// Вы можете использовать методы isNaN для проверки консоли NaN . log ( isNaN ( "преобразовано в NaN" ));  // правда console . журнал ( isNaN ( NaN ));  // правда console . журнал ( Number . isNaN ( "не преобразован" ));  // ложная консоль . журнал ( Число . isNaN ( NaN ));  // правда

BigInt [ править ]

BigInts можно использовать для сколь угодно больших целых чисел . Особенно целые числа больше 2 ⁵³ - 1, которые являются наибольшим числом, которое JavaScript может надежно представить с помощью примитива Number и представленного константой Number.MAX_SAFE_INTEGER.

При делении BigInts, результаты усечены .

Строка [ править ]

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

var  приветствие  =  "Привет, мир!" ; var  anotherGreeting  =  'Приветствую, люди Земли.' ;

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

var  h  =  приветствие . charAt ( 0 );

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

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

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

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

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

var  x  =  "Мир" ; var  compare1  =  ( "Привет,"  + x  ==  "Привет, мир" );  // Здесь compare1 содержит истину. var  compare2  =  ( "Привет,"  + x  ==  "привет, мир" );  // Здесь compare2 содержит ...  // ... false, поскольку ...  // ... первые символы ...  // ... обоих операндов ...  // ... не совпадают дело.

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

var  x  =  '"Привет, мир!" он сказал.' ;  // Просто хорошо. var  x  =  "" Привет ,  мир ! " он сказал." ;  // Нехорошо. var  x  =  "\" Привет, мир! \ "сказал он." ;  // Работает путем экранирования "with \"

Конструктор String создает строковый объект (объект, заключающий строку):

вар  приветствие  =  новая  строка ( "Привет, мир!" );

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

var  s  =  new  String ( «Привет!» ); typeof  s ;  // Является объектом. typeof  s . valueOf ();  // Строка.

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

var  s1  =  new  String ( «Привет!» ); var  s2  =  new  String ( «Привет!» ); s1  ==  s2 ;  // Ложь, потому что это два разных объекта. s1 . valueOf ()  ==  s2 . valueOf ();  // Правда.

Boolean [ править ]

JavaScript предоставляет логический тип данных с истинными и ложными литералами. Оператор typeof возвращает строку "boolean" для этих примитивных типов . При использовании в логическом контексте 0 , -0 , null , NaN , undefined и пустая строка ( "" ) оцениваются как ложные из-за автоматического приведения типов . Все остальные значения ( дополнение к предыдущему списку) оцениваются как истинные , включая строки «0» ,«ложь» и любой объект.

Преобразование типа [ править ]

Автоматического приведения типа операторами сравнения равенства ( ==и !=) можно избежать, используя операторы сравнения с проверкой типа ( ===и !==).

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

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

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

Логический

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

Объект

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

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

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

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

var  b  =  new  Boolean ( false );  // Объект false {} var  t  =  Boolean ( b );  // Логическое значение true var  f  =  Boolean ( b . ValueOf ());  // логическое значение false var  n  =  new  Boolean ( b );  // Не рекомендуется n  =  new  Boolean ( b . ValueOf ());  // Предпочтительноif  ( 0  ||  - 0  ||  ""  ||  null  ||  undefined  ||  b . valueOf ()  ||  ! new  Boolean ()  ||  ! t )  {  console . журнал ( "Никогда не это" ); }  else  if  ([]  &&  {}  &&  b  &&  typeof  b  ===  "объект"  &&  b . toString ()  ===  "false") {  console . журнал ( «Всегда это» ); }

Символ [ править ]

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

Пример:

var  x  =  Symbol ( 1 ); var  y  =  Symbol ( 1 ); х  ===  у ;  // => ложьvar  symbolObject  =  {}; var  normalObject  =  {};// поскольку x и y уникальны, // их можно использовать как уникальные ключи в объекте symbolObject [ x ]  =  1 ; symbolObject [ y ]  =  2 ;symbolObject [ x ];  // => 1 symbolObject [ y ];  // => 2// по сравнению с обычными цифровыми клавишами normalObject [ 1 ]  =  1 ; normalObject [ 1 ]  =  2 ;  // отменяет значение 1normalObject [ 1 ];  // => 2// изменение значения x не меняет ключ, хранящийся в объекте x  =  Symbol ( 3 ); symbolObject [ x ];  // => не определено// изменение x назад просто создает еще один уникальный символ x  =  Symbol ( 1 ); symbolObject [ x ];  // => не определено

Есть также известные символы .

Один из которых Symbol.iterator; если что-то реализуется Symbol.iterator, это повторяется:

пусть  x  =  [ 1 ,  2 ,  3 ,  4 ];  // x - это массив x [ Symbol . итератор ]  ===  Массив . прототип [ Символ . итератор ];  // и массивы повторяютсяconst  xIterator  =  x [ Символ . итератор ] ();  // Функция [Symbol.iterator] должна предоставлять итератор для x xIterator . следующий ();  // {значение: 1, сделано: false} xIterator . следующий ();  // {значение: 2, готово: false} xIterator . следующий ();  // {значение: 3, готово: false} xIterator . следующий ();  // {значение: 4, готово: false} xIterator . следующий ();  // {value: undefined, done: true} xIterator . следующий (); // {value: undefined, done: true}// for..of петля автоматически итерация значения для  ( сопзИте  значение  из  й )  {  консоли . журнал ( значение );  // 1 2 3 4 }// Наборы также можно повторять: [ Symbol . итератор ]  в  Set . прототип ;  // правдадля  ( сопзЬ  значения  из  нового  набора ([ «яблоко» ,  «оранжевый» ]))  {  консоли . журнал ( значение );  // "яблоко" "апельсин" }

Родные объекты [ править ]

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

Массив [ править ]

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

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

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

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

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

myArray [ 1 ];  // 2-й элемент в myArray myArray [ "1" ];

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

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

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

let  myArray ;// Литералы массива myArray  =  [ 1 ,  2 ];  // длина 2 myArray  =  [ 1 ,  2 ,];  // тот же массив - в конце можно поставить дополнительную запятую// Также можно не заполнять части массива myArray  =  [ 0 ,  1 ,  / * hole * / ,  / * hole * / ,  4 ,  5 ];  // длина 6 myArray  =  [ 0 ,  1 ,  / * отверстие * / ,  / * отверстие * / ,  4 ,  5 ,];  // тот же массив myArray  =  [ 0 ,  1 ,  / * отверстие * / ,  / * отверстие * / ,  4 ,  5 ,  / * отверстие * /,];  // длина 7// С конструктором myArray  =  new  Array ( 0 ,  1 ,  2 ,  3 ,  4 ,  5 );  // длина 6 myArray  =  new  Array ( 365 );  // пустой массив длиной 365

Массивы реализованы так, что только определенные элементы используют память; они представляют собой « разреженные массивы ». Настройка и использует пространство только для этих двух элементов, как и любой другой объект. Длина массива будет по- прежнему , как сообщалось 58. максимальная длина массива составляет 4294967295 , который соответствует 32-битного двоичного числа (11111111111111111111111111111111) ₂ .myArray[10] = 'someThing'myArray[57] = 'somethingOther'

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

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

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

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

Дата [ править ]

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

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

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

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

Ошибка [ редактировать ]

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

выкидывать  новую  ошибку ( «Что-то пошло не так.» );

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

Математика [ править ]

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

Регулярное выражение [ править ]

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

Классы персонажей [ править ]

// \ d - цифра // \ D - не цифра // \ s - пробел // \ S - не пробел // \ w - слово char // \ W - не слово // [] - одно из // [ ^] - один не из // - - диапазонаесли  ( / \ d / . test ( '0' ))  console . журнал ( 'Цифра' ); if  ( / [0-9] / . test ( '6' ))  console . журнал ( 'Цифра' ); if  ( / [13579] / . test ( '1' ))  console . log ( 'Нечетное число' ); if  ( / \ S \ S \ s \ S \ S \ S \ S / . test ( 'My name' ))  console .log ( 'Форматировать ОК' ); if  ( / \ w \ w \ w / . test ( 'Tom' ))  console . журнал ( 'Привет, Том' ); if  ( / [a-zA-Z] / . test ( 'B' ))  console . журнал ( 'Письмо' );

Соответствие символов [ править ]

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

Ретрансляторы [ править ]

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

Якоря [ править ]

// ^ - строка начинается с // $ - строка заканчивается наif  ( / ^ My / . test ( "Меня зовут Том" ))  console . журнал  ( «Привет!» ); if  ( / Tom $ / . test ( "Меня зовут Том" ))  console . журнал  ( «Привет, Том!» );

Подвыражение [ править ]

// () - группирует символыif  ( / water (mark)? / . test ( "watermark" ))  console . журнал ( «Вот вода!» );  // совпадение: "вода", "водяной знак", if  ( / (Tom) | (John) / . test ( "John" ))  console . log ( «Привет, Том или Джон!» );

Флаги [ править ]

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

Расширенные методы [ править ]

my_array  =  моя_строка . разделить ( my_delimiter ); // пример my_array  =  "собака, кошка, корова" . split ( "," );  // my_array == ["собака", "кошка", "корова"];my_array  =  моя_строка . совпадение ( мое_выражение ); // пример my_array  =  "Мы начинаем в 11:30, 12:15 и 16:45" . совпадение ( / \ d \ d: \ d \ d / g );  // my_array == ["11:30", "12:15", "16:45"];

Группы захвата [ править ]

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

Функция [ править ]

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

// x, y - аргумент. return x + y - это тело функции, последнее в списке аргументов. var  add  =  new  Function ( 'x' ,  'y' ,  'return x + y' ); добавить ( 1 ,  2 );  // => 3

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

var  add  =  function ( x ,  y )  {  return  x  +  y ; }; добавить ( 1 ,  2 );  // => 3

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

var  add  =  ( x ,  y )  =>  { return  x  +  y ;}; // значения также могут быть возвращены неявно (т.е. оператор возврата не требуется) var  addImplicit  =  ( x ,  y )  =>  x  +  y ;добавить ( 1 ,  2 );  // => 3 addImplicit ( 1 ,  2 )  // => 3

Для функций, которые необходимо поднять, есть отдельное выражение:

функция  добавить ( х ,  у )  {  вернуть  х  +  у ; } добавить ( 1 ,  2 );  // => 3

Подъем позволяет использовать функцию до ее «объявления»:

добавить ( 1 ,  2 );  // => 3, а не функция  ReferenceError add ( x ,  y )  {  return  x  +  y ; }

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

функция  subtract ( x ,  y )  {  return  x  -  y ; }консоль . Журнал ( вычитают . длина );  // => 2, арность функции (количество аргументов) console . журнал ( вычесть . toString ());/ * "функция вычитания (x, y) {  return x - y; }" * /

Операторы [ править ]

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

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

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

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

Арифметика [ править ]

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

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

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

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

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

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

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

Назначение [ править ]

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

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

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

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

Деструктурирующее задание [ править ]

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

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

Оператор спреда / отдыха [ править ]

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

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

Другими словами, « ... » преобразует « [... foo] » в « [foo [0], foo [1], foo [2]] » и « this.bar (... foo); «в» this.bar (foo [0], foo [1], foo [2]); ».

var  a  =  [ 1 ,  2 ,  3 ,  4 ];// Его можно использовать несколько раз в одном выраженииvar  b  =  [... a ,  ... a ];  // b = [1, 2, 3, 4, 1, 2, 3, 4];// Можно комбинировать с нераспространенными предметами.var  c  =  [ 5 ,  6 ,  ... a ,  7 ,  9 ];  // c = [5, 6, 1, 2, 3, 4, 7, 9];// Для сравнения делаем это без оператора спреда // создает вложенный массив.var  d  =  [ a ,  a ];  // d = [[1, 2, 3, 4], [1, 2, 3, 4]]// То же самое и с вызовами функцийfunction  foo ( arg1 ,  arg2 ,  arg3 )  { консоль . журнал ( arg1  +  ':'  +  arg2  +  ':'  +  arg3 );}// Вы можете использовать его, даже если он передает больше параметров, чем функция будет использоватьфу (... а );  // «1: 2: 3» → foo (a [0], a [1], a [2], a [3]);// Можно смешивать с параметрами без спредаfoo ( 5 ,  ... a ,  6 );  // "5: 1: 2" → foo (5, a [0], a [1], a [2], a [3], 6);// Для сравнения делаем это без оператора спреда// присваивает массив arg1 и ничего другим параметрам.foo ( а );  // "1,2,3,4: undefined: undefined"

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

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

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

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

Сравнение [ править ]

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

var  obj1  =  { a :  1 }; var  obj2  =  { a :  1 }; var  obj3  =  obj1 ; консоль . журнал ( obj1  ==  obj2 );  // ложная консоль . журнал ( obj3  ==  obj1 );  // правда console . журнал ( obj3  ===  obj1 );  //правда

См. Также String .

Логический [ править ]

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

• унарное отрицание ( НЕ =! а )
• бинарная дизъюнкция ( OR = a || b ) и конъюнкция ( AND = a && b )
• тернарный условный ( c? t: f )

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

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

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

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

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

консоль . журнал (  ! 0  ===  логическое ( ! 0 )); консоль . журнал ( логический ( ! 0 )  ===  !! 1 ); консоль . журнал ( !! 1  ===  Boolean ( 1 )); консоль . журнал ( !! 0  ===  Boolean ( 0 )); консоль . журнал ( логический ( 0 ) ===  ! 1 ); консоль . журнал ( ! 1  ===  Boolean ( ! 1 )); консоль . log ( ! ""  ===  Boolean ( ! "" )); консоль . журнал ( логический ( ! "" )  ===  !! "s" ); консоль . журнал ( !! "s"  ===  Boolean ( "s" )); консоль .журнал ( !! ""  ===  Boolean ( "" )); консоль . журнал ( Boolean ( "" )  ===  ! "s" ); консоль . журнал ( ! "s"  ===  Boolean ( ! "s" ));

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

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

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

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

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

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

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

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

Логическое присвоение [ править ]

Побитовое [ править ]

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

Примеры:

х = 11  и  6 ; консоль . журнал ( х );  // 2

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

Побитовое присвоение [ править ]

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

Примеры:

х = 7 ; консоль . журнал ( х );  // 7 x << = 3 ; консоль . журнал ( х );  // 7-> 14-> 28-> 56

Строка [ править ]

Примеры:

str  =  "ab"  +  "cd" ;  // "abcd" str  + =  "e" ;  // "abcde"str2  =  "2"  +  2 ;  // «22», а не «4» или 4.

?? [ редактировать ]

const  a  =  b  ??  3 ;

const  a  =  b  ||  3 ;

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

Составные утверждения [ править ]

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

Если ... еще [ править ]

if  ( expr )  {  // операторы; }  else  if  ( expr2 )  {  // операторы; }  else  {  // операторы; }

Условный (тернарный) оператор [ править ]

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

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

такой же как:

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

В отличие от оператора if , условный оператор не может опускать «ветвь else».

Оператор переключения [ править ]

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

 switch  ( expr )  {  case  НЕКОТОРЫЕ ЗНАЧЕНИЕ :  // операторы;  перерыв ;  case  ANOTHERVALUE :  // операторы;  перерыв ;  по умолчанию :  // операторы;  перерыв ;  }

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

Для цикла [ править ]

Синтаксис цикла for в JavaScript следующий:

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

или же

 for  ( начальный ;  условие ;  оператор цикла  ( итерация )) // один оператор 

For ... in loop [ править ]

Синтаксис JavaScript for ... in loopследующий:

for  ( var  property_name  in  some_object )  {  // операторы, использующие some_object [property_name]; }

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

Пока цикл [ править ]

Синтаксис цикла while в JavaScript следующий:

while  ( условие )  {  оператор1 ;  оператор2 ;  statement3 ;  ... }

Do ... while loop [ править ]

Синтаксис JavaScript do ... while loopследующий:

сделать  {  statement1 ;  оператор2 ;  statement3 ;  ... }  while  ( условие );

С [ править ]

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

с  ( документ )  {  var  a  =  getElementById ( 'a' );  var  b  =  getElementById ( 'b' );  var  c  =  getElementById ( 'c' ); };

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

Семантика аналогична оператору with языка Паскаля .

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

Ярлыки [ править ]

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

loop1 :  for  ( var  a  =  0 ;  a  <  10 ;  a ++ )  {  if  ( a  ==  4 )  {  break  loop1 ;  // Остановка после 4-й попытки  }  console . журнал ( 'a ='  +  a );  loop2 :  for  ( var  b  =  0 ;  b  <  10 ;  ++ b )  {  if  (б  ==  3 )  {  продолжить  цикл2 ;  // Номер 3 пропускается  }  if  ( b  ==  6 )  {  continue  loop1 ;  // Продолжаем первый цикл, «готово» не отображается  }  console . журнал ( 'b ='  +  b );  }  console . журнал ( 'готово' ); } block1 :  {  console . журнал ( 'Привет' );  // Отображает  паузу "Hello" block1 ;  консоль . журнал ( 'Мир' );  // Здесь никогда не будет } goto  block1 ;  // Ошибка разбора.

Функции [ править ]

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

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

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

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

функция  add7 ( x ,  y )  {  если  ( ! y )  {  y  =  7 ;  }  console . журнал ( x  +  y  +  аргументы . длина ); }; add7 ( 3 );  // 11 add7 ( 3 ,  4 );  // 9

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

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

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

var  v  =  "Верх" ; var  bar ,  baz ; функция  foo ()  {  var  v  =  "fud" ;  bar  =  function ()  {  console . журнал ( v )  };  baz  =  функция ( x )  {  v  =  x ;  }; } foo (); баз ( «Фугли» ); бар (); // Фугл (не фуд), хотя foo () завершился. консоль . журнал ( v );  // Вершина

Объекты [ править ]

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

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

Создание объектов [ править ]

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

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

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

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

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

Методы [ править ]

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

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

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

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

function  px ()  {  вернуть  это . префикс  +  «X» ;  }функция  Foo ( yz )  {  this . префикс  =  "а-" ;  если  ( yz  >  0 )  {  это . pyz  =  function ()  {  верните  это . префикс  +  «Y» ;  };  }  else  {  this . pyz  =  function ()  {  верните  это . префикс  +  "Z" ;  };  }  это .m1  =  px ;  вернуть  это ; }var  foo1  =  новый  Foo ( 1 ); var  foo2  =  новый  Foo ( 0 ); foo2 . префикс  =  "b-" ;консоль . журнал ( "foo1 / 2"  +  foo1 . pyz ()  +  foo2 . pyz ()); // foo1 / 2 aY bZfoo1 . m3  =  px ;  // Назначает саму функцию, а не результат ее оценки, т.е. не px () var  baz  =  { "prefix" :  "c-" }; баз . m4  =  px ;  // Нет необходимости в конструкторе для создания объекта.консоль . журнал ( "m1 / m3 / m4"  +  foo1 . m1 ()  +  foo1 . m3 ()  +  baz . m4 ()); // m1 / m3 / m4 aX aX cXfoo1 . m2 ();  // Выдает исключение, потому что foo1.m2 не существует.

Конструкторы [ править ]

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

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

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

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

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

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

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

Наследование [ править ]

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

В следующем примере производный класс наследуется от базового класса. Когда d создается как Derived , ссылка на базовый экземпляр Base копируется в d.base .

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

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

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

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

function  m1 ()  {  return  "Один" ;  } function  m2 ()  {  return  "Два" ;  } function  m3 ()  {  return  "Три" ;  }функция  Base ()  {}База . прототип . м  =  м2 ; bar  =  новая  база (); консоль . журнал ( "бар.м"  +  бар . м ());  // bar.m Двафункция  Top ()  {  this . м  =  м3 ;  } t  =  новый  верх ();foo  =  новая  база (); База . прототип  =  t ; // Не влияет на foo, * ссылка * на t копируется. консоль . журнал ( "foo.m"  +  foo . m ());  // foo.m Дваbaz  =  новая  база (); консоль . журнал ( "baz.m"  +  baz . m ());  // baz.m Трит . m  =  m1 ;  // Влияет на baz и любые другие производные классы. консоль . журнал ( "baz.m1"  +  baz . m ());  // baz.m1 Один

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

Обработка исключений [ править ]

JavaScript включает оператор try ... catch ... finally обработки исключений для обработки ошибок времени выполнения.

В try ... catch ... finallyзаявлении улавливает исключения , возникающие в результате ошибки или бросок заявления. Его синтаксис следующий:

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

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

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

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

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

попробуйте  {  заявление ;  } catch  ( e  if  e  ==  "InvalidNameException" )  {  оператор ;  } catch  ( e  if  e  ==  "InvalidIdException" )  {  оператор ;  } catch  ( e  if  e  ==  "InvalidEmailException" )  {  оператор ;  } catch  ( e )  {  инструкция ;  }

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

onerror  =  функция  ( errorValue ,  url ,  lineNr )  {...;  return  true ;};

Собственные функции и методы [ править ]

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

eval (выражение) [ править ]

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

( функция  foo ()  {  var  x  =  7 ;  console . log ( "val"  +  eval ( "x + 2" )); }) ();  // показывает val 9.

См. Также [ править ]

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

Ссылки [ править ]

Дальнейшее чтение [ править ]

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

Внешние ссылки [ править ]

В Викиучебнике есть книга по теме: JavaScript.

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