ECMAScript — Википедия

ECMAScript
Класс языка язык программирования общего назначения[вд]
Появился в июнь 1997
Автор Брендан Эйх и Ecma International
Разработчик Брендан Эйх
Расширение файлов .es[2]
Выпуск ECMAScript 2024[Спецификация 1] (июнь 2024; 5 месяцев назад (2024-06))
Система типов утиная
Диалекты JavaScript, JScript, ActionScript, JScript .NET, QtScript
Испытал влияние Self[1], Си, Scheme[1], Perl[1], Python, Java[1], AWK[1]
Повлиял на Objective-J
Сайт ecma-international.org (англ.)

ECMAScript — встраиваемый расширяемый не имеющий средств ввода-вывода язык программирования, используемый в качестве основы для построения других скриптовых языков[3].

ECMAScript стандартизирован международной организацией ECMA в спецификации ECMA-262. Расширения языка: JavaScript, JScript и ActionScript.

История

[править | править код]

Язык возник на основе нескольких технологий, самыми известными из которых являются языки JavaScript и JScript. Разработка первой редакции спецификации началась в ноябре 1996 года. Принятие спецификации состоялось в июне 1997 года. Будучи отправленной в ISO/IEC JTC 1 для принятия по процедуре Fast-Tracking, она послужила основой международного стандарта ISO/IEC 16262. В июне 1998 года общим собранием ECMA была принята вторая редакция ECMA-262, соответствующая ISO/IEC 16262. Третья редакция спецификации отличалась от предыдущей введением поддержки регулярных выражений, улучшением поддержки строк, введением новых управляющих конструкций, механизма исключений, форматирования при численном вводе и некоторыми другими изменениями[Спецификация 2].

Семантика и синтаксис

[править | править код]

Типы данных

[править | править код]

В ECMAScript поддерживаются пять примитивных типов данных:

Числовой тип данных в ECMAScript соответствует 64-битному формату чисел с плавающей запятой, определённому стандартом IEEE 754-2008 за исключением того, что различные значения Not-a-Number, определяемые в стандарте[4], представляются в данном языке единственным специальным значением NaN[Спецификация 4].

Нулевой и неопределённый типы данных Дэвидом Флэнаганом неформально причисляются к «тривиальным» типам, поскольку каждый из них определяет только одно значение[5].

Также в языке имеется «составной» тип данных[5]:

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

Популярность языка JavaScript и нетривиальность обработки данных, относящихся к разным типам, обусловили развёртывание академических исследований в области анализа типов данных ECMAScript, ставящих своей целью создание полноценного анализатора кода, который можно было бы применять в интегрированных средах разработки[6].

Инструкции

[править | править код]

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

Типы инструкций, определяемые спецификацией языка[Спецификация 7]
Название Оригинальное название Краткие сведения Завершающая ;[Спецификация 8]
Блок англ. Block {[<инструкции>]} −
Объявление переменной англ. VariableStatement var <список объявления переменных> +
Пустая инструкция англ. EmptyStatement ; +
Выражение англ. ExpressionStatement [строка до ∉ {{, function}] инструкция +
Условие англ. IfStatement if (<инструкция>) <выражение>[ else <выражение>] −
Цикл англ. IterationStatement do <выражение> while (<инструкция>)

while (<инструкция>) <выражение>
for ([<инструкция до начала>]; [<инструкция>]; [<инструкция>]) <выражение>
for (<объявление переменных>; [<инструкция>]; [<инструкция>]) <выражение>
for (<lvalue-выражение> in <инструкция>) <выражение>
for (<объявление переменных> in <инструкция>) <выражение>

+/−[~ 1]
Продолжение англ. ContinueStatement continue [<идентификатор>] +
Прерывание англ. BreakStatement break [<идентификатор>] +
Возврат англ. ReturnStatement return [<инструкция>] +
Сочетание англ. WithStatement with (<инструкция>) <выражение> −
Метка англ. LabelledStatement <идентификатор>: <выражение> −
Выбор англ. SwitchStatement switch (<инструкция>) case <инструкция>: [<выражения>][ case <инструкция>: [<выражения>] …] [default: [<выражения>]] −
Генерация исключения англ. ThrowStatement throw <инструкция> +
Блок try англ. TryStatement try <блок> catch (<идентификатор>) <блок>
try <блок> finally <блок>
try <блок> catch (<идентификатор>) <блок> finally <блок> 		−
(новое[Спецификация 9]) Отладчик англ. Debugger debugger −

Автодополнение строк точками с запятой

[править | править код]

Несмотря на обязательность точки с запятой в случаях, отмеченных в четвёртой колонке, спецификация декларирует механизм автодополнения строк точками с запятой, приводящий к тому, что при наличии переноса строки инструкция до переноса может быть снабжена этим знаком[Спецификация 8], что является объектом критики[7].

Инструкции, меняющие смысл при использовании перевода строки внутри[Спецификация 8]
[править | править код]
  • Унарный постфиксный ++
  • Унарный постфиксный --
  • Продолжение
  • Прерывание
  • Возврат
  • Генерация исключения

Пример изменения смысла инструкции 

return {      status: "complete" };

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

Несмотря на то, что литеральная форма записи объекта блоком кода не является, единообразие в расстановке скобок может приводить к ошибкам. Снизить вероятность их появления способна выработка или принятие подходящего стандарта оформления кода. Играет роль выбор стиля отступов. В частности, стили Олмана и Уайтсмита, а также стиль Хорстмана и стиль GNU для кода JavaScript не рекомендуются к использованию большинством руководств[8] в отличие от стилей K&R, 1TBS, BSD KNF.

Несрабатывание механизма автодополнения
[править | править код]

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

func() ['h1', 'h2'].forEach(function(t) {     handleTag(t) })

В данном примере квадратные скобки на второй строке интерпретируются в качестве обращения к элементу массива, возвращаемого func(). Запятая в скобках трактуется как соответствующий оператор, возвращающий 'h2'. Таким образом, код преобразуется к следующему: 

func()['h2'].forEach(function(t) {     handleTag(t); });

В стандартах кодирования принято прописывать обязательность проставления точек с запятой даже в тех случаях, когда синтаксис языка позволяет их опускать[Стандарты кодирования 1][Стандарты кодирования 2][Стандарты кодирования 3][Стандарты кодирования 4][Стандарты кодирования 5].

Блоки и область видимости

[править | править код]

Ещё одной особенностью ECMAScript по отношению к другим C-подобным языкам является то, что в данном языке блоки не образуют области видимости. Объявленные в блоке переменные распространяются на всю функцию, содержащую блок[10][11].

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

function foo() {     var sum = 0;     for (var i = 0; i < 42; i += 2) {         var tmp = i + 2;         sum += i * tmp;     }     for (var i = 1; i < 42; i += 2) {         sum += i*i;     }     alert(tmp);     return sum; } foo();

Кроме того, к переменной tmp, объявленной внутри первого из циклов (строка 4), в соответствии с синтаксисом языка вполне законно обратиться извне цикла (строка 10).

Из-за особенностей, связанных с областью видимости и блоками, в целях поддержания качества исходного кода рекомендуется объявлять переменные в начале функций[10][Стандарты кодирования 1][Стандарты кодирования 4].

Объявление переменных

[править | править код]

Переменные определяются с помощью ключевых слов var, let, const. При объявлении переменная помещается в область видимости, соответствующую в случае var функции, а в случае let, const блоку кода. Если переменная объявляется вне функций, она помещается в глобальную область видимости. Создание переменной происходит при получении управления функцией с её объявлением. Или программой, если переменная глобальна. При создании переменной в ECMAScript она приобретает значение undefined. Если переменная объявлена с инициализацией, инициализация происходит не в момент создания переменной, а при выполнении строки с инструкцией var[Спецификация 10].

При раскомментировании выделенной строки на экран будет выводиться не number, а undefined: 

var a = 42; function foo() {     alert(typeof a);     // var a = 10; } foo();

При создании переменной она приобретает внутреннее свойство {DontDelete} и её невозможно удалить с помощью оператора delete[Спецификация 10]. Исключение составляют переменные, объявленные в контексте eval[12][Спецификация 11].

Многие источники[13][14][15][16][17][18] декларируют возможность неявного объявления переменных в ECMAScript при осуществлении присваивания корректному идентификатору, не являющемуся формальным аргументом функции, без предварительного объявления с помощью var. Однако в терминологии спецификации языка в этом случае создаётся свойство глобального объекта, а не переменная[12][Спецификация 10].

Фиксация в стандарте оформления кода необходимости обязательного объявления переменных до их использования[Стандарты кодирования 1][Стандарты кодирования 4] (либо фиксация необходимости использовать пространства имён для всех глобальных объектов[Стандарты кодирования 2]) позволяет избегать трудноуловимых ошибок, предотвращая опасность взаимодействия одинаково названных переменных в разных участках кода[19].

Ключевые и зарезервированные слова

[править | править код]

Следующие слова являются ключевыми в языке и не могут быть использованы как идентификаторы[Спецификация 12]: 

 break    do       instanceof typeof  case     else     new        var  catch    finally  return     void  continue for      switch     while  debugger function this       with  default  if       throw  delete   in       try

По сравнению с третьей редакцией спецификации[Спецификация 13] в пятой добавилось ключевое слово debugger с соответствующей инструкцией.

Следующие слова используются как ключевые слова в предложенных расширениях и поэтому являются зарезервированными для возможности адаптировать эти расширения[Спецификация 14]: 

 class enum   extends super  const export import

При использовании строгого режима следующие слова рассматриваются как зарезервированные для использования в будущем[Спецификация 14]: 

 implements let     private   public yield  interface  package protected static

Таким образом, по сравнению с третьей редакцией спецификации языка количество зарезервированных для использования в будущем слов существенно снизилось. Ранее их было 31[Спецификация 15], и наличие большого количества ключевых и зарезервированных слов, большинство из которых не используется в языке, подвергалось критике[20].

Операторы

[править | править код]

В ECMAScript имеются как операторы, использующие в качестве названий ключевые слова, так и операторы, использующие в качестве названий знаки препинания.

Классификация операторов

[править | править код]

По убыванию приоритета операторы ECMAScript можно разбить в следующие группы:

  • . (доступ к свойству),[] (доступ к свойству),() (вызов функции), new (создание нового объекта),
  • ++ (инкремент), -- (декремент), - (унарный минус), + (унарный плюс), ^ (поразрядное дополнение), ! (логическое дополнение), delete (удаление свойства), typeof (определение примитивного типа данных), void (возврат неопределённого значения),
  • * (умножение), / (деление), % (остаток от деления),
  • + (сложение), - (вычитание), + (конкатенация строк),
  • << (сдвиг влево), >> (сдвиг вправо с расширением знакового разряда), >>> (сдвиг вправо с дополнением нулями),
  • < (меньше), <= (меньше или равно), > (больше), >= (больше или равно), instanceof (проверка типа объекта), in (проверка наличия свойства),
  • == (проверка на равенство), != (проверка на неравенство), === (проверка на идентичность), !== (проверка на неидентичность),
  • & (поразрядная конъюнкция),
  • ^ (поразрядное сложение по модулю 2),
  • | (поразрядная дизъюнкция),
  • && (конъюнкция),
  • || (дизъюнкция),
  • ?: (тернарная условная операция),
  • = (присваивание), *=, /=, +=, -=, <<=, >>=, >>>=, &=, ^=, |= (присваивание с операцией),
  • , (множественное вычисление)[21].

Операторы ++, --, -, +, ~, !, delete, typeof, void, ?:, =, *=, /=, +=, -=, <<=, >=, >>>=, &=, ^=, |= правоассоциативны (то есть для них a op b op c эквивалентно a op (b op c)). Остальные операторы ECMAScript левоассоциативны[22].

По арности операторы ECMAScript делятся на следующие группы:

  • унарные (delete, void, typeof, ++, --, - (унарный минус), + (унарный плюс), ^, !, new)[Спецификация 16],
  • бинарные (., [], (), *, /, %, + (сложение), - (вычитание), + (конкатенация строк), <<, >>, >>>, <, <=, >, >=, instanceof, in, ==, !=, ===, !==, &, ^, |, &&, ||, =, *=, /=, +=, -=, <<=, >=, >>>=, &=, ^=, |=, ,),
  • тернарные (?:)[23],
  • операторы, не имеющие фиксированного количества операндов (())[24].

По положению знака операции относительно операндов операторы ECMAScript делятся на следующие группы:

  • префиксные (например, new, ++ (префиксный инкремент),
  • инфиксные (например, +, -),
  • постфиксные (например, ++ (постфиксный инкремент), -- (постфиксный декремент).

Также операторы классифицируются по типу операндов[25] и по характеру осуществляемого действия.

Особенности операторов ECMAScript

[править | править код]

В ECMAScript нет оператора, позволяющего проверить, относится ли свойство непосредственно к объекту или является унаследованным. Такая проверка осуществляется с помощью метода hasOwnProperty(). В связи с тем, что данный метод не является оператором, он может быть переписан любым другим свойством[26].

Оператор + является единственным арифметическим оператором в языке, который перегружен для строковых аргументов. Если хотя бы один из операндов — строка, + действует как конкатенатор, в противном случае выполняется сложение[27][Спецификация 17].

В отличие от языков, где void является типом данных, в ECMAScript это оператор, возвращающий значение undefined[28].

Оператор == осуществляет проверку на равенство по алгоритму, состоящему из 10 шагов, подразумевающему в ряде случаев преобразование типов[Спецификация 18], что, в конечном счёте, может привести к неочевидным результатам[29].

Пример результатов работы == (во всех перечисленных случаях значением оператора === с теми же аргументами будет false): 

alert("NaN" == NaN);       // false alert(NaN == NaN);         // false alert(true == 1);          // true alert(true == 42);         // false alert(null == 0);          // false alert(0 == "");            // true alert("" == 0);            // true alert("false" == false);   // false alert(false == 0);         // true alert(undefined == false); // false alert(null == false);      // false alert(undefined == null);  // true alert(" \t\r\n " == 0);    // true

Функции

[править | править код]
Основная статья: Функция (программирование)

Функции в ECMAScript являются объектами[30][31]. Конструктор, с помощью которого они создаются — Function(). Функции, как и любые другие объекты, могут храниться в переменных, объектах и массивах, могут передаваться как аргументы в другие функции и могут возвращаться функциями. Функции, как и любые другие объекты, могут иметь свойства. Существенной специфической чертой функций является то, что они могут быть вызваны[30].

Задание функций

[править | править код]

В ECMAScript имеется два типа функций:

  • внутренние функции (например, parseInt),
  • функции, определённые в тексте программы.

Внутренние функции представляют собой встроенные объекты (см. ниже), не обязательно реализованные на ECMAScript[Спецификация 19].

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

// объявление функции function sum(arg1, arg2) {     return arg1 + arg2; }  // задание функции с помощью инструкции var sum2 = function(arg1, arg2) {     return arg1 + arg2; };  // задание функции с использованием объектной формы записи var sum3 = new Function("arg1", "arg2", "return arg1 + arg2;");

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

Первые два способа дают похожий, но не идентичный эффект. Усугубляет ситуацию то, что инструкция, использующаяся при задании функции, может выглядеть очень похоже на объявление функции: во-первых, за ключевым словом function может следовать идентификатор[Спецификация 20], во-вторых, точка с запятой может быть опущена в силу механизма автодополнения строк точками с запятой[Спецификация 8]. Пример: 

// объявление функции function sum(arg1, arg2) {     return arg1 + arg2; }  // задание функции с помощью выражения var sum2 = function sum(arg1, arg2) {     return arg1 + arg2; }  function bar(){};  // использование объявления функции (function bar(){}) // использование соответствующей инструкции

Наиболее существенной разницей между заданием функции с использованием объявления и заданием функции с помощью выражения является то, что в первом случае создание переменной и присваивание ей в качестве значения функции осуществляются до выполнения кода при входе в контекст исполнения. Во втором случае переменная получает значение инициализатора при выполнении оператора присваивания. При создании же переменной, осуществляемом при входе в контекст исполнения, она инициализируется значением undefined[Спецификация 21][32] (подробнее см. в разделе Объявление переменных).

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

alert(sum(3, 4)); // 7: переменная sum к моменту выполнения этой строки уже создана и в качестве значения ей присвоена функция function sum(arg1, arg2) {     return arg1 + arg2; }  alert(sum2(3, 4)); // ошибка: переменная sum2 к моменту выполнения этой строки уже создана, но в качестве значения ей присвоено undefined var sum2 = function(arg1, arg2) {     return arg1 + arg2; };

Объявлением функций не следует пользоваться внутри условных конструкций[33], хотя в Gecko-браузерах это обработается интуитивным образом за счёт реализованного механизма функций как инструкций[34].

Присваивания функций

[править | править код]

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

var sum = function(arg1, arg2) {     return arg1 + arg2; };  alert(sum(3, 4));    // 7 var sum2 = sum; alert(sum2(4, 2));   // 6 sum = null; alert(sum2(42, 42)); // 84

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

Перегрузка функций

[править | править код]

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

Пример, показывающий отсутствие перегрузки функций: 

function sum(arg1, arg2) {     return arg1 + arg2; }  function sum(arg1, arg2, arg3) {     return arg1 + arg2 + arg3; }  alert(sum(3, 4));       // NaN alert(sum(3, 4, 5));    // 12

Если объявлено несколько функций с одинаковыми названиями, более поздние объявления перезаписывают ранние объявления[31].

Тем не менее, эффект перегрузки функций достижим.

1. Проверка на undefined. Для того, чтобы проверить, передан ли в функцию фактический аргумент, можно осуществить проверку формального аргумента на идентичность значению undefined. Например: 

function sum(arg1, arg2, arg3) {     if (arg3 !== undefined) {         return arg1 + arg2 + arg3;     } else {         return arg1 + arg2;     } }  alert(sum(3, 4));       // 7 alert(sum(3, 4, 5));    // 12

2. Проверка типа. Кроме того, typeof, instanceof, constructor могут быть использованы для выяснения типа фактических аргументов и кастомизации поведения функции в зависимости от них. 

function sum(arg1, arg2, arg3) {     switch (typeof arg3) {         case "undefined":             return arg1 + arg2;         case "number":             return arg1 + arg2 + arg3;         default:             return arg1 + arg2 + " (" + arg3 + ")";     } }  alert(sum(3, 4));       // 7 alert(sum(3, 4, 5));    // 12 alert(sum(3, 4, "!"));  // "7 (!)"

3. Обращение к данным об аргументах. В функциях ECMAScript можно получить доступ к данным об аргументах с помощью объекта arguments[Спецификация 22]. Он, в частности, позволяет воспользоваться индексированием для доступа к конкретным переданным аргументам[31][35] и свойством length, хранящем количество фактически переданных аргументов, что может быть полезно при применении парадигмы обобщённого программирования. 

function sum() {     var res = 0;     for (var i = 0; i < arguments.length; i++) {         res += arguments[i];     }     return res; }  alert(sum(3, 4));           // 7 alert(sum(3, 4, 5));        // 12 alert(sum(3, 4, 5, 7, 9));  // 28

Рекурсия

[править | править код]
Основная статья: Рекурсия § В программировании

Функции ECMAScript допускают рекурсивный вызов. При задании функции с помощью инструкции без указания идентификатора после ключевого слова function внутри функции можно обратиться к ней с помощью свойства callee объекта arguments[Спецификация 22].

Пример рекурсивного вычисления факториала: 

var factorial = function(step, res) {     res = res || 1;      if (step < 2) {          return res;      }      return arguments.callee(step - 1, step * res);  };  alert(factorial(5));           // 120

На данный момент в ECMAScript не реализована хвостовая рекурсия, применяемая для оптимизации рекурсивных вызовов[36].

Функции обратного вызова

[править | править код]
Основная статья: Callback (программирование)

В ECMAScript функция представляет собой объект первого класса и может быть передана в другую функцию как аргумент. Если она при этом вызывается в функции, в которую передаётся, то её называют функцией обратного вызова (или callback-функцией). Если при этом передаваемая функция не имеет имени, это анонимная функция обратного вызова (анонимная callback-функция)[37]. Основные причины использования функций обратного вызова:

  • избежание именования функции при оперировании с ней (способствует снижению числа глобальных переменных)[37],
  • делегирование вызова функции другой функции (способствует повышению выразительности кода)[37],
  • увеличение быстродействия[37],
  • упрощение оперирования с непродолжительными событиями[38].

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

function sumOfResults(callback) {     var result = 0;     for (var i = 1; i < arguments.length; i++) {         result += callback(arguments[i]);     }     return result; }  var square = function(x) {     return x * x; }; alert(sumOfResults(square, 3, 4)); // 25

Замыкания

[править | править код]
Основная статья: Замыкание (программирование)

Функциям в ECMAScript присуща лексическая область видимости. Это означает, что область видимости определяется в момент определения функции (в отличие от динамической области видимости, при которой область видимости определяется в момент вызова функции)[39].

При объявлении функции последовательность областей видимости, относящихся ко вложенным функциям, сохраняется как составляющая состояния функции. То есть в процессе выполнения программы функции, обладающие доступом к локальным переменным объемлющих функций, сохраняют такой доступ на протяжении всего выполнения программы[39].

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

(function() {  // Участок программы, доступ к переменным которого необходимо изолировать извне.  })();

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

Замыкания используются не только для запрещения доступа к ряду переменных, но и к модификации такого доступа. Это достигается с помощью функций, возвращающих другие функции. Пример функции-генератора последовательных чисел: 

var uniqueId = function() {     var id = 0;     return function() { return id++; }; }();  var aValue = uniqueId(); var anotherValue = uniqueId();

За счёт использования замыкания доступ к переменной id имеет только функция, которая была присвоена переменной uniqueId.

Пример карринга: 

var multNumber = function(arg) {     return function(mul) {         return arg * mul;     }; };  var multFive = multNumber(5); alert(multFive(7)); //35

Пример создания объекта, позволяющего осуществить доступ к свойству исключительно с помощью своих методов[40]: 

var myObject = function() {     var value = 0;      return {          increment: function (inc) {              value += typeof inc === 'number' ? inc : 1;          },          getValue: function (  ) {              return value;          }      }  }();  alert(myObject.value === undefined); // true alert(myObject.getValue()); // 0 myObject.increment(9) myObject.increment(7) alert(myObject.getValue()); // 16

Пользуясь этим приёмом, можно использовать замыкание для эмуляции констант[41]. 

var getConstant = function() {   var constants = {     UPPER_BOUND: 100,     LOWER_BOUND: -100   };   return function(constantName) {     return constants[constantName];   }; }();  alert(getConstant("LOWER_BOUND")); // -100

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

[править | править код]
Основная статья: Регулярные выражения

Синтаксис и функциональность регулярных выражений в ECMAScript сформировались под влиянием Perl 5[Спецификация 23] и допускают два вида синтаксиса: литеральный и объектный. 

var literalWay = /pattern/flags; var objectWay  = new RegExp(pattern, flags);

В первом случае шаблон (pattern) и флаги (flags) указываются явно, не сопровождаясь дополнительными избыточными синтаксическими знаками: их разделителями служат слеши. Во втором случае шаблон и флаги должны представлять собой переменные, содержащие строковые значения, либо непосредственно строковые значения. Литеральная форма записи предпочтительнее тем, что не требует двойного[~ 2] экранирования метасимволов регулярных выражений, в отличие от объектной формы[42].

В качестве флагов в ECMAScript могут использоваться следующие символы:

Флаги регулярных выражений[42][Спецификация 23]
Флаг Описание
g глобальный режим: шаблон применяется ко всем соответствиям в строке, работа регулярного выражения не останавливается после первого найденного соответствия шаблону
i игнорирование регистра: при поиске соответствий регистр символов шаблона и строки игнорируются
m многострочный режим: строка, содержащая символы перевода строки, трактуется как несколько строк, разделённых символами перевода строки; работа регулярного выражения осуществляется во всех строках

Каждое регулярное выражение представляет собой объект со следующими свойствами:

Свойства объекта регулярное выражение в ECMAScript[42][Спецификация 23]
Свойство Тип Описание
global логический показывает, установлен ли флаг g
ignoreCase логический показывает, установлен ли флаг i
multiline логический показывает, установлен ли флаг m
lastIndex числовой соответствует номеру позиции в строке, в которой обнаружилось совпадение с шаблоном в результате предыдущего применения регулярного выражения или 0, если регулярное выражение ранее не применялось
source строковый строка, соответствующая шаблону регулярного выражения

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

Методы объекта регулярное выражение в ECMAScript[42][Спецификация 23]
Метод Тип возвращаемого значения Описание
exec(handledString) объектный (массив) или null формирует массив подстрок, соответствующих заданному шаблону с учётом выставленных флагов. null, если никакая подстрока не соответствует шаблону
test(handledString) логический true, если нашлась строка, соответствующая шаблону и false в противном случае

Объекты

[править | править код]

Реализация в языке

[править | править код]

Объекты ECMAScript представляют собой неупорядоченные коллекции свойств, каждое из которых имеет один или более атрибутов, которые определяют, как может быть использовано свойство — например, если в качестве значения атрибута ReadOnly установлена истина, то любая попытка выполняющегося ECMAScript-кода поменять значение этого свойства останется безрезультатной. Свойства представляют собой контейнеры, инкапсулирующие другие объекты, значения примитивных типов и методы[Спецификация 24].

Атрибуты свойств объектов ECMAScript[Спецификация 25]
Название Описание
ReadOnly Свойство является свойством только для чтения. Попытка поменять значение этого свойства, предпринятая в программе, останется безрезультатной. В некоторых случаях значение свойства с установленным атрибутом ReadOnly меняется в силу действий среды расширения языка, поэтому ReadOnly не следует понимать как неизменное
DontEnum Свойство не перечисляется циклом for-in
DontDelete Попытки удалить это свойство будут проигнорированы
Internal Свойство является внутренним. Оно не имеет названия и к нему нельзя получить доступ с помощью аксессоров. Доступ к этим свойствам определяется реализацией языка.

Объекты ECMAScript подразделяются на базовые (native) и объекты расширения (host). Под базовыми понимаются любые объекты, независимые от окружения, относящегося к расширению языка. Некоторые из базовых объектов являются встроенными (built-in): существующими с самого начала выполнения программы. Другие могут быть созданы, когда программа выполняется. Объекты расширения предоставляются расширением ECMAScript, а для ECMAScript это значит, что они входят в объектную модель документа или в объектную модель браузера[Спецификация 3].

Синтаксис

[править | править код]

Для задания объектов может использоваться объектная и литеральная формы. Объектная форма задания объекта имеет синтаксис, аналогичный Java, но, в отличие от него, скобки в ECMAScript требуется использовать только при передаче аргументов в конструктор[43]. Синтаксически следующие записи эквивалентны: 

var obj1 = new Object(); var obj2 = new Object; var obj3 = {};

Однако второй вариант использовать не рекомендуется[43]. Дуглас Крокфорд рекомендует избегать и первого варианта, отдавая предпочтение литеральной форме, которую он считает большим достоинством языка[44].

Спецификация языка оперирует понятием свойства объекта, называя методом использующуюся в качестве свойства объекта функцию[Спецификация 3].

Каждый объект в языке имеет следующие свойства:

Свойства объектов ECMAScript[43]
Название Краткое описание
constructor Функция, использованная для создания объекта (в примерах выше это Object())
hasOwnProperty(propertyName) Показывает, существует ли данное свойство в объекте (не в его прототипе)
isPrototypeOf(object) Определяет, находится ли объект в цепи прототипов объекта-аргумента
propertyIsEnumerable(propertyName) Показывает, является ли свойство с данным названием перечислимым в цикле for-in
toString() Возвращает представление объекта в виде строки
valueOf() Возвращает значение this. Если же объект является результатом вызова конструктора объекта расширения, значение valueOf() зависит от реализации[Спецификация 26]. Зачастую в качестве возвращаемого значения выступает значение примитивного типа, соответствующее объекту. Как правило, результат данного метода совпадает с результатом toString(). Объекты, созданные с помощью конструктора Date() — яркий пример, где результаты toString() и valueOf() не совпадают[43].

Доступ к свойствам объекта осуществляется использованием точечной и скобочной записи: 

var obj = new Object(); alert(obj.constructor === obj["constructor"]); // true — использование точечной и скобочной записи для доступа к свойству  var foo = obj["toString"]; // использование скобочной записи для сохранения функции в переменную var result = obj["toString"](); // сохранение результата вызова функции в переменную alert(foo()); // вывод на экран результата вызова сохранённой функции alert(result);  var boo = obj.toString; // аналогично с использованием точечной записи var res = obj.toString(); alert(boo()); alert(res);

Задание новых свойств может осуществляться динамически. 

var country            = new Object(); country["name"]       = "Russia"; // использование скобочной записи country.foundationYear = 862; // использование точечной записи  var country2 = {     "name":           "Russia",     "foundationYear": 862 }; // использование литеральной формы

Подходы к созданию объектов

[править | править код]

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

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

В языке нет классов, однако их можно эмулировать за счёт использования конструкторов. Пример эмуляции класса в ECMAScript: 

function MyClass() {     this.myValue1 = 1;     this.myValue2 = 2; }  MyClass.prototype.myMethod = function() {     return this.myValue1 * this.myValue2; }  var mc      = new MyClass(); mc.myValue1 = mc.myValue2 * 2; var i       = mc.myMethod();

Особенности наследования в ECMAScript

[править | править код]

Для каждой из составляющих объекта можно рассматривать наследование. При наследовании интерфейса родителя без того, чтобы потомок использовал функциональность предка, говорят о наследовании интерфейса. При наследовании состояния осуществляется наследование объектом-потомком структуры данных объекта-предка. При наследовании функциональности речь идёт о наследовании вместе с интерфейсом и кода методов. Как правило, это влечёт необходимость организации наследования состояния, что делает разумным объединение наследования состояния и наследования функциональности в наследование реализации[46].

В отношении ECMAScript неприменимо лишь наследование интерфейсов, поскольку функции в языке не имеют сигнатур[45].

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

ECMAScript 6

[править | править код]

Принятие ES6 устранило многие классы проблем JavaScript[48][49][50][51].

Примечания

[править | править код]
  1. ↑ 1 2 3 4 5 Dr. Axel Rauschmayer. The Nature of JavaScript // Speaking JavaScript. — First Edition. — O’Reilly Media, 2014. — P. 41. — ISBN 978-1-449-36503-5. Архивировано 10 мая 2015 года.
  2. ↑ Scripting Media Type — 2006.
  3. ↑ Zakas N. ECMAScript // Professional JavaScript for Web Developers. — 2nd ed. — USA, Canada: Wiley Publishing, Inc, 2009. — P. 3—7. — ISBN 978-0-470-22780-0.
  4. ↑ Aiken A., Applegate M., Bailey D. and others. 6.2. Operations with NaNs // IEEE Standard for Floating-Point Arithmetic / Chair Zuras D., Editor Cowlishaw M. — USA, 2008. — P. 34. — ISBN 978-0-7381-5753-5.
  5. ↑ 1 2 Дэвид Флэнаган. 3. Типы данных и значения // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 39—66. — ISBN 5-93286-103-7.
  6. ↑ Jensen S., Møller A., Thiemann P. Type Analysis for JavaScript (англ.) // Lecture Notes in Computer Science : Материалы конф. / The 16th International Static Analysis Symposium (SAS 2009), Лос-Анджелес, США, 9 – 11 августа 2009. — Springer Berlin / Heidelberg, 2009. — Vol. 5673. — P. 238 — 255. — ISBN 978-3-642-03236-3. (недоступная ссылка)
  7. ↑ Crockford D. A.3. Semicolon Insertion // JavaScript: The Good Parts. — 2008. — P. 102. — ISBN 978-0-596-51774-8.
  8. ↑ Dr. Axel Rauschmayer. JavaScript’s Syntax // Speaking JavaScript. — First Edition. — O’Reilly Media, 2014. — P. 378. — ISBN 978-1-449-36503-5. Архивировано 10 мая 2015 года.
  9. ↑ Dr. Axel Rauschmayer. JavaScript’s Syntax // Speaking JavaScript. — First Edition. — O’Reilly Media, 2014. — P. 41. — ISBN 978-1-449-36503-5. Архивировано 10 мая 2015 года.
  10. ↑ 1 2 Crockford D. A.2. Scope // JavaScript: The Good Parts. — 2008. — P. 36. — ISBN 978-0-596-51774-8.
  11. ↑ Дэвид Флэнаган. 4.3.1. Отсутствие блочной области видимости // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 70—71. — ISBN 5-93286-103-7.
  12. ↑ 1 2 Сошников, Дмитрий Тонкости ECMA-262-3. Часть 2. Объект переменных. (27 июня 2009). Дата обращения: 6 ноября 2009. Архивировано 18 февраля 2012 года.
  13. ↑ Дэвид Флэнаган. 4.2. Объявление переменных // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 68. — ISBN 5-93286-103-7.
  14. ↑ Koch Peter-Paul. Implicit variable declaration // ppk on JavaScript / Editor: Wendy Sharp. — 1st ed. — New Riders Press, 2006. — 528 p. — ISBN 978-0-321-42330-6.
  15. ↑ Zakas N. Variables // Professional JavaScript for Web Developers. — 2nd ed. — USA, Canada: Wiley Publishing, Inc, 2009. — P. 26, 27. — ISBN 978-0-470-22780-0.
  16. ↑ Souders S. Use Local Variables // Even Faster Web Sites: Performance Best Practices for Web Developers. — 1st ed. — USA: O'Reilly Media, 2009. — P. 81—83. — ISBN 0596522304.
  17. ↑ Easttom C. Variable Declaration // Advanced Javascript. — 3rd ed. — USA: Wordware Publishing, Inc, 2008. — 81 — 83 p. — ISBN 1-59822-033-0.
  18. ↑ Keith J. Variables // DOM Scripting: Web Design with JavaScript and the Document Object Model. — 1st ed. — USA: Wordware Publishing, Inc, 2005. — 18 — 20 p. — ISBN 1590595335.
  19. ↑ Koch Peter-Paul. Chapter 5. Core. Section D. Variables // ppk on JavaScript / Editor: Wendy Sharp. — 1st ed. — New Riders Press, 2006. — 528 p. — ISBN 978-0-321-42330-6.
  20. ↑ Crockford D. A.4. Reserved Words // JavaScript: The Good Parts. — 2008. — 170 p. — ISBN 978-0-596-51774-8.
  21. ↑ Дэвид Флэнаган. 5.2. Обзор операторов // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 78—79. — ISBN 5-93286-103-7.
  22. ↑ Дэвид Флэнаган. 5.2.4 Ассоциативность операторов // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 81. — ISBN 5-93286-103-7.
  23. ↑ Дэвид Флэнаган. 5.2.1 Количество операндов // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 79. — ISBN 5-93286-103-7.
  24. ↑ Дэвид Флэнаган. 5.10.8 Оператор вызова функции // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 98. — ISBN 5-93286-103-7.
  25. ↑ Дэвид Флэнаган. 5.2.2 Тип операндов // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 80. — ISBN 5-93286-103-7.
  26. ↑ Crockford D. A.13. hasOwnProperty // JavaScript: The Good Parts. — 2008. — P. 107. — ISBN 978-0-596-51774-8.
  27. ↑ Crockford D. A.8. + // JavaScript: The Good Parts. — 2008. — 170 p. — ISBN 978-0-596-51774-8.
  28. ↑ Crockford D. B.12. void // JavaScript: The Good Parts. — 2008. — 170 p. — ISBN 978-0-596-51774-8.
  29. ↑ Crockford D. B.1. == // JavaScript: The Good Parts. — 2008. — 170 p. — ISBN 978-0-596-51774-8.
  30. ↑ 1 2 Crockford D. 4.1. Function Objects // JavaScript: The Good Parts. — 2008. — P. 26. — ISBN 978-0-596-51774-8.
  31. ↑ 1 2 3 4 Zakas N. The Function Type // Professional JavaScript for Web Developers. — 2nd ed. — USA, Canada: Wiley Publishing, Inc, 2009. — P. 122—130. — ISBN 978-0-470-22780-0.
  32. ↑ Сошников, Дмитрий Тонкости ECMA-262-3. Часть 1. Контексты исполнения. (26 июня 2009). Дата обращения: 12 октября 2010. Архивировано 16 октября 2010 года.
  33. ↑ Juriy "kangax" Zaytsev. Named function expressions demystified (англ.). — Статья, детально описывающая разницу между заданием функции с помощью объявления и заданием функции с помощью выражения. Дата обращения: 19 октября 2009. Архивировано из оригинала 19 июня 2009 года.
  34. ↑ Maian и др. Conditionally defining a function (англ.). Functions and function scope. — Описание деталей реализации функций как выражений в контексте объявлений внутри условий. Дата обращения: 19 октября 2009. Архивировано из оригинала 14 октября 2008 года.
  35. ↑ Crockford D. 4.4. Arguments // JavaScript: The Good Parts. — 2008. — P. 31. — ISBN 978-0-596-51774-8.
  36. ↑ Crockford D. 4.8. Recursion // JavaScript: The Good Parts. — 2008. — P. 35. — ISBN 978-0-596-51774-8.
  37. ↑ 1 2 3 4 Stefanov S. Callback Functions // Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications and libraries. — 1st ed. — Packt Publishing, 2008. — P. 73, 74. — ISBN 184719414.
  38. ↑ Crockford D. 4.11. Callbacks // JavaScript: The Good Parts. — 2008. — P. 40. — ISBN 978-0-596-51774-8.
  39. ↑ 1 2 Дэвид Флэнаган. 8.8. Область видимости функций и замыкания // JavaScript. Подробное руководство = JavaScript. The Definite Guide / Перевод А. Киселева. — 5-е изд. — СПб.: «Символ-Плюс», 2008. — С. 156—163. — ISBN 5-93286-103-7.
  40. ↑ Crockford D. 4.10. Closure // JavaScript: The Good Parts. — 2008. — 170 p. — ISBN 978-0-596-51774-8.
  41. ↑ Harmes R., Diaz D. Constants // Pro JavaScript™ Design Patterns. — USA: Apress, 2008. — P. 37, 38. — ISBN 1-59059-908-X.
  42. ↑ 1 2 3 4 Zakas N. The RegExp Type // Professional JavaScript for Web Developers. — 2nd ed. — USA, Canada: Wiley Publishing, Inc, 2009. — P. 115—122. — ISBN 978-0-470-22780-0.
  43. ↑ 1 2 3 4 Zakas N. The Object Type // Professional JavaScript for Web Developers. — 2nd ed. — USA, Canada: Wiley Publishing, Inc, 2009. — P. 40—41. — ISBN 978-0-470-22780-0.
  44. ↑ Crockford D. JSON // JavaScript: The Good Parts. — 2008. — P. 136. — ISBN 978-0-596-51774-8.
  45. ↑ 1 2 3 Zakas N. 6. Object-Oriented Programming // Professional JavaScript for Web Developers. — 2nd ed. — USA, Canada: Wiley Publishing, Inc, 2009. — P. 151—182. — ISBN 978-0-470-22780-0.
  46. ↑ Кузнецов, Михаил Наследование реализации в распределённых объектных системах. Издательство «Открытые системы» (11 декабря 2002). Дата обращения: 1 ноября 2009. Архивировано 17 февраля 2010 года.
  47. ↑ Stefanov S. Chapter 6. Inheritance. Summary // Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications and libraries. — 1st ed. — Packt Publishing, 2008. — P. 194—198. — ISBN 184719414.
  48. ↑ ECMAScript 6. Дата обращения: 17 марта 2017. Архивировано 20 декабря 2016 года.
  49. ↑ Введение в JS итераторы на ES6. Дата обращения: 17 марта 2017. Архивировано 10 июня 2017 года.
  50. ↑ ES6 Введение. Дата обращения: 17 марта 2017. Архивировано 20 декабря 2016 года.
  51. ↑ Стрелочные функции ES6. Дата обращения: 17 марта 2017. Архивировано 20 декабря 2016 года.

Стандарты ECMAScript

[править | править код]

Спецификации ECMAScript

[править | править код]
  1. ↑ Standard ECMA-262. 15th edition. ecma-international.org (июнь 2024). Дата обращения: 30 августа 2024. Архивировано 28 августа 2024 года.
  2. ↑ TC39. Brief History // ECMAScript Language Specification. — 5th ed. — 2009. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 8 декабря 2009. Архивировано 12 апреля 2015 года.
  3. ↑ 1 2 3 TC39. 4.3. Definitions // ECMAScript Language Specification. — 5th ed. — 2009. — P. 4. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  4. ↑ TC39. 8.5. The Number Type // ECMAScript Language Specification. — 5th ed. — 2009. — P. 29. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  5. ↑ 1 2 3 4 TC39. 8. Types // ECMAScript Language Specification. — 3rd ed. — 1999. — P. 24. Архивировано 11 апреля 2016 года.
  6. ↑ 1 2 3 4 TC39. 8. Types // 3rd edition, December 1999.pdf ECMAScript Language Specification. — 5th ed. — 2009. — P. 28. (недоступная ссылка)
  7. ↑ TC39. 12. Statements // ECMAScript Language Specification. — 5th ed. — 2009. — P. 86—97. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  8. ↑ 1 2 3 4 TC39. 7.9. Automatic Semicolon Insertion // ECMAScript Language Specification. — 5th ed. — 2009. — P. 25—28. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  9. ↑ TC39. 12. Statements // ECMAScript Language Specification. — 3rd ed. — 1999. — P. 61—71. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  10. ↑ 1 2 3 TC39. 12.2. Variable Statement // ECMAScript Language Specification. — 5th ed. — 2009. — P. 87, 88. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  11. ↑ TC39. 10.2.2. Eval Code // 3rd edition, December 1999.pdf ECMAScript Language Specification. — 3rd ed. — 1999. — P. 39. (недоступная ссылка)
  12. ↑ TC39. 7.6.1.1. Keywords // ECMAScript Language Specification. — 5th ed. — 2009. — P. 18. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  13. ↑ TC39. 7.5.2. Keywords // 3rd edition, December 1999.pdf ECMAScript Language Specification. — 3rd ed. — 1999. — P. 13—14. (недоступная ссылка)
  14. ↑ 1 2 TC39. 7.6.1. Reserved Words // ECMAScript Language Specification. — 5th ed. — 2009. — P. 18, 19. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  15. ↑ TC39. 7.5.3. Future Reserved Words // 3rd edition, December 1999.pdf ECMAScript Language Specification. — 3rd ed. — 1999. — P. 15. (недоступная ссылка)
  16. ↑ TC39. 11.4. Unary Operators // ECMAScript Language Specification. — 5th ed. — 2009. — P. 70—72. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  17. ↑ TC39. 11.6.1 The Addition operator ( + ) // ECMAScript Language Specification. — 5th ed. — 2009. — P. 74, 75. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  18. ↑ TC39. 11.9.3. The Abstract Equality Comparison Algorithm // ECMAScript Language Specification. — 5th ed. — 2009. — P. 80, 81. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  19. ↑ TC39. 4.3. Definitions // ECMAScript Language Specification. — 5th ed. — 2009. — P. 4—7. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  20. ↑ TC39. 13 Function Definition // ECMAScript Language Specification. — 5th ed. — 2009. — P. 97, 98. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  21. ↑ TC39. 12.2 Variable Statement // ECMAScript Language Specification. — 5th ed. — 2009. — P. 87, 88. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  22. ↑ 1 2 TC39. 10.6. Arguments Object // ECMAScript Language Specification. — 5th ed. — 2009. — P. 60—62. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  23. ↑ 1 2 3 4 TC39. 15.10. RegExp (Regular Expression) Objects // ECMAScript Language Specification. — 5th ed. — 2009. — P. 179—196. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  24. ↑ TC39. 4.2. Language Overview // ECMAScript Language Specification. — 5th ed. — 2009. — P. 2—4. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  25. ↑ TC39. 8.6.1. Property attributes // ECMAScript Language Specification. — 3rd ed. — 1999. — P. 25, 26. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.
  26. ↑ TC39. Properties of the Object Prototype Object // ECMAScript Language Specification. — 5th ed. — 2009. — P. 114—116. Архивировано 12 апреля 2015 года. Архивированная копия. Дата обращения: 11 ноября 2009. Архивировано 12 апреля 2015 года.

Комментарии

[править | править код]
  1. ↑ Только в отношении do-while
  2. ↑ Одним обратным слешем экранируются метасимволы строк (например, \t). Для экранирования метасимволов регулярных выражений используется двойной обратный слеш (например, \\s)

Стандарты оформления кода JavaScript

[править | править код]
  1. ↑ 1 2 3 Crockford, Douglas Code Conventions for the JavaScript Programming Language (англ.). Douglas Crockford's JavaScript. — Стандарт оформления кода JavaScript Дугласа Крокфорда. Дата обращения: 5 октября 2009. Архивировано 18 февраля 2012 года.
  2. ↑ 1 2 JavaScript Code Conventions (англ.). Echo Web Framework. NextApp, Inc. — Стандарт оформления кода JavaScript, принятый для Echo Web Framework. Дата обращения: 5 октября 2009. Архивировано 18 февраля 2012 года.
  3. ↑ Amaram, Rahul Javascript Naming Conventions, Coding Guidelines and Best Practices (англ.). Echo Web Framework. — Стандарт оформления кода JavaScript Рауля Амарама. Дата обращения: 5 октября 2009. Архивировано 18 февраля 2012 года.
  4. ↑ 1 2 3 Komenda, Klaus JavaScript Coding Guidelines and Standards (англ.). Сайт австрийского веб-разработчика Клауса Коменда. — Стандарт оформления кода JavaScript Клауса Коменда. Дата обращения: 5 октября 2009. Архивировано 18 февраля 2012 года.
  5. ↑ JavaScript coding style (англ.). GNOME. — Стандарт оформления кода JavaScript в GNOME. Дата обращения: 24 декабря 2009. Архивировано 18 февраля 2012 года.

Ссылки

[править | править код]
Источник — https://ru.wikipedia.org/w/index.php?title=ECMAScript&oldid=141316140