Войти
Синтаксис JavaScript - это набор правил которые определяют правильно структурированную программу JavaScript.
В приведенных ниже примерах используется функция журнала объекта консоли, присутствующая в большинстве браузеров для стандартного вывода текста.
В стандартной библиотеке JavaScript отсутствует официальная стандартная функция вывода текста. Учитывая, что JavaScript в основном используется для клиентских сценариев в современных веб-браузерах, и что почти все веб-браузеры предоставляют функцию оповещения, alertтакже можно использовать, но обычно не используется.
Брендан Эйх резюмировал происхождение синтаксиса в первом абзаце спецификации JavaScript 1.1 следующим образом:
JavaScript заимствует большую часть его синтаксис от Java, но также наследуется от Awk и Perl, с некоторым косвенным влиянием от Self в его системе прототипов объектов.
JavaScript чувствителен к регистру. Обычно имя конструктора начинается с буквы с большой буквы, а имя функции или переменной - с буквы нижнего регистра.
Пример:
var a = 5; console.log (а); // 5 console.log (A); // выдает ошибку ReferenceError: A не определено
Пробелы, табуляции и символы новой строки, используемые вне строковых констант, называются пробелами. В отличие от C, пробелы в исходном коде JavaScript могут напрямую влиять на семантику . Из-за техники, называемой «автоматическая вставка точки с запятой » (ASI), некоторые операторы, которые правильно сформированы при синтаксическом анализе новой строки, будут считаться завершенными (как если бы точка с запятой была вставлена непосредственно перед новой строкой). Некоторые авторитетные источники советуют явно указывать точку с запятой в конце оператора, поскольку это может уменьшить нежелательные эффекты автоматической вставки точки с запятой.
Есть две проблемы: пять токенов могут либо начинать оператор, либо быть продолжением полного оператора; и пять ограниченных производств, где разрывы строк не разрешены в определенных позициях, что потенциально может привести к неправильному синтаксическому анализу.
Пять проблемных токенов - открытая скобка «(», открытая скобка «[", косая черта" /", плюс" +"и минус" -". Из них открывающиеся скобки часто встречаются в немедленно вызываемое выражение функции шаблон и открытая скобка встречается иногда, в то время как другие встречаются довольно редко. Пример, приведенный в спецификации:
a = b + c (d + e) .foo () // Рассматривается как: // a = b + c (d + e) .foo ();
с предложением, чтобы предыдущий оператор завершался точкой с запятой.
Некоторые предлагают вместо этого использовать ведущие точки с запятой в строках, начинающихся с '(' или '[', чтобы строка не была случайно соединена с предыдущей. Это известно как защитная точка с запятой, и это особенно рекомендуется, потому что иначе код может стать неоднозначным при его изменении. Например:
a = b + c; (d + e) .foo () // Рассматривается как: // a = b + c; // (d + e) .foo ();
Начальные точки с запятой также иногда используются в начале библиотек JavaScript, в случае, если они добавляются к другой библиотеке, в которой отсутствует конечная точка с запятой, так как это может привести к неоднозначности исходного оператора.
Пять ограниченных производств: return, throw, break, continueи пост-инкремент / декремент. Во всех случаях установка точки с запятой не устраняет проблему, но делает синтаксис понятным, что упрощает обнаружение ошибки. returnи throwпринимают необязательное значение, а breakи continueпринимают необязательную метку. Во всех случаях рекомендуется оставлять значение или метку в той же строке, что и оператор. Чаще всего это проявляется в операторе return, где можно вернуть литерал большого объекта, который может быть случайно помещен с новой строки. Для постинкремента / декремента существует потенциальная двусмысленность с пре-инкрементом / декрементом, и снова рекомендуется просто держать их в одной строке.
вернуть a + b; // Возвращает undefined. Рассматривается как: // return; // a + b; // Следует записать как: // return a + b;
Комментарий синтаксис такой же, как в C ++ и многих других языках.
// короткий однострочный комментарий / * это длинный многострочный комментарий о моем скрипте. Пусть однажды это будет здорово. * / / * Комментарии / * могут не быть вложенными * / Синтаксическая ошибка * /
Переменные в стандартном JavaScript не имеют присоединенного типа типа, и любое значение может быть сохранено в любом переменная. Начиная с ES6, версии языка, завершенной в 2015 году, переменные можно объявлять с помощью let(для переменной уровня блока ), var(для переменной уровня функции ) или const(для неизменяемой). Однако, хотя объект, назначенный const, нельзя изменить, его свойства можно. До ES6 переменные объявлялись только с помощью оператора var. Идентификатор должен начинаться с буквы, подчеркивания (_) или знака доллара ($); последующие символы также могут быть цифрами (0-9). Поскольку JavaScript чувствителен к регистру, буквы включают символы от «A» до «Z» (верхний регистр) и символы от «a» до «z» (нижний регистр).
Начиная с JavaScript 1.5, в идентификаторах можно использовать буквы ISO 8859-1 или Unicode (или \ uXXXXescape-последовательности Unicode). В некоторых реализациях JavaScript знак at (@) может использоваться в идентификаторе, но это противоречит спецификациям и не поддерживается в новых реализациях.
Переменные лексически ограничены на уровне функции (не уровне блока, как в C), и это не зависит от порядка (предварительное объявление не требуется): если переменная объявлена внутри функции (в любой точке, в любом блоке), то внутри функции имя будет преобразовано в эту переменную. Это эквивалентно области видимости блока для переменных, объявляемых вперед в верхней части функции, и называется подъемом.
Однако значение переменной undefined, пока оно не инициализируется, и прямая ссылка невозможна. Таким образом, оператор var x = 1в середине функции эквивалентен оператору объявления var xв верхней части функции и x = 1оператор присваивания в этой точке в середине функции - поднимается только объявление, но не присваивание.
Операторы функций, результатом которых является объявление переменной типа Functionи присвоение ей значения, аналогичны операторам переменных, но в дополнение к подъему объявления они также поднимают присваивание - как если бы весь оператор появился в верхней части содержащей функцию - и, таким образом, прямая ссылка также возможна: расположение оператора функции внутри включающей функции не имеет значения.
Обязательно поймите, что
var func = function () {..} // НЕ будет поднята function func () {..} // будет поднятаОбласть видимости блока может быть создается путем оборачивания всего блока функцией и ее последующего выполнения - это известно как шаблон выражения немедленно вызываемой функции - или путем объявления переменной с помощью ключевого слова let.
Переменные, объявленные вне любой функции, являются глобальными. Если переменная объявлена в более высокой области видимости, к ней могут получить доступ дочерние функции.
Когда JavaScript пытается разрешить идентификатор, он смотрит в область локальной функции. Если этот идентификатор не найден, он просматривает внешнюю функцию, которая объявила локальную, и так далее по цепочке областей видимости, пока не достигнет глобальной области, в которой находятся глобальные переменные. Если он все еще не найден, JavaScript вызовет исключение ReferenceError.
Когда присваивает идентификатор, JavaScript выполняет точно такой же процесс для получения этого идентификатора, за исключением того, что если он не найден в глобальной области видимости, он создаст «переменную» как свойство глобального объекта. Как следствие, никогда не объявленная переменная будет глобальной, если она назначена. Объявление переменной (с ключевым словом var) в глобальном коде (т.е. вне тела функции), назначение никогда не объявленного идентификатора или добавление свойства к глобальному объекту (обычно window) также создаст новый глобальная переменная.
Обратите внимание, что строгий режим JavaScript запрещает присваивание необъявленной переменной, что позволяет избежать загрязнения глобального пространства имен. Также constнельзя объявить без инициализации.
Вот примеры объявления переменных и области действия:
var x = 0; // Глобальная переменная, потому что ее нет ни в одной функции function f () {var z = 'foxes', r = 'birds'; // 2 локальные переменные m = 'fish'; // глобальный, потому что он нигде не был объявлен до function child () {var r = 'monkeys'; // Эта переменная является локальной и не влияет на "птички" r родительской функции. z = 'пингвины'; // Закрытие: дочерняя функция имеет доступ к переменным родительской функции. } двадцать = 20; // Эта переменная объявлена в следующей строке, но ее можно использовать в любом месте функции, даже раньше, как здесь var 20; ребенок (); вернуть x; // Здесь можно использовать x, потому что он глобальный} f (); console.log (z); // Эта строка вызовет исключение ReferenceError, потому что значение z больше не доступнодля (let i = 0; i <10;i++) console.log(i); console.log(i); // throws a ReferenceError: i is not defined
for (const i = 0; i <10;i++) console.log(i); // throws a TypeError: Assignment to constant variable const pi; // throws a SyntaxError: Missing initializer in const declaration
Язык JavaScript предоставляет шесть примитивных типов данных :
Некоторые из примитивных типов данных также предоставляют набор именованных значений, которые представляют пределы границ типов. Эти именованные значения описаны в соответствующих разделах ниже.
Значение «undefined» присваивается всем неинициализированным переменным, а также возвращается при проверке свойств объекта, которые не существуют. В логическом контексте неопределенное значение считается ложным значением.
Примечание: undefined считается подлинным примитивным типом. Если явно не преобразовано, неопределенное значение может вести себя неожиданно по сравнению с другими типами, которые оцениваются как ложные в логическом контексте.
var test; // переменная объявлена, но не определена,... //... устанавливается значение undefined var testObj = {}; console.log (тест); // тестовая переменная существует, но значение не... //... определено, отображается неопределенное console.log (testObj.myProp); // testObj существует, свойства нет,... //... отображает undefined console.log (undefined == null); // не принудительный тип во время проверки, отображает true console.log (undefined === null); // принудительно использовать тип во время проверки, отображает falseПримечание: для undefined нет встроенного языкового литерала. Таким образом, (x == undefined)не является надежным способом проверить, является ли переменная undefined, потому что в версиях до ECMAScript 5 кто-то может написать var undefined = "Я определено сейчас ";. Более надежный подход заключается в сравнении с использованием (typeof x === 'undefined').
Подобные функции не будут работать должным образом:
function 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 '- нет.
В отличие от undefined, null часто устанавливается, чтобы указать, что что-то было объявлено, но определено как пустое. В логическом контексте значение null считается ложным значением в JavaScript.
Примечание: Null - это настоящий примитивный тип в языке JavaScript, из которых null (обратите внимание на регистр) является единственным значением. Таким образом, при выполнении проверок, требующих проверки типов, значение NULL не будет равняться другим типам false. Удивительно, но null считается объектом по типу.
console.log (null == undefined); // не принудительный тип во время проверки, отображает true console.log (null === undefined); // принудительно использовать тип во время проверки, отображает false console.log (typeof null === 'object'); // true
Изначально type нулевой результат, вызванный последовательностью совпадений. Хотя в настоящее время может быть объяснение, так как null отображается в конце цепочки прототипов, когда больше нет наследования. Полезно знать, что у null есть особое использование, которое отличается от других примитивов.
Числа представлены в двоичном виде как IEEE-754 удвоения, что обеспечивает точность почти 16 значащих цифр. Поскольку они являются числами с плавающей запятой, они не всегда точно представляют действительные числа, включая дроби.
Это становится проблемой при сравнении или форматировании чисел. Например:
console.log (0,2 + 0,1 == 0,3); // отображает истину согласно спецификации ECMASCRIPT 6 console.log (0.94 - 0.01); // отображает 0,9299999999999999
В результате следует использовать подпрограмму, такую как метод toFixed (), для округления чисел всякий раз, когда они отформатированы для вывода.
Числа могут быть указаны в любой из этих нотаций :
345; // «целое число», хотя в JavaScript 34.5 есть только один числовой тип; // число с плавающей запятой 3.45e2; // другое число с плавающей точкой, эквивалент 345 0b1011; // целое двоичное число, равное 11 0o377; // восьмеричное целое число 255 0xFF; // шестнадцатеричное целое число, равное 255, цифры, представленные... //... буквами AF, могут быть в верхнем или нижнем регистре
Экстенты +∞, −∞ и NaN (Не число) числового типа можно получить двумя программными выражениями:
Бесконечность; // положительная бесконечность (отрицательная, полученная, например, с -Infinity) NaN; // Значение Not-A-Number, также возвращаемое как сбой при преобразовании... //... строки в число
Infinity и NaN являются числами:
typeof Infinity; // возвращает «число» typeof NaN; // возвращает "число"
Эти три специальных значения соответствуют и ведут себя так, как их описывает IEEE-754.
Конструктор Number или унарный + или - может использоваться для выполнения явного числового преобразования:
var myString = "123.456"; var myNumber1 = Число (myString); var myNumber2 = + myString;
При использовании в качестве конструктора создается числовой объект-оболочка (хотя от него мало пользы):
myNumericWrapper = new Number (123.456);
Однако невозможно использовать операторы равенства (==и ===), чтобы определить, является ли значение NaN:
console.log (NaN == NaN); // ложь console.log (NaN === NaN); // ложь console.log (isNaN (NaN)); // верно var a = NaN; var b = a; console.log (а == б); // false
A string в JavaScript - это последовательность символов. В JavaScript строки можно создавать напрямую (как литералы), помещая серию символов между двойными (") или одинарными (') кавычками. Такие строки должны быть записаны в одной строке, но могут включать в себя экранированные символы новой строки (например, \ n). Стандарт JavaScript позволяет использовать символ обратной кавычки (`, также известный как серьезный акцент или обратную кавычку) для цитирования многострочных буквальных строк, но с 2016 года это поддерживается только в некоторых браузерах: Firefox и Chrome, но не в Интернете. Explorer 11.
var welcome = "Hello, World!"; Var anotherGreeting = 'Приветствую, люди Земли.';
Доступ к отдельным символам в строке можно получить с помощью метода charAt (предоставленного String.prototype). Это предпочтительный способ доступа к отдельным символам в строке, потому что он также работает в несовременных браузерах:
var h = welcome.charAt (0);
В современных браузерах к отдельным символам в строке можно получить доступ (как к строкам, состоящим только из одного символа) через тот же номер представление в виде массивов:
var h = welcome [0];
Однако строки JavaScript неизменяемы :
приветствие [0] = "H"; // Ошибка.
Применение оператора равенства ("==") к двум строкам возвращает истину, если строки имеют одинаковое содержимое, что означает: одинаковой длины и одинаковой последовательности символов (регистр важен для алфавитов). Таким образом:
var x = "World"; var compare1 = ("Привет," + x == "Привет, мир"); // Здесь compare1 содержит истину. var compare2 = ("Привет," + x == "Привет, мир"); // Здесь compare2 содержит... //... false, поскольку... //... первые символы... //... обоих операндов... //... не совпадают кейс.Цитаты одного типа не могут быть вложены, если они не экранированы.
var x = '"Hello, World!" он сказал.'; // Просто хорошо. var x = "« Привет, мир! »- сказал он.»; // Фигово. var x = "\" Привет, мир! \ "сказал он."; // Работает, экранируя "with \"
Можно создать строку с помощью конструктора String:
var welcome = new String ("Hello, World!");У этих объектов есть метод valueOf, возвращающий заключенную в них примитивную строку:
var s = new String ("Hello!"); typeof s; // Является объектом. typeof s.val ueOf (); // Строка.Равенство между двумя объектами String не работает как со строковыми примитивами:
var s1 = new String ("Hello!"); var s2 = new String («Привет!»); s1 == s2; // Ложь, потому что это два разных объекта. s1.valueOf () == s2.valueOf (); // Правда.JavaScript предоставляет Boolean тип данных с литералами true и false. Оператор typeof возвращает строку «boolean» для этих примитивных типов. При использовании в логическом контексте 0, -0, null, NaN, undefined и пустая строка ("") оцениваются как false из-за автоматического приведения типа к типу. Все остальные значения (дополнение предыдущего списка) оцениваются как true, включая строки «0», «false» и любой объект. Автоматического приведения типа операторами сравнения равенства (==и ! =) можно избежать, используя операторы сравнения с проверкой типа (===и ! ==).
Когда требуется преобразование типа, JavaScript преобразует операнды Boolean, Number, String или Object следующим образом:
Дуглас Крокфорд защищает термины «правдивость» и «ложь» для описания поведения значений различных типов при оценке в логическом контексте, особенно в отношении крайних случаев. Бинарные логические операторы возвращали логическое значение в ранних версиях JavaScript, но теперь вместо этого они возвращают один из операндов. Левый операнд возвращается, если его можно оценить как: ложь, в случае конъюнкции : (a b), или истина, в случай дизъюнкции : (a || b); в противном случае возвращается правый операнд. Автоматическое приведение типов операторами сравнения может отличаться для случаев смешанных логических и числовых операндов (включая строки, которые могут быть оценены как число, или объекты, которые могут быть оценены как такая строка), потому что логический операнд будет сравниваться как числовое значение. Это может быть неожиданно. Выражение можно явно преобразовать в логический примитив, удвоив логический оператор отрицания : (!!), используя функцию Boolean () или условный оператор : (c? T: f).
// Автоматическое приведение типа console.log (true == 2); // ложь... истина → 1! == 2 ← 2 console.log (false == 2); // ложь... ложь → 0! == 2 ← 2 console.log (true == 1); // истина.... истина → 1 === 1 ← 1 console.log (false == 0); // истина.... ложь → 0 === 0 ← 0 console.log (true == "2"); // ложь... истина → 1! == 2 ← "2" console.log (false == "2"); // ложь... ложь → 0! == 2 ← "2" console.log (true == "1"); // истина.... истина → 1 === 1 ← "1" console.log (false == "0"); // истина.... ложь → 0 === 0 ← "0" console.log (false == ""); // истина.... ложь → 0 === 0 ← "" console.log (false == NaN); // ложь... ложь → 0! == NaN console.log (NaN == NaN); // false...... NaN не эквивалентно ничему, включая NaN. // Сравнение проверенных типов (без преобразования типов и значений) console.log (true === 1); // false...... типы данных не совпадают // Явное приведение типов console.log (true === !! 2); // true.... типы данных и значения соответствуют console.log (true === !! 0); // false... типы данных совпадают, но значения различаются console.log (1? true: false); // истина.... только ± 0 и NaN - «ложные» числа console.log («0»? true: false); // истина.... только пустая строка является «ложной» console.log (Boolean ({})); // истина.... все объекты являются «правдивыми»Оператор new может использоваться для создания оболочки объекта для логического примитива. Однако оператор typeof не возвращает логическое значение для оболочки объекта, он возвращает объект. Поскольку все объекты оцениваются как true, для получения обернутого значения необходимо использовать такой метод, как.valueOf () или.toString (). Для явного принуждения к логическому типу 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.log ("Never this"); } else if ({} b typeof b === "объект" b.toString () === "false") {console.log ("Всегда это"); }Новое в ECMAScript6. Символ - это уникальный и неизменный идентификатор.
Пример:
x = Symbol (1); y = символ (1); х == у; // ложь arr = [x, y]; arr [x] = 1; arr [y] = 2; // x и y - уникальные ключи для массива arr arr [x]; // отображает 1 arr [y]; // отображает 2 x = Symbol (3); обр; // отображает [Symbol (1), Symbol (1)] arr [x]; // теперь не определено x = Symbol (1); arr [x]; // undefined
Оболочка Symbol также предоставляет доступ к итератору без переменных.
x = [1,2,3,4]; // x - это массив и итерация ex = x [Symbol.iterator] (); // предоставляет итератор для x while ((exv = ex.next (). value)! = undefined) console.log (exv); // отображает 1,2,3,4
Язык JavaScript предоставляет несколько собственных объектов. Собственные объекты JavaScript считаются частью спецификации JavaScript. Несмотря на среду JavaScript, этот набор объектов всегда должен быть доступен.
Массив - это объект JavaScript, прототип которого был создан из конструктора Array, специально разработанного для хранения значений данных, индексированных целочисленными ключами. Массивы, в отличие от базового типа Object, имеют прототипы с методами и свойствами, чтобы помочь программисту в повседневных задачах (например, join, sliceи push).
Как и в семействе C, массивы используют схему индексации с отсчетом от нуля: значение, вставляемое в пустой массив с помощью метода push, занимает 0-й индекс массива.
var myArray =; // Направляем переменную myArray на новый... //... созданный пустой массив myArray.push ("hello World"); // Заполняем следующий пустой индекс, в данном случае 0 console.log (myArray [0]); // Эквивалент console.log ("hello World");Массивы имеют свойство length, которое гарантированно всегда больше, чем самый большой целочисленный индекс, используемый в массиве. Он автоматически обновляется, если создается свойство с еще большим индексом. Запись меньшего числа в свойство lengthприведет к удалению больших индексов.
К элементам массиваможно получить доступ, используя обычную нотацию доступа к свойствам объекта:
myArray [1]; // второй элемент в myArray myArray ["1"];
Два вышеупомянутых эквивалента. Невозможно использовать обозначение «точка» или строки с альтернативными представлениями числа:
myArray.1; // синтаксическая ошибка myArray ["01"]; // не то же самое, что myArray [1]
Объявление массива может использовать либо литерал Array, либо конструктор Array:
myArray = [0, 1, 4, 5]; // массив из 6 и 6 элементов,... //... включая 2 неопределенных элемента myArray = new Array (0, 1, 2, 3, 4, 5); // массив длиной 6 и 6 элементов myArray = new Array (365); // пустой массив длиной 365
Массивы реализованы так, что только определенные элементы используют память; это «разреженные массивы ». Установка myArray [10] = 'someThing'и myArray [57] = 'somethingOther'использует пространство только для этих двух элементов, как и любой другой объект. длинамассива по-прежнему будет сообщаться как 58.
Можно использовать литерал объявления объекта для создания объектов, которые ведут себя так же, как ассоциативные массивы на других языках:
dog = { цвет: «коричневый», размер: «большой»}; собака ["окрас"]; // приводит к "коричневому" dog.color; // также приводит к «коричневому»Можно использовать литералы объявления объекта и массива для быстрого создания ассоциативных, многомерных массивов или и того, и другого. (Технически JavaScript не поддерживает многомерные массивы, но их можно имитировать с помощью массивов массивов.)
cats = [{color: "brown", size: "large"}, {color: "black", маленький размер"}]; кошки [0] ["размер"]; // приводит к "большим" собакам = {ровер: {цвет: "коричневый", размер: "большой"}, пятно: {цвет: "черный", размер: "маленький"}}; собаки ["пятно"] ["размер"]; // приводит к "маленьким" dog.rover.color; // приводит к "коричневому"A 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 = new Date (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.log (d);
Пользовательские сообщения об ошибках могут быть созданы с помощью класса Error:
throw new Error («Что-то пошло не так»);
Их можно перехватить с помощью блоков try... catch... finally, как описано в разделе обработка исключений.
Объект Mathсодержит различные математические константы (например, π) и функции (например, косинус). (Обратите внимание, что объект Mathне имеет конструктора, в отличие от Arrayили Date. Все его методы являются «статическими», то есть методами «класса».) Все тригонометрические функции используют углы, выраженные в радианах, а не в градусах или градусах.
| Property | Возвращаемое значение. округлено до 5 цифр | Описание |
|---|---|---|
| Math.E | 2.7183 | e : Основание натурального логарифма |
| Math.LN2 | 0,69315 | Натуральный логарифм от 2 |
| Math.LN10 | 2.3026 | Натуральный логарифм 10 |
| Math.LOG2E | 1.4427 | Логарифм по основанию 2 числа e |
| Math.LOG10E | 0,43429 | Логарифм по основанию 10 числа e |
| Math.PI | 3,14159 | π : длина окружности / диаметр круга |
| Math.SQRT1_2 | 0,70711 | Квадратный корень из ½ |
| Math.SQRT2 | 1.4142 | Квадратный корень из 2 |
| Пример | Возвращаемое значение. с округлением до 5 цифр | Описание |
|---|---|---|
| Math.abs(-2.3) | 2.3 | Абсолютное значение: (x < 0) ? -x : x |
| Math.acos (Math.SQRT1_2) | 0,78540 рад. = 45 ° | Арккосин |
| Math.asin (Math.SQRT1_2) | 0,78540 рад. = 45 ° | Арксинус |
| Математ. Атан (1) | 0,78540 рад. = 45 ° | Полукруг арктангенс (от -π / 2 до + π / 2) |
| Math.atan2 (-3.7, -3.7) | -2,3562 рад. = -135 ° | Арктангенс всего круга (от -π до + π) |
| Math.ceil (1.1) | 2 | Верхний предел: округлить до наименьшего целого числа ≥ аргумент |
| Math.cos (Math.PI / 4) | 0.70711 | Косинус |
| Math.exp(1) | 2.7183 | Экспоненциальная функция : e возведено в это значение power |
| Math.floor (1.9) | 1 | Floor: округлить до наибольшего целого числа ≤ аргумент |
| Math.log (Math.E) | 1 | Натуральный логарифм, основание e |
| Math.max (1, -2) | 1 | Максимум: (x>y)? x : y |
| Math.min(1, -2) | -2 | Minimum: (x < y) ? x : y |
| Math.pow(-3, 2) | 9 | Exponentiation (raised to the power of): Math.pow(x, y)gives x |
| Math.random() | 0.17068 | Pseudorandom number between 0 (inclusive) and 1 (exclusive) |
| Math.round(1.5) | 2 | Round to the nearest integer; half fractions are rounded up (e.g. 1.5 rounds to 2) |
| Math.sin(Math.PI/4) | 0.70711 | Sine |
| Math.sqrt(49) | 7 | Square root |
| Math.tan(Math.PI/4) | 1 | Tangent |
/expression/.test(string); // returns Boolean "string".search(/expression/); // returns position Number "string".replace(/expression/, replacement); // Here are some examples if (/Tom/.test("My name is Tom")) console.log("Hello Tom!"); console.log("My name is Tom".search(/Tom/)); // == 11 (letters before Tom) console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is John"// \d - digit // \D - non digit // \s - space // \S - non space // \w - word char // \W - non word // [ ] - one of // [^] - one not of // - - range if (/\d/.test('0')) console.log('Digit'); if (/[0-9]/.test('6')) console.log('Digit'); if (/[13579]/.test('1')) console.log('Odd number'); if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK'); if (/\w\w\w/.test('Tom')) console.log('Hello Tom'); if (/[a-zA-Z]/.test('B')) console.log('Letter');// A...Z a...z 0...9 - alphanumeric // \u0000...\uFFFF - Unicode hexadecimal // \x00...\xFF - ASCII hexadecimal // \t - tab // \n - new line // \r - CR //. - any character // | - OR if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim'); if (/A|B/.test("A")) console.log ('A or B');// ? - 0 or 1 match // * - 0 or more // + - 1 or more // {n} - exactly n // {n,} - n or more // {0,n} - n or less // {n,m} - range n to m if (/ab?c/.test("ac")) console.log("OK"); // match: "ac", "abc" if (/ab*c/.test("ac")) console.log("OK"); // match: "ac", "abc", "abbc", "abbbc" etc. if (/ab+c/.test("abc")) console.log("OK"); // match: "abc", "abbc", "abbbc" etc. if ( /ab{3}c/.test("abbbc ")) console.log (" ОК "); // совпадение: "abbbc" if (/ab{3,}c/.test("abbbc ")) console.log (" OK "); // соответствие: "abbbc", "abbbbc", "abbbbbc" и т. д. if (/ab{1,3}c/.test("abc ")) console.log (" OK "); // соответствие: "abc", "abbc", "abbbc"// ^ - строка начинается с // $ - строка заканчивается на if (/^My/.test(" Меня зовут Том ")) console.log (" Привет! "); if (/Tom$/.test(" Меня зовут Том ")) console.log (" Привет, Том! ");// () - группирует символы if (/water(mark)?/.test("watermark ")) console.log (" Вот вода! "); // совпадение: "вода", "водяной знак", if (/(Tom)|(John)/.test("John ")) console.log (" Привет, Том или Джон! ");// / g - глобальный // / i - игнорировать верхний / нижний регистр // / m - разрешить совпадения занимать несколько строк console.log ("привет Том!". Replace (/ Tom / i, "Джон")); // == "Привет, Джон!" console.log ("ratatam".replace (/ ta /, "tu")); // == "ратутам" console.log ("рататам".replace (/ ta / g, "tu")); // == "ratutum"my_array = my_string.split (my_delimiter); // пример my_array = "собака, кошка, корова".split (","); // my_array == ["собака", "кошка", "корова"]; my_array = my_string.match (мое_выражение); // пример my_array = "Мы начинаем в 11:30, 12:15 и 16:45".match (/ \ 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 ("Дата и время: 08.09.2009, 09:37:08."); если (результаты) {console.log ("Соответствует:" + результаты [0]); // Совпадение полностью var my_date = results [1]; // Первая группа == "2009-09-08" var my_time = results [2]; // Вторая группа == "09:37:08" console.log ("Это" + my_time + "on" + my_date); } else console.log («Не нашел подходящей даты!»);Каждая функция в JavaScript является экземпляром конструктора Function:
// x, y - аргумент. return x + y - это тело функции, последнее в списке аргументов. var add = new Function ('x', 'y', 'return x + y'); var t = add (1, 2); console.log (t); // 3Вышеупомянутая функция добавления также может быть определена с помощью выражения функции:
var add = function (x, y) {return x + y; }; var t = add (1, 2); console.log (t); // 3Существует сокращение для обозначения используемых функций, оно выглядит следующим образом:
function add (x, y) {return x + y; } var t = add (1, 2); console.log (t); // 3Или
var add = ((x, y) =>{return x + y;}); // или var add = ((x, y) =>x + y); var t = add (1, 2); console.log (t); // 3Экземпляр функции имеет свойства и методы.
функция subtract (x, y) {return x - y; } console.log (вычесть.длина); // 2, ожидаемое количество аргументов. console.log (subtract.toString ()); / * "function subtract (x, y) {return x - y;}" * /Оператор '+' перегружен : он используется для конкатенации строк и арифметическое сложение. Это может вызвать проблемы при случайном смешивании строк и чисел. Как унарный оператор, он может преобразовывать числовую строку в число.
// Объединяем 2 строки console.log ('He' + 'llo'); // отображает Hello // Сложите два числа console.log (2 + 6); // отображает 8 // Добавление числа и строки приводит к объединению console.log (2 + '2'); // отображает 22 console.log ('$' + 3 + 4); // отображает 34 доллара, но можно было ожидать 7 долларов console.log ('$' + (3 + 4)); // отображает $ 7 console.log (3 + 4 + '7'); // отображает 77, числа остаются числами, пока строка не будет добавлена // Преобразование строки в число console.log (+ '2' === 2); // отображает истинное значение console.log (+ 'Hello'); // отображает NaNТочно так же перегружен оператор '*': он может преобразовать строку в число.
console.log (2 + '6' * 1); // отображает 8 console.log (3 * '7'); // 21 console.log ('3' * '7'); // 21 console.log ('привет' * 'мир'); // отображает NaNJavaScript поддерживает следующие бинарные арифметические операторы :
| + | сложение |
| - | вычитание |
| * | умножение |
| / | деление (возвращает значение с плавающей запятой) |
| % | по модулю (возвращает остаток) |
| ** | возведение в степень |
JavaScript поддерживает следующие унарные арифметические операторы :
| + | унарное преобразование строки в число |
| - | унарное отрицание (меняет знак) |
| ++ | приращение (может быть префикс или постфикс) |
| -- | декремент (может быть префиксом или постфиксом) |
var x = 1; console.log (++ x); // x становится 2; отображает 2 console.log (x ++); // отображает 2; x становится 3 console.log (x); // x равно 3; отображает 3 console.log (x--); // отображает 3; x становится 2 console.log (x); // отображает 2; x равен 2 console.log (- x); // x становится 1; отображает 1
Оператор по модулю отображает остаток после деления на модуль. Если задействованы отрицательные числа, возвращаемое значение зависит от операнда.
var x = 17; console.log (x% 5); // отображает 2 console.log (x% 6); // отображает 5 console.log (-x% 5); // отображает -2 console.log (-x% -5); // отображает -2 console.log (x% -5); // отображает 2
Чтобы всегда вернуть неотрицательное число, повторно заменить модуль и снова применить оператор по модулю:
var x = 17; console.log ((- x% 5 + 5)% 5); // отображает 3
| = | присвоить |
| += | добавить и присвоить |
| -= | вычесть и присвоить |
| *= | умножить и назначить |
| /= | разделить и присвоить |
| %= | по модулю и присвоить |
| ** = | возведение в степень и присвоить |
var x = 9; х + = 1; console.log (х); // отображает: 10 x * = 30; console.log (х); // отображает: 300 x / = 6; console.log (х); // отображает: 50 x - = 3; console.log (х); // отображает: 47 x% = 7; console.log (х); // отображает: 5
Назначение типов объектов
/ ** * Чтобы изучить объекты JavaScript... * / var object_1 = {a: 1}; // присваиваем ссылку на вновь созданный объект объекту_1 var object_2 = {a: 0}; var object_3 = object_2; // объект_3 указанный на тот же объект, что и объект_2 объект_3.a = 2; сообщение (); // отображает 1 2 2 object_2 = object_1; // теперь объект_2 обратился на тот же объект, что и объект_1 // объект_3 по-прежнему установлен на объект_2, на который назван перед message (); // отображает 1 1 2 object_2.a = 7; // изменяет object_1 message (); // отображает 7 7 2 object_3.a = 5; // object_3 не меняет object_2 message (); // отображает 7 7 5 object_3 = object_2; object_3.a = 4; // объект_3 изменяет объект_1 и объект_2 message (); // отображает 4 4 4 / ** * Вывод сообщения console.log * / function message () {console.log (object_1.a + "" + object_2.a + "" + object_3.a); }В JavaScript Mozilla, начиная с версии 1.7, деструктурирующее присвоение позволяет назначать части структур данных сразу нескольким переменным. Левая часть присваивания - это шаблон, который напоминает произвольно вложенный литерал объекта / набора, предоставленное значение на своих листьях, которые должны получить подструктуры присвоенного значения.
var a, b, c, d, e; [a, b, c] = [3, 4, 5]; console.log (а + ',' + 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; console.log (а + ',' + b + ',' + arr); // отображает: 5,6, Baz,,, Content [a, b] = [b, a]; // меняем местами содержимого a и b console.log (a + ',' + b); // отображает: 6,5 [a, b, c] = [3, 4, 5]; // перестановки [a, b, c] = [b, c, a]; console.log (а + ',' + b + ',' + c); // отображает: 4,5,3Стандарт ECMAScript 2015 вводит оператор «...» для связанных понятий «синтаксиса распространения» и «остальные параметры»
Синтаксис расширения другой способ деструктуризации массивов. Он указывает, что в указанном массиве должен быть введен массив.
Другими словами, «...» преобразует «[... foo]» в «[foo [0], foo [1], foo [2]]"и" this.bar (... foo);"в" this.bar (foo [0], foo [1], foo [2]);".
1 переменная a = [1, 2, 3, 4]; 2 3 // Его можно использовать несколько раз в одном выражении 4 var b = [... a,... a]; // b = [1, 2, 3, 4, 1, 2, 3, 4]; 5 6 // Можно комбинировать с элементами без распространения 7 var c = [5, 6,... a, 7, 9 ]; // c = [5, 6, 1, 2, 3, 4, 7, 9]; 8 9 // Для сравнения: без распространения 10 // создается вложенный массив 11 var d = [a, a] ; // d = [[1, 2, 3, 4], [1, 2, 3, 4]] 12 13 // То же самое работает с вызовами функций 14 function foo (arg1, arg2, arg3) {15 console. журнал (arg1 + ':' + arg2 + ':' + arg3); 16} 17 18 // Вы можете использовать его, даже если он передает больше параметров, чем функция будет использовать 19 foo (... a); / / "1: 2: 3" → foo (a [0], a [1], a [2], a [3]); 20 21 // Вы можете смешивать это с применением без распространения 22 foo (5,... a, 6); // "5: 1: 2" → foo (5, a [0], a [1], a [2], a [3], 6); 23 24 // Для сравнения, при выполнении этого без распространения 25 // массив присваивается arg1 и ничего другим параметрам. 26 фу (а); // «1,2,3,4: undefined: undefined»Когда ...используется в объявлении функции, это указывает на параметр отдыха . Остальной параметр должен быть последним указанным параметром в списке параметров функции. Будет назначен массив , использованы любые аргументы, переданные функции сверх других именованных параметров. Другими словами, он получает «остальные» аргументы, переданные функции (отсюда и название).
функция foo (a, b,... c) {console.log (c.length); } foo (1, 2, 3, 4, 5); // «3» → c = [3, 4, 5] foo ('a', 'b'); // «0» → c =Остальные параметры аналогичны объекту аргументыв Javascript, который представляет собой объект, подобный массив, который содержит все параметры (названные и безымянные) в текущем вызове функции. Однако в отличие от arguments, остальные параметры являются истинными объектами Array, поэтому такие методы, как .slice ()и .sort ()одна из них на них напрямую.
Оператор ...может сообщить только с объектами Массив. (Однако есть предложение расширить его до Objectв будущем ECMAScript.)
| == | равно |
| != | не равно |
| > | больше, чем |
| >= | больше или равно |
| < | меньше |
| <= | меньше или равно |
| === | идентично (равно и того же типа) |
| ! == | не идентично |
Переменные указанные объекты равны или идентичны, только если они обнаруживаются на одном и том же объекте:
var obj1 = {a: 1}; var obj2 = {a: 1}; var obj3 = obj1; console.log (obj1 == obj2); // ложь console.log (obj3 == obj1); // правда console.log (obj3 === obj1); // истинаСм. также Строка.
JavaScript использует четыре логических оператора:
В контексте логической операции любое выражение оценивается как истинное, кроме следующих :
Логическая функция может быть сообщение для явного преобразования в примитив типа Boolean:
// Только пустые строки возвращают false console.log (Boolean ("") === false); console.log (Boolean ("false") === true); console.log (Boolean ("0") === true); // Только ноль и NaN возвращают false console.log (Boolean (NaN) === false); console.log (Boolean (0) === false); console.log (Boolean (-0) === false); // эквивалент -1 * 0 console.log (Boolean (-2) = == true); // Все объекты возвращают true c onsole.log (Boolean (this) === true); co nsole.log (Boolean ({}) === true); console.log (Boolean () === true); // Эти типы возвращают false console.log (Boolean (null) === false); console.log (Boolean (undefined) === false); // эквивалент Boolean ()Оператор НЕ оценивает свой операнд как логическое значение и возвращает отрицание. Использование оператора дважды подряд в двойного отрицательного значения явно преобразует выражение в примитив типа Boolean:
console.log (! 0 === Boolean (! 0)); console.log (Boolean (! 0) === !! 1); console.log (!! 1 === Boolean (1)); console.log (!! 0 === Boolean (0)); console.log (логический (0) ===! 1); console.log (! 1 === логическое (! 1)); console.log (! "" === Логическое (! "")); console.log (Boolean (! "") === !! "s"); console.log (!! "s" === Boolean ("s")); console.log (!! "" === Boolean ("")); console.log (Boolean ("") ===! "s"); console.log (! "s" === Boolean (! "s"));Тернарный оператор также Заявление для явного преобразования:
console.log (== false); console.log (? истина: ложь); // «правда», но для сравнения используется.toString () console.log ([0] == false); console.log ([0]? истина: ложь); // [0].toString () == "0" console.log ("0" == false); console.log («0»? истина: ложь); // «0» → 0... (0 == 0)... 0 ← false console.log ([1] == true); console.log ([1]? истина: ложь); // [1].toString () == "1" console.log ("1" == true); console.log («1»? истина: ложь); // «1» → 1... (1 == 1)... 1 ← true console.log ([2]! = True); console.log ([2]? истина: ложь); // [2].toString () == "2" console.log ("2"! = True); console.log ("2"? истина: ложь); // «2» → 2... (2! = 1)... 1 ← trueВыражения, использующие такие функции, как пост-инкремент (i ++), имеют ожидаемую сторону эффект. JavaScript обеспечивает оценку короткого замыкания выражений; правый операнд выполняется только в том случае, если левого операнда недостаточно для определения значения выражения.
console.log (a || b); // Когда a истинно, нет причин оценивать b. console.log (a b); // Когда a ложно, нет причин оценивать b. console.log (c? t: f); // Когда c истинно, нет причин оценивать f.
В ранних версиях JavaScript и JScript двоичные логические операторы возвращали логическое значение (как и большинство языков программирования на основе C). Однако все современные реализации этого возвращают один из своих операндов:
console.log (a || b); // если а истинно, вернуть а, иначе вернуть b console.log (a b); // если a ложно, вернуть a, иначе вернуть b
Программисты, которые более знакомы с поведением в C, могут найти эту функцию удивительной, но позволяет более краткое выражение шаблонов, таких как null coalescing :
var s = t || "(по умолчанию)"; // присваивает t или значение по умолчанию, если t равно null, пусто и т. д.
JavaScript поддерживает следующие двоичные побитовые операторы :
| И | |
| | | ИЛИ |
| ^ | XOR |
| ! | NOT |
| << | сдвиг влево (заполнение нулями справа) |
| >> | сдвиг вправо (распространение знака); копии самого левого бита. (бит знака) сдвигаются слева |
| >>> | сдвиг вправо (заполнение нулями слева). Для положительных чисел. >>и >>>дают одинаковый результат. |
Примеры:
x = 11 и 6; console.log (х); // 2
JavaScript поддерживает следующий унарный побитовый оператор :
| ~ | НЕ (инвертирует биты) |
JavaScript поддерживает следующие операторы двоичного присваивания:
| = | и |
| |= | или |
| ^= | xor |
| <<= | сдвиг влево (заполнение нулями справа) |
| >>= | сдвиг вправо (распространение знака); копии самого левого бита. (знаковый бит) сдвигаются слева |
| >>>= | сдвиг вправо (нулевое заполнение слева). Для положительных чисел. >>=и >>>=дают тот же результат. |
Примеры:
x = 7; console.log (х); // 7 x <<=3; console.log(x); // 7->14->28->56
| = | присвоение |
| + | конкатенация |
| += | объединение и присвоение |
Примеры:
str = "ab" + "cd"; // "abcd" str + = "e"; // "abcde" str2 = "2" + 2; // «22», а не «4» или 4.
Пара фигурных скобок {}и заключенная в них последовательность операторы составляет составной оператор, который можно использовать везде, где можно использовать оператор.
if (expr) {// операторы; } else if (expr2) {// операторы; } else {// операторы; }Условный оператор создает выражение, которое оценивает как одно из двух выражений в зависимости от условий. Это на оператора if, который выбирает для выполнения одного из двух операторов в зависимости от условий. То есть, условный оператор относится к выражениям, а если - к оператору.
результат = условие? выражение: альтернатива;
означает то же самое, что:
if (условие) {результат = выражение; } else {результат = альтернатива; }В отличие от оператора if, условный оператор не может опустить свою «ветвь else».
Синтаксис оператора JavaScript Switch следующий:
переключатель (выражение) {case SOMEVALUE: // операторы; перемена; case ANOTHERVALUE: // операторы; перемена; по умолчанию: // операторы; перемена; }Синтаксис JavaScript для цикла следующий:
for (начальное; условие; оператор цикла) {/ * операторы будут работать каждый раз, когда цикл для {} выполняется, пока условие выполнено * /}или
for (начальное; условие; оператор цикла (итерация)) // одна инструкция
Синтаксис JavaScript for... in loop следующий:
for (var property_name in some_object) {// операторы, использующие some_ob ject [название_свойства]; }if (some_object.hasOwnProperty (property_name)) {...}. Таким образом, добавление метода к прототипу массива с помощью Array.prototype.newMethod = function () {...} может привести к, что цикл для... inбудет перебирать имя метода..Синтаксис JavaScript цикл while следующий:
while (условие) {оператор1; оператор2; statement3;...}Синтаксис цикла JavaScript do... пока следующий:
do {statement1; оператор2; statement3;...} while (условие);Оператор с определенными свойствами и методами данного объекта в области действия следующего блока, позволяя ссылаться на них, как если бы они были локальными переменными.
с (документ) {var a = getElementById ('a'); var b = getElementById ('b'); var c = getElementById ('c'); };Семантика аналогична оператору с в Pascal.
, поскольку наличие операторов снижает производительность и, как считается, снижает ясность кода (любая заданная переменная на самом деле может быть своим путем из, заключенная в), этот оператор не разрешен в строгом режиме.
JavaScript поддерживает вложенные ярлыки в большинстве реализаций. Циклы или блоки могут быть помечены для оператора break, а циклы для continue. Хотя goto является зарезервированным словом, gotoне реализован в JavaScript.
loop1: for (var a = 0; a < 10; a++) { if (a == 4) { break loop1; // Stops after the 4th attempt } console.log('a = ' + a); loop2: for (var b = 0; b < 10; ++b) { if (b == 3) { continue loop2; // Number 3 is skipped } if (b == 6) { continue loop1; // Continues the first loop, 'finished' is not shown } console.log('b = ' + b); } console.log('finished'); } block1: { console.log('Hello'); // Displays 'Hello' break block1; console.log('World'); // Will never get here } goto block1; // Parse error.A function - это блок со (возможно, пустым) списком параметров, которым обычно дается имя. Функция может использовать локальные переменные. из функции без оператора return возвращается значение undefined.
function gcd (segmentA, segmentB) {var diff = segmentA - segmentB; if (diff == 0) return segmentA; return diff>0? gcd (segmentB, diff): gcd (segmentA, -diff);} console.log (gcd (60, 40)); // 20 var mygcd = gcd; // mygcd - это ссылка на ту же функцию, что и gcd. Обратите внимание на отсутствие аргумента () s. Console.log (mygcd (60, 40)); // 20Функции являются объектами первого класса и могут быть присвоены другим переменным.
Количество аргументов, передается при вызове функции, не обязательно может соответствовать количеству аргументов в определяющих функциях; именованный аргумент в параметре, который не имеет соответствующего аргумента в вызове, имеет значение undefine d (которое может быть неявно приведенным к false). В пределах t Функция, аргументы также могут быть доступны через объект аргументов ; это обеспечивает доступ ко всем аргументам с использованием индексов (например, arguments [0], arguments [1],... arguments [n]), включая те, которые превышают количество названных аргументов. (Хотя в списке аргументов есть свойство .length, он не является экземпляром Array; у него нет таких методов, как.slice (),.sort () и т. д.)
function add7 (x, y) {if (! y) {y = 7; } console.log (x + y + arguments.length); }; add7 (3); // 11 add7 (3, 4); // 9Примитивные значения (число, логическое значение, строка) передаются по значению. Для объектов это ссылка на объект, который передается.
var obj1 = {a: 1}; var obj2 = {b: 2}; функция foo (p) {p = obj2; // Игнорирует фактический параметр p.b = arguments [1]; } foo (obj1, 3); // Совершенно не влияет на obj1. 3 - дополнительный параметр console.log (obj1.a + "" + obj2.b); // пишет 1 3Функции могут быть объявлены внутри других функций и иметь доступ к локальным переменным внешней функции. Более того, они реализуют полное закрытие , запоминая локальные переменные внешней функции даже после выхода из внешней функции.
var v = "Top"; var bar, baz; функция foo () {var v = "fud"; бар = функция () {console.log (v)}; baz = функция (x) {v = x; }; } foo (); баз («Фугли»); бар(); // Неудачный (не fud), хотя foo () завершился. console.log (v); // ВерхДля удобства типы обычно подразделяются на примитивы и объекты. Объекты - это сущности, которые имеют идентичность (они равны только самим себе) и отображают имена свойств в значения («слоты» в терминологии программирования на основе прототипов ). Объекты можно рассматривать как ассоциативные массивы или хэши, и они часто реализуются с использованием этих структур данных. Однако у объектов есть дополнительные функции, такие как цепочка прототипов, которых нет у обычных ассоциативных массивов.
JavaScript имеет несколько видов встроенных объектов, а именно: Array, Boolean, Date, Function, Математика, Число, Объект, Регулярное выражениеи Строка. Другие объекты - это «хост-объекты», которые определяются не языком, а средой выполнения. Например, в браузере типичные хост-объекты принадлежат DOM (окно, форма, ссылки и т. Д.).
Объекты могут быть созданы с помощью конструктора или литерала объекта. Конструктор может использовать либо встроенную функцию Object, либо пользовательскую функцию. По соглашению функциям-конструкторам присваивается имя, начинающееся с заглавной буквы:
// Конструктор var anObject = new Object (); // Литерал объекта var objectA = {}; var objectA2 = {}; // A! = A2, {} s создают новые объекты как копии. var objectB = {index1: 'значение 1', index2: 'значение 2'}; // Пользовательский конструктор (см. Ниже)Литералы объектов и литералы массивов позволяют легко создавать гибкие структуры данных:
var myStructure = {name: {first: "Mel", last: "Smith"}, age: 33 года, увлечения: [«шахматы», «бег трусцой»]};Это основа для JSON, который представляет собой простую нотацию, использующую синтаксис, подобный JavaScript, для обмена данными.
A Метод - это просто функция, которая была назначена имени свойства объекта. В отличие от многих объектно-ориентированных языков, в объектно-ориентированномJavaScript не отличается между определением функций и определением метода. Скорее, различие происходит во время вызова функции; функцию можно вызвать как метод.
При вызове в качестве метода стандартной локальная переменная просто автоматически устанавливается для экземпляра объекта слева от ".". (Также существуют методы call и apply, которые могут явно установить this - некоторые пакеты, такие как jQuery, делают необычные вещи с this.)
В приведенном ниже примере Foo используется как конструктор. Вторе нет ничего особенного - это просто функция, которая инициализирует объект. При использовании с ключевым словом новый, как обычно, устанавливается на вновь созданный пустой объект.
Обратите внимание, что в приведенном ниже примере Foo просто присваивает значения слотам, которые используются в некоторых функциях. Таким образом, он может назначать разные функции разным экземплярам. В этом примере нет прототипа.
function px () {вернуть this.prefix + "X"; } функция Foo (yz) {this.prefix = "a-"; if (yz>0) {this.pyz = function () {вернуть this.prefix + "Y"; }; } else {this.pyz = function () {вернуть this.prefix + "Z"; }; } this.m1 = px; вернуть это; } var foo1 = новый Foo (1); var foo2 = новый Foo (0); foo2.prefix = "b-"; console.log ("foo1 / 2" + foo1.pyz () + foo2.pyz ()); // foo1 / 2 a-Y b-Z foo1.m3 = px; // Назначает саму функцию, а не результат ее оценки, т.е. не px () var baz = {"префикс": "c-"}; baz.m4 = px; // Нет необходимости в конструкторе для создания объекта. console.log ("m1 / m3 / m4" + foo1.m1 () + foo1.m3 () + baz.m4 ()); // m1 / m3 / m4 a-X a-X c-X foo1.m2 (); // Выдает исключение, потому что foo1.m2 не существует.Функции конструктора просто присваивают значения слотам вновь созданного объекта. Значения могут быть данные или другие функции.
Пример: манипулирование объектом:
функция MyObject (attributeA, attributeB) {this.attributeA = attributeA; this.attributeB = attributeB; } MyObject.staticC = "синий"; // В функции MyObject, а не в объекте console.log (MyObject.staticC); // синий объект = новый MyObject ('красный', 1000); console.log (объект.attributeA); // красный console.log (object ["attributeB"]); // 1000 console.log (object.staticC); // неопределенный объект. attributeC = новая дата (); // добавляем новое свойство delete object.attributeB; // удаляем свойство объекта console.log (object.attributeB); // неопределенный объект удаления; // удаляем весь объект (редко используется) console.log (object.attributeA); // выдает исключениеНа сам конструктор ссылается в слоте конструктора прототипа объекта. Итак,
function Foo () {} // Использование 'new' устанавливает слоты прототипа (например, // x = new Foo () установит прототип x в Foo.prototype, // и Foo.prototype имеет слот конструктора, указывающий обратно на Foo). х = новый Foo (); // Вышеупомянутое почти эквивалентно y = {}; y.constructor = Foo; y.constructor (); // За исключением x.constructor == y.constructor // true x instanceof Foo // true y instanceof Foo // false // прототипом y является Object.prototype, а не // Foo.prototype, поскольку он был инициализирован с помощью // {} вместо нового Foo. // Даже если для Foo задан слот конструктора y, // это игнорируется instanceof - учитывается только слот конструктора прототипа y.Само собой разумеется, что это объект, который использует эффект «статическим» (с использованием терминологии C ++ / Java), как показано ниже. (Функциональный объект также имеет специальное свойство prototype, как обсуждается в разделе «Наследование» ниже.)
Удаление объекта редко используется, поскольку механизм сценариев собирает мусор объекты, на которые больше не упоминаются.
Поддержка иерархии наследования через JavaScript посредством прототипирования в манере Сам.
В следующем примере производный класс наследуется от базового класса. Когда d создается как Производный, ссылка на базовый экземпляр База копируется в d.base.
Derive не содержит значения для aBaseFunction, поэтому оно извлекается из aBaseFunction при доступе к aBaseFunction. Это становится понятным путем изменения значения base.aBaseFunction, которое отражается в значении d.aBaseFunction.
Некоторые позволяют получить доступ к прототипу или явно установить его, используя слот __proto__, как показано ниже.
функция Base () {this.anOverride = function () {console.log ("Base :: anOverride ()"); }; this.aBaseFunction = function () {console.log ("Base :: aBaseFunction ()"); }; функция Derived () {this.anOverride = function () {console.log ("Derived :: anOverride ()"); }; } base = new Base (); Derived.prototype = base; // Должен быть перед new Derived () Derived.prototype.constructor = Derived; // Требуется для работы ʻinstanceof` d = new Derived (); // Копирует Derived.prototype в скрытый слот прототипа экземпляра d. d instanceof Derived; // истина d instanceof Base; // правда base.aBaseFunction = function () {console.log ("Base :: aNEWBaseFunction ()"); } d.anOverride (); // Derived :: anOverride () d.aBaseFunction (); // Base :: aNEWBaseFunction () console.log (d.aBaseFunction == Derived.prototype.aBaseFunction); // правда console.log (d.__ proto__ == base); // true в реализации на основе Mozilla и false во многих других.Следующее ясно показывает, как ссылки на прототипы копируются при создании экземпляров, но что изменения в прототипе могут повлиять на все экземпляры, которые указаны на него.
function m1 () {return "One"; } function m2 () {return "Два"; } function m3 () {return "Три"; } function Base () {} Base.prototype.m = m2; bar = новая база (); console.log ("bar.m" + bar.m ()); // bar.m Две функции Top () {this.m = m3; } t = новый верх (); foo = новая база (); Base.prototype = t; // Не влияет на foo, * ссылка * на t копируется. console.log ("foo.m" + foo.m ()); // foo.m Two baz = new Base (); console.log ("baz.m" + baz.m ()); // baz.m Три t.m = m1; // Влияет на baz и любые другие производные классы. console.log ("baz.m1" + baz.m ()); // baz.m1 Один. используется как мощным, так и запутанным.
JavaScript включает инструкцию try... catch... finallyобработки исключений для обработки ошибок времени выполнения.
Оператор попробуйте... поймать... наконецперехватывает исключение, возникают в результате ошибки или оператора throw. Его синтаксис следующий:
try {// Операторы, в которых могут возникнуть исключения} catch (errorValue) {// Операторы, которые выполняются в случае исключения} finally {// Операторы, которые выполняются позже в любом случае}Первоначально выполняются операторы в блоке try. Если генерируется исключение, поток управления скрипта переходит к операм в блоке catch, причем исключение доступно в качестве аргумента ошибки. В противном случае блок перехвата пропускается. Блок catch может выдать (errorValue), если он не хочет обрабатывать конкретную ошибку.
В любом случае операторы в блоке, наконец, всегда выполняются. Это можно использовать для освобождения ресурсов, хотя память автоматически собирается сборщиком мусора.
Можно опустить предложение catch или finally. Аргумент улов является обязательным.
Реализация Mozilla позволяет использовать несколько операторов для расширения стандарта ECMAScript. Они следуют синтаксису, аналогичному используемому в Java :
try {statement; } 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представляет серьезную угрозу безопасности, поскольку позволяет злоумышленнику выполнять произвольный код, и его использование не рекомендуется.
(функция foo () {var x = 7; console. Журнал ("val" + eval ("x + 2"));}) (); // показывает значение 9.Пропуск точки с запятой - плохая практика программирования; вы должны выработать привычку вставлять их.
 | В Викиучебнике есть книга по теме: JavaScript |
