Задний план
В этом разделе дается небольшая предыстория JavaScript, чтобы помочь вам понять, почему он такой, какой он есть.
JavaScript против ECMAScript
ECMAScript — это официальное название JavaScript. Новое имя стало необходимым, потому что на JavaScript есть торговая марка (первоначально принадлежавшая Sun, а теперь Oracle). На данный момент Mozilla — одна из немногих компаний, которым разрешено официально использовать название JavaScript, потому что она давно получила лицензию. Для общего использования применяются следующие правила:
- JavaScript означает язык программирования.
- ECMAScript — это имя, используемое спецификацией языка. Поэтому всякий раз, когда речь идет о версиях языка, люди говорят ECMAScript. Текущая версия JavaScript — ECMAScript 5; В настоящее время разрабатывается ECMAScript 6.
Влияния и природа языка
У создателя JavaScript, Брендана Эйха, не было другого выбора, кроме как очень быстро создать язык (иначе Netscape приняла бы другие, худшие технологии). Он заимствовал из нескольких языков программирования: Java (синтаксис, примитивные значения и объекты), Scheme и AWK (первоклассные функции), Self (прототипное наследование), Perl и Python (строки, массивы и регулярные выражения).
В JavaScript не было обработки исключений до версии ECMAScript 3, что объясняет, почему язык так часто автоматически конвертирует значения и так часто молча терпит неудачу: изначально он не мог генерировать исключения.
С одной стороны, у JavaScript есть особенности, и ему не хватает некоторых функций (переменные с блочной областью видимости, модули, поддержка подклассов и т. д.). С другой стороны, он имеет несколько мощных функций, позволяющих обойти эти проблемы. На других языках вы изучаете особенности языка. Вместо этого в JavaScript вы часто изучаете шаблоны.
Учитывая его влияние, неудивительно, что JavaScript поддерживает стиль программирования, представляющий собой смесь функционального программирования (функции более высокого порядка, встроенная карта, сокращение и т. д.) и объектно-ориентированного программирования (объекты, наследование).
Синтаксис
В этом разделе объясняются основные синтаксические принципы JavaScript.
Обзор синтаксиса
Несколько примеров синтаксиса:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Two slashes start single-line comments
var x; // declaring a variable
x = 3 + y; // assigning a value to the variable `x`
foo(x, y); // calling function `foo` with parameters `x` and `y`
obj.bar(3); // calling method `bar` of object `obj`
// A conditional statement
if (x === 0) { // Is `x` equal to zero?
x = 123;
}
// Defining function `baz` with parameters `a` and `b`
function baz(a, b) {
return a + b;
}
Обратите внимание на два разных использования знака равенства:
- Одиночный знак равенства (=) используется для присвоения значения переменной.
- Тройной знак равенства (===) используется для сравнения двух значений (см. Операторы равенства).
Операторы против выражений
Чтобы понять синтаксис JavaScript, вы должны знать, что он имеет две основные синтаксические категории: операторы и выражения:
- Утверждения «делай что-то». Программа представляет собой последовательность операторов. Вот пример оператора, который объявляет (создает) переменную foo:
1
var foo;
- Выражения производят значения. Это аргументы функции, правая часть присваивания и т. д. Вот пример выражения:
1
3 * 7
Различие между операторами и выражениями лучше всего иллюстрируется тем фактом, что в JavaScript есть два разных способа выполнения if-then-else — либо в виде оператора:
1
2
3
4
5
6
var x;
if (y >= 0) {
x = y;
} else {
x = -y;
}
или как выражение:
1
var x = y >= 0 ? y : -y;
Вы можете использовать последний в качестве аргумента функции (но не первый):
1
myFunction(y >= 0 ? y : -y)
Наконец, везде, где JavaScript ожидает оператора, вы также можете использовать выражение; Например:
1
foo(7, 1);
Вся строка является оператором (так называемый оператор выражения), но вызов функции foo(7, 1) является выражением.
Точки с запятой
В JavaScript точки с запятой необязательны. Тем не менее, я рекомендую всегда включать их, потому что в противном случае JavaScript может неправильно угадать конец оператора. Подробности объясняются в разделе Автоматическая вставка точки с запятой.
Точки с запятой завершают операторы, но не блоки. Есть один случай, когда вы увидите точку с запятой после блока: функциональное выражение — это выражение, оканчивающееся блоком. Если такое выражение стоит последним в операторе, за ним следует точка с запятой:
1
2
3
// Pattern: var _ = ___;
var x = 3 * 7;
var f = function () { }; // function expr. inside var decl.
Комментарии
В JavaScript есть два вида комментариев: однострочные и многострочные. Однострочные комментарии начинаются с // и заканчиваются концом строки:
1
x++; // single-line comment
Многострочные комментарии разделяются символами /* и */:
1
2
3
4
/* This is
a multiline
comment.
*/
Переменные и присвоение
Переменные в JavaScript объявляются перед использованием:
1
var foo; // declare variable `foo`
Назначение
Вы можете объявить переменную и одновременно присвоить ей значение:
1
var foo = 6;
Вы также можете присвоить значение существующей переменной:
1
foo = 4; // change variable `foo`
Составные операторы присваивания
Существуют составные операторы присваивания, такие как +=. Следующие два присваивания эквивалентны:
1
2
x += 1;
x = x + 1;
Идентификаторы и имена переменных
Идентификаторы — это имена, которые играют различные синтаксические роли в JavaScript. Например, имя переменной является идентификатором. Идентификаторы чувствительны к регистру.
Грубо говоря, первым символом идентификатора может быть любая буква Юникода, знак доллара ($) или символ подчеркивания (_). Последующие символы могут быть дополнительно любой цифрой Unicode. Таким образом, ниже перечислены все допустимые идентификаторы:
1
2
3
4
arg0
_tmp
$elem
π
Следующие идентификаторы являются зарезервированными словами — они являются частью синтаксиса и не могут использоваться в качестве имен переменных (включая имена функций и имена параметров):
Следующие три идентификатора не являются зарезервированными словами, но вы должны обращаться с ними так, как если бы они были:
Наконец, вы также должны держаться подальше от имен стандартных глобальных переменных. Вы можете использовать их для локальных переменных, ничего не нарушая, но ваш код все равно будет запутанным.
Ценности
JavaScript имеет много значений, которые мы привыкли ожидать от языков программирования: логические значения, числа, строки, массивы и так далее. Все значения в JavaScript имеют свойства. Каждое свойство имеет ключ (или имя) и значение. Вы можете думать о свойствах как о полях записи. Вы используете оператор точки (.) для чтения свойства:
1
value.propKey
Например, строка 'abc' имеет свойство length:
1
2
3
> var str = 'abc';
> str.length
3
Предыдущее можно также записать как:
1
2
3
4
5
6
7
8
9
> 'abc'.length
3
The dot operator is also used to assign a value to a property:
> var obj = {}; // empty object
> obj.foo = 123; // create property `foo`, set it to 123
123
> obj.foo
123
И вы можете использовать его для вызова методов:
1
2
> 'hello'.toUpperCase()
'HELLO'
В предыдущем примере мы вызвали метод toUpperCase() для значения «hello».
Примитивные значения против объектов
JavaScript делает несколько произвольных различий между значениями:
- Примитивными значениями являются логические значения, числа, строки, null и undefined.
- Все остальные значения являются объектами.
Основное различие между ними заключается в том, как они сравниваются; каждый объект имеет уникальную идентичность и только (строго) равен самому себе:
1
2
3
4
5
6
> var obj1 = {}; // an empty object
> var obj2 = {}; // another empty object
> obj1 === obj2
false
> obj1 === obj1
true
Напротив, все примитивные значения, кодирующие одно и то же значение, считаются одинаковыми:
1
2
3
4
> var prim1 = 123;
> var prim2 = 123;
> prim1 === prim2
true
Следующие два раздела объясняют примитивные значения и объекты более подробно.
Примитивные значения
Ниже приведены все примитивные значения (или примитивы для краткости):
- Булевы значения: true, false (см. Логические значения)
- Номера: 1736, 1.351 (см. Номера)
- Строки: 'abc', abc (см. Строки)
- Два «незначения»: undefined, null (см. undefined и null)
Примитивы обладают следующими характеристиками:
По сравнению со значением
«Содержание» сравнивается:
1
2
3
4
> 3 === 3
true
> 'abc' === 'abc'
true
###Всегда неизменяемые
Свойства нельзя изменить, добавить или удалить:
1
2
3
4
5
6
7
8
9
> var str = 'abc';
> str.length = 1; // try to change property `length`
> str.length // ⇒ no effect
3
> str.foo = 3; // try to create property `foo`
> str.foo // ⇒ no effect, unknown property
undefined
(Чтение неизвестного свойства всегда возвращает значение undefined.)
Объекты
Все непримитивные значения являются объектами. Наиболее распространенные виды объектов:
- Простые объекты, которые могут быть созданы литералами объектов (см. Отдельные объекты):
1
2
3
4
{
firstName: 'Jane',
lastName: 'Doe'
}
Предыдущий объект имеет два свойства: значением свойства firstName является «Jane», а значением свойства lastName является «Doe».
- Массивы, которые могут быть созданы литералами массивов (см. Массивы):
1
[ 'apple', 'banana', 'cherry' ]
Предыдущий массив имеет три элемента, к которым можно получить доступ через числовые индексы. Например, индекс «яблока» равен 0.
- Регулярные выражения, которые могут быть созданы литералами регулярных выражений (см. Регулярные выражения):
1
/^a+b+$/
Объекты имеют следующие характеристики:
По сравнению со ссылкой
Тождества сравниваются; каждое значение имеет свою собственную идентичность:
1
2
3
4
5
6
7
> ({} === {}) // two different empty objects
false
> var obj1 = {};
> var obj2 = obj1;
> obj1 === obj2
true
Изменяемый по умолчанию
Обычно вы можете свободно изменять, добавлять и удалять свойства (см. Отдельные объекты):
1
2
3
4
> var obj = {};
> obj.foo = 123; // add property `foo`
> obj.foo
123
неопределенный и нулевой
Большинство языков программирования имеют значения, обозначающие отсутствующую информацию. В JavaScript есть два таких «незначения»: undefined и null:
- undefined означает «нет значения». Неинициализированные переменные не определены:
1
2
3
> var foo;
> foo
undefined
Отсутствующие параметры не определены:
1
2
3
> function f(x) { return x }
> f()
undefined
Если вы читаете несуществующее свойство, вы получаете undefined:
1
2
3
> var obj = {}; // empty object
> obj.foo
undefined
- null означает «нет объекта». Он используется как незначение всякий раз, когда ожидается объект (параметры, последний в цепочке объектов и т. д.).
ПРЕДУПРЕЖДЕНИЕ
undefined и null не имеют свойств, даже стандартных методов, таких как toString().
Проверка на undefined или null
Функции обычно позволяют указать отсутствующее значение либо через undefined, либо через null. Вы можете сделать то же самое с помощью явной проверки:
1
2
3
if (x === undefined || x === null) {
...
}
Вы также можете использовать тот факт, что и undefined, и null считаются ложными:
1
2
3
if (!x) {
...
}
ПРЕДУПРЕЖДЕНИЕ
false, 0, NaN и '' также считаются ложными (см. Правда и Ложь).
Категоризация значений с использованием typeof и instanceof
Есть два оператора для категоризации значений: typeof в основном используется для примитивных значений, а instanceof используется для объектов.
typeof выглядит следующим образом:
1
typeof value
Он возвращает строку, описывающую «тип» значения. Вот некоторые примеры:
1
2
3
4
5
6
7
8
> typeof true
'boolean'
> typeof 'abc'
'string'
> typeof {} // empty object literal
'object'
> typeof [] // empty array literal
'object'
В следующей таблице перечислены все результаты typeof:
typeof null, возвращающий 'object', является ошибкой, которую нельзя исправить, потому что это нарушит существующий код. Это не означает, что null является объектом.
instanceof выглядит так:
1
value instanceof Constr
Он возвращает true, если value является объектом, созданным конструктором Constr (см. Конструкторы: фабрики для объектов). Вот некоторые примеры:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> var b = new Bar(); // object created by constructor Bar
> b instanceof Bar
true
> {} instanceof Object
true
> [] instanceof Array
true
> [] instanceof Object // Array is a subconstructor of Object
true
> undefined instanceof Object
false
> null instanceof Object
false
Булевы значения
Примитивный логический тип содержит значения true и false. Следующие операторы производят логические значения:
- Бинарные логические операторы: && (И), || (Или)
- Префиксный логический оператор: ! (Нет)
- Операторы сравнения: Операторы равенства: ===, !==, ==, !=
- Операторы упорядочивания (для строк и чисел): ›, ›=, ‹, ‹=
Правда и ложь
Всякий раз, когда JavaScript ожидает логическое значение (например, для условия оператора if), можно использовать любое значение. Оно будет интерпретировано как истинное или ложное. Следующие значения интерпретируются как ложные:
- неопределенный, ноль
www.fmz.com
