Чтение этой статьи требует опыта программирования на других языках.
Простые типы в JavaScript включают:
1. Числа
2. Строка
3. Boolean (True и Fall)
4.null
5.
Другие типы - это объекты (например, мы не должны путать возвращаемое значение оператора типа), например:
1. Функция
2. Орей
3. Регулярные выражения
4. Объект (объекты естественным образом объекты)
Объектная основа
В JavaScript объекты являются коллекциями свойств (объекты являются ассоциативными массивами), каждое свойство включает в себя:
1. Имя атрибута должно быть строкой
2. Значение атрибута может быть любым значением, отличным от неопределенного
Создать объект через буквальный объект:
Кода -копия выглядит следующим образом:
// Создать пустой объект через Literal {}
var empty_object = {};
Имя атрибута и значение атрибута объекта:
Кода -копия выглядит следующим образом:
var stande = {
// "Первое имя"-это имя атрибута, а "Джером"-это значение атрибута
«Первое имя»: «Джером»,
// «Последнее имя»-это имя атрибута, а «Говард»-это значение атрибута
«Последнее имя»: «Говард»
};
Если имя атрибута является законным идентификатором, кавычки могут быть опущены:
Кода -копия выглядит следующим образом:
var flight = {
авиакомпания: "Oceanic",
номер: 815,
отделение: {
IATA: "syd",
Время: "2004-09-22 14:55",
Город: "Сидней"
},
прибытие: {
IATA: "LAX",
Время: "2004-09-23 10:42",
Город: "Лос -Анджелес"
}
};
Давайте посмотрим на пример доступа к собственности:
Кода -копия выглядит следующим образом:
var anker = {name: "name5566"};
владелец. name; // "name5566"
Владелец ["Имя"]; // "name5566"
Владелец.job; // неопределенный
владелец.job = "кодер"; // или владелец ["job"] = "кодер";
Если имя атрибута не является юридическим идентификатором, его необходимо обернуть в кавычки. Значение имущества, которого не существует, не определена. Объекты передаются ссылкой, а не по значению:
Кода -копия выглядит следующим образом:
var x = {};
var владелец = x;
владелец.name = "name5566";
x.name; // x.name === "name5566"
Здесь X и владелец относятся к тому же объекту.
Атрибуты объекта могут быть удалены с помощью оператора удаления:
Кода -копия выглядит следующим образом:
Удалить obj.x; // Удалить x атрибут объекта obj
Прототип объекта
Каждый объект связан с объектом прототипа, и объект может наследовать атрибуты от объекта прототипа. Мы создаем объект через буквальный объект, объект прототипа которого является объектом. Когда мы создаем объект, мы можем установить объект прототипа объекта (а затем обсудить конкретный метод настройки). При попытке получить (не изменять) атрибут объекта, если объект не существует, JavaScript пытается получить атрибут из объекта прототипа этого объекта, если нет такого атрибута в объекте прототипа, затем посмотрите на объект прототипа этого объекта прототипа и так далее до объекта. По сравнению с получением атрибутов, когда мы изменяем атрибут объекта, он не повлияет на объект прототипа.
Функциональные основы
Функции также являются объектами в JavaScript, которые связаны с объектом прототипа прототипа прототипа (функция. Функция имеет свойство с именем прототипа, а его значение является объектом. Этот объект имеет конструктор свойств, и значение конструктора - эта функция:
Кода -копия выглядит следующим образом:
var f = function () {}
TypeOf F.Protototype; // 'объект'
typeof f.prototype.constructor; // 'функция'
f === F.Prototype.constructor; // истинный
Функции - это объекты, вы можете использовать такие функции, как использование объектов, то есть функции могут быть сохранены в переменных и массивах и могут передаваться в качестве параметров для функций, и функции могут быть определены в функциях. В качестве примечания, функция имеет два скрытых свойства:
1. Контекст функции
2. Функциональный код
Функция создается следующим образом:
Кода -копия выглядит следующим образом:
var f = функция добавить (a, b) {
вернуть A + B;
}
console.log (f); // Выход [Функция: добавить]
Имя функции после функции ключевого слова необязательно. Мы сформулируем имя функции в основном для нескольких целей:
1. Для рекурсивного вызова
2. отладчики, инструменты разработки и т. Д. Используются для определения функций
Много раз нам не нужны имена функций, а функции без имен функций называются анонимными функциями. Список параметров обернут в скобки. JavaScript не требует сопоставления реальных параметров и формальных параметров, например:
Кода -копия выглядит следующим образом:
var add = function (a, b) {
вернуть A + B;
}
добавить (1, 2, 3); // фактический параметр и формальный параметр не совпадают
Если существует слишком много реальных параметров, то избыточные реальные параметры будут игнорироваться. Если существует слишком мало реальных параметров, то значение неопределенных формальных параметров не определено. Функция должна иметь возвратное значение. Если возвращаемое значение не указано через оператор возврата, возвращаемое значение функции не определено.
Функция и внешние переменные, которые она доступна, образуют закрытие. Это ключевое очарование JavaScript.
Функциональные вызовы
Когда каждая функция вызвана, получены два дополнительных параметра:
1. Это
2. Аргументы
Значение этого связано с конкретной шаблоном вызова. В JavaScript есть четыре шаблона вызова:
1. Метод вызова режима. Если свойство объекта является функцией, оно называется методом. Если метод вызывается через OM (ARGS), это объект O (который можно увидеть, что это и O связаны только при вызове), например:
Кода -копия выглядит следующим образом:
var obj = {
значение: 0,
Приращение: функция (v) {
это.
}
};
obj.increment (); // это === obj
2. Режим вызова функции. Если функция не является свойством объекта, она будет вызвана как функция, и это связано с глобальным объектом, например:
Кода -копия выглядит следующим образом:
Сообщение = 'Hello World';
var p = function () {
console.log (this.message);
}
p (); // вывод 'Hello World'
Такое поведение иногда сбивает с толку, см. Пример:
Кода -копия выглядит следующим образом:
obj = {
значение: 0,
Приращение: function () {
var helper = function () {
// добавить 1 к значению в глобальном объекте
это. Value += 1;
}
// помощник называется как функция
// Поэтому это глобальный объект
Helper ();
}
};
obj.increment (); // obj.value === 0
Результаты, которые мы ожидаем, должны быть:
Кода -копия выглядит следующим образом:
obj = {
значение: 0,
Приращение: function () {
var that = это;
var helper = function () {
что. Value += 1;
}
Helper ();
}
};
obj.increment (); // obj.value === 1
3. Режим вызова конструктора. Функции, которые намерены использовать новый префикс, называются конструкторами, например:
Кода -копия выглядит следующим образом:
// тест называется конструктором
var test = function (string) {
this.message = string;
}
var mytest = new Test ("Hello World");
Функция может быть вызвана с новой (такие функции обычно начинаются с заглавного средства). После добавления нового объекта, связанного со свойством прототипа этой функции, будет создан, и этот объект в конструкторе является этим объектом.
4. Применить режим вызова. Применение метода функции используется для вызова функции, которая имеет два параметра, первым является это, а второе - массив параметров, например:
Кода -копия выглядит следующим образом:
var add = function (a, b) {
вернуть A + B;
}
var ret = add.Apply (null, [3, 4]); // ret === 7
При вызове функции мы можем получить доступ к множеству классов, называемых аргументами (нереальный массив JavaScript), которые содержит все аргументы, поэтому мы можем реализовать параметры длиной длины:
Кода -копия выглядит следующим образом:
var add = function () {
var sum = 0;
for (var i = 0; i <arguments.length; ++ i) {
sum += аргументы [i];
}
вернуть сумму;
}
добавить (1, 2, 3, 4);
аномальный
Теперь давайте поговорим о механизме обработки исключений JavaScript. Мы используем оператор Thress, чтобы бросить исключения, и заявление Try-Cache, чтобы поймать и обрабатывать исключения:
Кода -копия выглядит следующим образом:
var add = function (a, b) {
if (typeof a! == 'Number' || typeof b! == 'number') {
// бросить исключение
бросать {
Имя: 'typeError',
Сообщение: «Добавить необходимых номеров»
};
}
вернуть A + B;
}
// Поймайте и обрабатывают исключения
пытаться {
добавить ("семь");
// e - объект исключения, брошенный
} catch (e) {
console.log (e.name + ':' + e.message);
}
Добавить свойства к типам JavaScript
Конструкторы существуют в большинстве типов в JavaScript:
1. Конструктором объекта является объект
2. Конструктором массива является массивом
3. Конструктором функции является функция
4. Конструктором строки является строкой
5. Конструктор номера - число
6. Конструктор логического
7. Конструктором регулярного выражения является regexp
Мы можем добавить свойства (часто добавлять методы) к прототипу конструктора, чтобы это свойство было доступно для связанных переменных:
Кода -копия выглядит следующим образом:
Number.prototype.integer = function () {
вернуть математику [это <0? 'ceil': 'floor'] (это);
}
(1.1) .integer (); // 1
Объем
JavaScript должен создавать области с помощью функций:
Кода -копия выглядит следующим образом:
function () {
// ...
} ();
Анонимная функция создается и выполняется здесь. Область, чтобы скрыть переменные, которые вы не хотите подвергнуть воздействию:
Кода -копия выглядит следующим образом:
var obj = function () {
// скрыть значение, не может быть доступно извне
var value = 0;
возвращаться {
// Только этот метод может изменить значение
Приращение: function () {
значение += 1;
},
// Только этот метод может прочитать значение
getValue: function () {
возвращаемое значение;
}
};
} ();
obj.increment ();
obj.getValue () === 1;
наследовать
Есть много способов реализовать наследование в JavaScript.
При создании объекта мы можем настроить объект прототипа, связанный с объектом, и мы делаем:
Кода -копия выглядит следующим образом:
// Создать объект o с его объектом прототипа {x: 1, y: 2}
var o = object.create ({x: 1, y: 2});
Метод object.create определен в Ecmascript 5. Если вы используете Ecmascript 3, вы можете реализовать метод создания самостоятельно:
Кода -копия выглядит следующим образом:
// Если метод object.create не определен
if (typeof object.create! == 'function') {
// Создать метод object.create
Object.create = function (o) {
var f = function () {};
F.Prototype = O;
// Создать новый объект, объект прототипа этого объекта o
вернуть новый f ();
};
}
Через метод Object.create мы выполняем наследование на основе прототипа: новый объект непосредственно наследует свойства старого объекта (относительно наследования на основе классов, существует здесь нет необходимости в существовании класса, и объект непосредственно наследует объект). пример:
Кода -копия выглядит следующим образом:
var mymammal = {
Имя: «трава млекопитающего»,
get_name: function () {
вернуть это. name;
},
говорит: function () {
вернуть это '';
}
};
// наследуют Mymammal
var mycat = object.create (mymammal);
mycat.name = 'henrietta';
mycat.saying = 'meow';
mycat.purr = function (n) {
var i, s = '';
for (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
возврат S;
};
mycat.get_name = function () {
вернуть this.says () + '' + this.name + '' + this.says ();
};
Приведенный выше код прост, но он не может защитить частных членов. Мы можем использовать режим модуля. В режиме модуля определенный тип объекта генерируется функцией и использует область функции для защиты частных элементов от внешнего доступа:
Кода -копия выглядит следующим образом:
// функция млекопитающих, используемая для построения объектов млекопитающих
var mammal = function (spec) {
// это построенный объект
var, что = {};
// Публичный метод get_name можно получить извне
that.get_name = function () {
// spec.name нельзя получить непосредственно снаружи
вернуть Spec.name;
};
// публичный метод говорит, что можно получить доступ снаружи
что.says = function () {
// spec.say не прямой доступ к внешнему
Возврат Spec.say || '';
};
вернуть это;
};
// Создать объект млекопитающего
var mymammal = mammal ({name: 'herb'});
// Функция CAT, используемая для построения объекта CAT
var cat = function (spec) {
Spec.saying = spec.say || 'мяу';
// Кошка наследует от млекопитающего, так что сначала постройте объект млекопитающего
var that = mammal (spec);
// Добавить публичный метод Purr
что. purr = function (n) {
var i, s = '';
for (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
возврат S;
};
// Измените публичный метод get_name
that.get_name = function () {
вернуть это.says () + '' + spec.name +
' + that.says ();
вернуть это;
};
};
// Создать объект CAT
var mycat = cat ({name: 'henrietta'});
В режиме модуля наследование достигается путем вызова конструктора. Кроме того, мы также можем получить доступ к методам родительского класса в подклассе:
Кода -копия выглядит следующим образом:
Object.prototype.superior = function (name) {
var that = this, method = that [name];
return function () {
return Method.apply (это, аргументы);
};
};
var coolcat = function (spec) {
// Получить метод get_name подкласса
var that = cat (spec), super_get_name = this.superior ('get_name');
это.get_name = function (n) {
вернуть 'like' + super_get_name () + 'baby';
};
вернуть это;
};