Описание режима прототипа
Примечание. Используйте экземпляры прототипа для копирования и создания новых настраиваемых объектов; Для недавно созданных объектов вам не нужно знать конкретный процесс создания исходного объекта;
Процедура: Prototype => New Protoexam => клон для нового объекта;
Используйте соответствующий код:
Кода -копия выглядит следующим образом:
Функция прототипа () {
this.name = '';
this.age = '';
this.sex = '';
}
Prototype.prototype.userinfo = function () {
вернуть 'личную информацию, имя:'+this.name+', возраст:'+this.age+', пол:'+this.sex+'<br />';
}
Теперь требуется два или более личной информации: требуется:
Кода -копия выглядит следующим образом:
var proto = новый прототип ();
var person1 = object.create (proto);
Person1.name = 'xiao ming';
Person1.sex = 'мужчина';
Person1.age = 35;
Person1.userinfo ();
//
var person2 = object.create (proto);
person2.name = 'xiaohua';
Person2.sex = 'Женщина';
человек2.age = 33;
Person2.userinfo ();
Выходные возвраты:
Кода -копия выглядит следующим образом:
Личная информация, имя: Сяо Мин, возраст: 35 лет, пол: мужчина
Личная информация, имя: xiaohua, возраст: 33, пол: женщина
Режим прототипа обычно используется для сложных абстрактных структур, но состав содержимого аналогичен, можно настроить абстрактный контент, а новое создание требует лишь слегка измененного на исходном объекте создания для удовлетворения требований;
Object.create Инструкции
1>. Определение: создать объект, который определяет объект прототипа и может содержать дополнительные пользовательские свойства;
2> object.create (proto [, свойства]); Необязательно, используется для настройки свойств новых объектов;
Кода -копия выглядит следующим образом:
1. Прото: Чтобы создать прототип нового объекта, он должен быть нулевым; Это прото является ценным только в том случае, если оно было создано [новое] или объект. Прототип;
2. Свойства: необязательно, структура:
{
Propield: {
значение: 'val' | {} | function () {},
Записывается: истинно | Неверно,
перечисляется: true | false,
настраивается: true | false,
get: function () {return 10},
SET: function (value) {}
}
}
Пользовательские атрибуты имеют следующие четыре атрибута:
Значение: пользовательское значение атрибута;
Записывается: является ли значение этого элемента редактируемым, по умолчанию неверно, и когда верно, OBJ.Prodfield может быть назначено; в противном случае только чтение;
перечисляется: перечисляется;
настраивается: настраивается;
Он также может включать в себя установку, получить методы доступа;
Среди них [Set, Get] не может появиться в то же время, что и стоимость и записи;
1. Создайте прототип объекта класса:
Кода -копия выглядит следующим образом:
function protoclass () {
this.a = 'protoclass';
this.c = {};
this.b = function () {
}
}
Создание прототипа метода:
Кода -копия выглядит следующим образом:
Protoclass.prototype.amethod = function () {
//this.a;
//this.b ();
вернуть это.
}
Как использовать
1. Создать объект с помощью протокласс.
Кода -копия выглядит следующим образом:
var obj1 = object.create (protoclass.prototype, {
foo: {value: 'obj1', writeble: true}
})
obj1 имеет метод прототипа протоклассного прототипа аметода;
Кода -копия выглядит следующим образом:
obj1.amethod ();
// Неопределенный метод будет выводиться для доступного, а элемент протоклана не может быть доступен
Однако этот метод не может выполнить свойства члена A, B, C в Protoclass:
2. Используйте созданное протокласт в качестве прототипа:
Кода -копия выглядит следующим образом:
var proto = new Protoclass ();
var obj2 = object.create (proto, {
foo: {value: 'obj2'}
});
OBJ2, созданный таким образом, имеет все атрибуты члена A, B, C и Amethod Prototype Prototype Protoclass; и добавляет атрибут данных только для чтения;
Кода -копия выглядит следующим образом:
obj2.a; // протокласс
obj2.c: // [объект]
obj2.b (); //
obj2.amethod (); // протокласс
obj2.foo; // obj2
3. Наследство подкласса:
Кода -копия выглядит следующим образом:
функция subclass () {
}
Subclass.prototype = object.create (protoclass.prototype, {
foo: {value: 'subclass'}
});
Subclass.prototype.submethod = function () {
вернуть это.a || this.foo;
}
Этот метод может быть унаследован от метода аметода Protoclass и выполнена;
Кода -копия выглядит следующим образом:
var func = new subclass ();
func.amethod (); // не определено, свойства члена протоклаша не могут быть прочитаны, A, B, C
func.submethod (); // Подкласс
Чтобы позволить подклассу прочитать свойства члена протоклассника, необходимо изменить подкласс:
Кода -копия выглядит следующим образом:
Функция subclass ()
{
Protoclass.call (это);
}
// другой код;
Этот метод может получить свойства члена и прототипные методы протоклаша;:
Кода -копия выглядит следующим образом:
var func = new subclass ();
func.amethod (); // protoclass
func.submethod (); // protoclass
Другой метод состоит в том, чтобы использовать созданный объект Protoclass в качестве прототипа подкласса;
Кода -копия выглядит следующим образом:
var proto = new Protoclass ();
функция subclass () {
}
Subclass.prototype = object.create (proto, {
foo: {value: 'subclass'}
});
Таким образом, после создания подкласса вы можете получить все свойства протоклаша и методы прототипа и создать атрибут данных только для чтения Foo;
Кода -копия выглядит следующим образом:
var func = new subclass ();
func.foo; // подкласс
func.a; // протокласс
func.b (); //
func.c; //[Объект]
func.amethod (); // протокласс
4. Другой метод создания наследования совпадает с объектом. Компания Create's Commandited Protoclass для прототипов:
Кода -копия выглядит следующим образом:
функция subclass () {
this.foo = 'subclass'; // но это можно прочитать и написано здесь
}
Subclass.prototype = new Protoclass ();
Object.create связанные с инструкциями
Object.Create используется для создания нового объекта. Когда это объект, прототип является нулевым, и его эффект согласуется с новым объектом (); или {};
Когда функция функция такая же, как и New FunctionName;
Кода -копия выглядит следующим образом:
// 1 объект
var O = {}
// эквивалентно
var o2 = object.create ({});
// конструкторы одинаковы;
// -----------------------------------------
функция func () {
this.a = 'func';
}
func.prototype.method = function () {
вернуть это.
}
var newfunc = new func ();
// эквивалентно [эффект такой же]
var newfunc2 = object.create (object.prototype/*function.prototype || function () {}*/, {
A: {value: 'func', riseable: true},
Метод: {value: function () {return this.a;}}
});
Но Newfunc и Newfunc2 различаются в ссылках на функцию для создания своих объектов.
newfunc is function func () {...}, newfunc2 - функция функции {Native}
Кода -копия выглядит следующим образом:
Object.Create (Proto [, Propertiesfield]):
Прото указывает, что значение требуется и может быть нулевым. Если это не установлено, будет брошено исключение;
Прото не ноль, то есть созданное значение, то есть значение, которое было новым; Большинство объектов в JavaScript имеют атрибуты конструктора, которые атрибуты указывают, какую функцию создается через объект;
Propertiesfield является необязательным, устанавливая свойства или методы члена, которые могут потребоваться для вновь созданных объектов;