面向对象编程之ECMAScript已毕,深切通晓

深入明白Javascript面向对象编程

2015/12/23 · JavaScript
· 1 评论 ·
面向对象

原稿出处:
涂根华   

一:驾驭构造函数原型(prototype)机制

prototype是javascript达成与治本持续的一种体制,也是面向对象的安排思想.构造函数的原型存储着引用对象的一个指南针,该指针指向与一个原型对象,对象内部存储着函数的原始属性和措施;大家得以凭借prototype属性,可以访问原型内部的习性和艺术。

当构造函数被实列化后,所有的实例对象都可以访问构造函数的原型成员,假如在原型中宣示一个成员,所有的实列方法都足以共享它,比如如下代码:

JavaScript

// 构造函数A 它的原型有一个getName方法 function A(name){ this.name =
name; } A.prototype.getName = function(){ return this.name; } //
实列化2次后 该2个实列都有原型getName方法;如下代码 var instance1 = new
A(“longen1”); var instance2 = new A(“longen2”);
console.log(instance1.getName()); //longen1
console.log(instance2.getName()); // longen2

1
2
3
4
5
6
7
8
9
10
11
12
// 构造函数A 它的原型有一个getName方法
function A(name){
    this.name = name;
}
A.prototype.getName = function(){
    return this.name;
}
// 实列化2次后 该2个实列都有原型getName方法;如下代码
var instance1 = new A("longen1");
var instance2 = new A("longen2");
console.log(instance1.getName()); //longen1
console.log(instance2.getName()); // longen2

原型具有普通对象社团,可以将其他一般对象设置为原型对象; 一般景观下,对象都一连与Object,也可以知道Object是兼备目的的超类,Object是从未原型的,而构造函数拥有原型,由此实列化的靶子也是Object的实列,如下代码:

JavaScript

// 实列化对象是构造函数的实列 console.log(instance1 instanceof A);
//true console.log(instance2 instanceof A); // true //
实列化对象也是Object的实列 console.log(instance1 instanceof Object);
//true console.log(instance2 instanceof Object); //true //Object
对象是持有目的的超类,由此构造函数也是Object的实列 console.log(A
instanceof Object); // true // 可是实列化对象 不是Function对象的实列
如下代码 console.log(instance1 instanceof Function); // false
console.log(instance2 instanceof Function); // false //
但是Object与Function有涉嫌 如下代码表达 console.log(Function instanceof
Object); // true console.log(Object instanceof Function); // true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 实列化对象是构造函数的实列
console.log(instance1 instanceof A); //true
console.log(instance2 instanceof A); // true
 
// 实列化对象也是Object的实列
console.log(instance1 instanceof Object); //true
console.log(instance2 instanceof Object); //true
 
//Object 对象是所有对象的超类,因此构造函数也是Object的实列
console.log(A instanceof Object); // true
 
// 但是实列化对象 不是Function对象的实列 如下代码
console.log(instance1 instanceof Function); // false
console.log(instance2 instanceof Function); // false
 
// 但是Object与Function有关系 如下代码说明
console.log(Function instanceof Object);  // true
console.log(Object instanceof Function);  // true

如上代码,Function是Object的实列,也足以是Object也是Function的实列;他们是2个分歧的构造器,大家继承看如下代码:

JavaScript

var f = new Function(); var o = new Object();
console.log(“————“); console.log(f instanceof Function); //true
console.log(o instanceof Function); // false console.log(f instanceof
Object); // true console.log(o instanceof Object); // true

1
2
3
4
5
6
7
var f = new Function();
var o = new Object();
console.log("————");
console.log(f instanceof Function);  //true
console.log(o instanceof Function);  // false
console.log(f instanceof Object);    // true
console.log(o instanceof Object);   // true

咱俩精晓,在原型上伸张成员属性或者措施的话,它被有着的实列化对象所共享属性和章程,不过只要实列化对象有和原型相同的成员成员名字的话,那么它取到的分子是本实列化对象,假设本实列对象中从未的话,那么它会到原型中去摸索该成员,倘若原型找到就回到,否则的会再次回到undefined,如下代码测试

JavaScript

function B(){ this.name = “longen2”; } B.prototype.name = “AA”;
B.prototype.getName = function(){ return this.name; }; var b1 = new B();
// 在本实列查找,找到就再次来到,否则到原型查找 console.log(b1.name); //
longen2 // 在本实列没有找到该方法,就到原型去摸索
console.log(b1.getName());//longen2 //
假设在本实列没有找到的话,到原型上查找也向来不找到的话,就重临undefined
console.log(b1.a); // undefined //
现在我使用delete运算符删除本地实列属性,那么取到的是就是原型属性了,如下代码:
delete b1.name; console.log(b1.name); // AA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function B(){
    this.name = "longen2";
}
B.prototype.name = "AA";
B.prototype.getName = function(){
    return this.name;
};
 
var b1 = new B();
// 在本实列查找,找到就返回,否则到原型查找
console.log(b1.name); // longen2
 
// 在本实列没有找到该方法,就到原型去查找
console.log(b1.getName());//longen2
 
// 如果在本实列没有找到的话,到原型上查找也没有找到的话,就返回undefined
console.log(b1.a); // undefined
 
// 现在我使用delete运算符删除本地实列属性,那么取到的是就是原型属性了,如下代码:
delete b1.name;
console.log(b1.name); // AA

二:精晓原型域链的概念

原型的助益是力所能及以目标社团为载体,创立大气的实列,这么些实列能共享原型中的成员(属性和格局);同时也足以选取原型完结面向对象中的继承机制~ 如下代码:下边我们来看这一个协会函数AA和布局函数BB,当BB.prototype = new AA(11);执行那几个的时候,那么B就继续与A,B中的原型就有x的属性值为11

JavaScript

function AA(x){ this.x = x; } function BB(x) { this.x = x; }
BB.prototype = new AA(11); console.log(BB.prototype.x); //11 //
大家再来通晓原型继承和原型链的概念,代码如下,都有注释 function A(x) {
this.x = x; } // 在A的原型上定义一个属性x = 0 A.prototype.x = 0;
function B(x) { this.x = x; } B.prototype = new A(1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function AA(x){
    this.x = x;
}
function BB(x) {
    this.x = x;
}
BB.prototype = new AA(11);
console.log(BB.prototype.x); //11
 
// 我们再来理解原型继承和原型链的概念,代码如下,都有注释
function A(x) {
    this.x = x;
}
// 在A的原型上定义一个属性x = 0
A.prototype.x = 0;
function B(x) {
    this.x = x;
}
B.prototype = new A(1);

实列化A new A(1)的时候 在A函数内this.x =1, B.prototype = new A(1);B.prototype 是A的实列 也就是B继承于A, 即B.prototype.x = 1;
 如下代码:

JavaScript

console.log(B.prototype.x); // 1 // 定义C的构造函数 function C(x) {
this.x = x; } C.prototype = new B(2);

1
2
3
4
5
6
console.log(B.prototype.x); // 1
// 定义C的构造函数
function C(x) {
    this.x = x;
}
C.prototype = new B(2);

C.prototype = new B(2); 也就是C.prototype 是B的实列,C继承于B;那么new B(2)的时候 在B的构造函数内 this.x = 2;那么 C的原型上会有一个性质x =2 即C.prototype.x = 2;
如下代码:

JavaScript

console.log(C.prototype.x); // 2

1
console.log(C.prototype.x); // 2

下边是实列化 var d = new C(3); 实列化C的构造函数时候,那么在C的构造函数内this.x = 3; 由此如下打印实列化后的d.x = 3;如下代码:

JavaScript

var d = new C(3); console.log(d.x); // 3

1
2
var d = new C(3);
console.log(d.x); // 3

删去d.x 再拜访d.x的时候 本实列对象被删掉,只好从原型上去寻找;由于C.prototype = new B(2); 也就是C继承于B,由此C的原型也有x = 2;即C.prototype.x = 2;
如下代码:

JavaScript

delete d.x; console.log(d.x); //2

1
2
delete d.x;
console.log(d.x);  //2

去除C.prototype.x后,我们从上边代码知道,C是连续于B的,自身的原型被删掉后,会去追寻父元素的原型链,由此在B的原型上找到x =1;
如下代码:

JavaScript

delete C.prototype.x; console.log(d.x); // 1

1
2
delete C.prototype.x;
console.log(d.x);  // 1

当删除B的原型属性x后,由于B是继承于A的,因而会从父元素的原型链上查找A原型上是或不是有x的特性,即使有的话,就赶回,否则看A是或不是有继承,没有继续的话,继续往Object上去寻找,固然没有找到就重返undefined 由此当删除B的原型x后,delete B.prototype.x; 打印出A上的原型x=0;
如下代码:

JavaScript

delete B.prototype.x; console.log(d.x); // 0 // 继续删除A的原型x后
结果尚未找到,就重返undefined了; delete A.prototype.x; console.log(d.x);
// undefined

1
2
3
4
5
6
delete B.prototype.x;
console.log(d.x);  // 0
 
// 继续删除A的原型x后 结果没有找到,就返回undefined了;
delete A.prototype.x;
console.log(d.x);  // undefined

在javascript中,一切都是对象,Function和Object都是函数的实列;构造函数的父原型指向于Function原型,Function.prototype的父原型指向与Object的原型,Object的父原型也针对与Function原型,Object.prototype是有着原型的顶层;

一般来说代码:

JavaScript

Function.prototype.a = function(){ console.log(“我是父原型Function”); }
Object.prototype.a = function(){ console.log(“我是 父原型Object”); }
function A(){ this.a = “a”; } A.prototype = { B: function(){
console.log(“b”); } } // Function 和 Object都是函数的实列 如下:
console.log(A instanceof Function); // true console.log(A instanceof
Object); // true //
A.prototype是一个目标,它是Object的实列,但不是Function的实列
console.log(A.prototype instanceof Function); // false
console.log(A.prototype instanceof Object); // true //
Function是Object的实列 同是Object也是Function的实列 console.log(Function
instanceof Object); // true console.log(Object instanceof Function); //
true /* * Function.prototype是Object的实列
但是Object.prototype不是Function的实列 *
表达Object.prototype是所有父原型的顶层 */
console.log(Function.prototype instanceof Object); //true
console.log(Object.prototype instanceof Function); // false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Function.prototype.a = function(){
    console.log("我是父原型Function");
}
Object.prototype.a = function(){
    console.log("我是 父原型Object");
}
function A(){
    this.a = "a";
}
A.prototype = {
    B: function(){
        console.log("b");
    }
}
// Function 和 Object都是函数的实列 如下:
console.log(A instanceof Function);  // true
console.log(A instanceof Object); // true
 
// A.prototype是一个对象,它是Object的实列,但不是Function的实列
console.log(A.prototype instanceof Function); // false
console.log(A.prototype instanceof Object); // true
 
// Function是Object的实列 同是Object也是Function的实列
console.log(Function instanceof Object);   // true
console.log(Object instanceof Function); // true
 
/*
* Function.prototype是Object的实列 但是Object.prototype不是Function的实列
* 说明Object.prototype是所有父原型的顶层
*/
console.log(Function.prototype instanceof Object);  //true
console.log(Object.prototype instanceof Function);  // false

三:明白原型继承机制

构造函数都有一个指针指向原型,Object.prototype是持有原型对象的顶层,比如如下代码:

JavaScript

var obj = {}; Object.prototype.name = “tugenhua”; console.log(obj.name);
// tugenhua

1
2
3
var obj = {};
Object.prototype.name = "tugenhua";
console.log(obj.name); // tugenhua

给Object.prototype 定义一个属性,通过字面量构建的对象的话,都会从父类这边获得Object.prototype的性质;

从上面代码我们了然,原型继承的法子是:即使A必要持续于B,那么A.prototype(A的原型) = new B()(作为B的实列) 即可完结A继承于B; 由此大家上边可以开始化一个空的构造函数;然后把目标赋值给构造函数的原型,然后回到该构造函数的实列; 即可达成一连;
如下代码:

JavaScript

if(typeof Object.create !== ‘function’) { Object.create = function(o) {
var F = new Function(); F.prototype = o; return new F(); } } var a = {
name: ‘longen’, getName: function(){ return this.name; } }; var b = {};
b = Object.create(a); console.log(typeof b); //object
console.log(b.name); // longen console.log(b.getName()); // longen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
if(typeof Object.create !== ‘function’) {
    Object.create = function(o) {
        var F = new Function();
        F.prototype = o;
        return new F();
    }
}
var a = {
    name: ‘longen’,
    getName: function(){
        return this.name;
    }
};
var b = {};
b = Object.create(a);
console.log(typeof b); //object
console.log(b.name);   // longen
console.log(b.getName()); // longen

如上代码:大家先检测Object是不是业已有Object.create该措施;如若没有的话就创办一个; 该方法内创立一个空的构造器,把参数对象传递给构造函数的原型,最终回来该构造函数的实列,就落实了继承格局;如上测试代码:先定义一个a对象,有成员属性name=’longen’,还有一个getName()方法;最终回到该name属性; 然后定义一个b空对象,使用Object.create(a);把a对象继承给b对象,因而b对象也有性能name和成员方法getName();

 精通原型查找原理:对象查找先在该构造函数内寻找对应的性质,如若该对象没有该属性的话,

那么javascript会试着从该原型上去寻找,假如原型对象中也从没该属性的话,那么它们会从原型中的原型去找寻,直到查找的Object.prototype也远非该属性的话,那么就会重返undefined;由此大家想要仅在该目的内寻找的话,为了增强性能,咱们可以运用hasOwnProperty()来判定该目的内有没有该属性,假设有的话,就执行代码(使用for-in循环查找):如下:

JavaScript

var obj = { “name”:’tugenhua’, “age”:’28’ }; // 使用for-in循环 for(var i
in obj) { if(obj.hasOwnProperty(i)) { console.log(obj[i]); //tugenhua
28 } }

1
2
3
4
5
6
7
8
9
10
var obj = {
    "name":’tugenhua’,
    "age":’28’
};
// 使用for-in循环
for(var i in obj) {
    if(obj.hasOwnProperty(i)) {
        console.log(obj[i]); //tugenhua 28
    }
}

如上拔取for-in循环查找对象里面的属性,可是我们必要知道的是:for-in循环查找对象的性能,它是不保证顺序的,for-in循环和for循环;最本色的分歧是:for循环是有各样的,for-in循环遍历对象是无序的,因而我们只要急需对象有限支撑顺序的话,可以把对象转换为数组来,然后再采用for循环遍历即可;

上面大家来研究原型继承的亮点和缺点

JavaScript

// 先看上边的代码: // 定义构造函数A,定义特权属性和特权方法 function
A(x) { this.x1 = x; this.getX1 = function(){ return this.x1; } } //
定义构造函数B,定义特权属性和特权方法 function B(x) { this.x2 = x;
this.getX2 = function(){ return this.x1 + this.x2; } } B.prototype = new
A(1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 先看下面的代码:
// 定义构造函数A,定义特权属性和特权方法
function A(x) {
    this.x1 = x;
    this.getX1 = function(){
        return this.x1;
    }
}
// 定义构造函数B,定义特权属性和特权方法
function B(x) {
    this.x2 = x;
    this.getX2 = function(){
        return this.x1 + this.x2;
    }
}
B.prototype = new A(1);

B.prototype = new A(1);那句代码执行的时候,B的原型继承于A,由此B.prototype也有A的习性和方法,即:B.prototype.x1 = 1; B.prototype.getX1 方法;可是B也有投机的特权属性x2和特权方法getX2;
如下代码:

JavaScript

function C(x) { this.x3 = x; this.getX3 = function(){ return this.x3 +
this.x2; } } C.prototype = new B(2); C.prototype = new
B(2);那句代码执行的时候,C的原型继承于B,因此C.prototype.x2 = 2;
C.prototype.getX2方法且C也有协调的特权属性x3和特权方法getX3, var b = new
B(2); var c = new C(3); console.log(b.x1); // 1 console.log(c.x1); // 1
console.log(c.getX3()); // 5 console.log(c.getX2()); // 3 var b = new
B(2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function C(x) {
    this.x3 = x;
    this.getX3 = function(){
        return this.x3 + this.x2;
    }
}
C.prototype = new B(2);
C.prototype = new B(2);这句代码执行的时候,C的原型继承于B,因此C.prototype.x2 = 2; C.prototype.getX2方法且C也有自己的特权属性x3和特权方法getX3,
var b = new B(2);
var c = new C(3);
console.log(b.x1);  // 1
console.log(c.x1);  // 1
console.log(c.getX3()); // 5
console.log(c.getX2()); // 3
var b = new B(2);

实列化B的时候 b.x1 首先会在构造函数内查找x1属性,没有找到,由于B的原型继承于A,由此A有x1属性,由此B.prototype.x1 = 1找到了;var c = new C(3); 实列化C的时候,从上边的代码可以看出C继承于B,B继承于A,因而在C函数中并未找到x1属性,会往原型继续查找,直到找到父元素A有x1属性,由此c.x1 = 1;c.getX3()方法; 重回this.x3+this.x2 this.x3 = 3;this.x2 是B的性质,因而this.x2 = 2;c.getX2(); 查找的措施也一样,不再解释

prototype的缺点与亮点如下:

优点是:可以允许三个对象实列共享原型对象的分子及格局,

缺点是:1. 各类构造函数唯有一个原型,因而不直接帮忙多重继承;

2. 不可能很好地援助多参数或动态参数的父类。在原型继承阶段,用户还不可以操纵以

怎么样参数来实列化构造函数。

四:了解使用类继承(继承的更好的方案)

类继承也叫做构造函数继承,在子类中实践父类的构造函数;完结原理是:可以将一个构造函数A的点子赋值给另一个构造函数B,然后调用该方式,使社团函数A在布局函数B内部被执行,那时候构造函数B就持有了结构函数A中的属性和办法,那就是运用类继承已毕B继承与A的基本原理;

一般来说代码达成demo:

JavaScript

function A(x) { this.x = x; this.say = function(){ return this.x; } }
function B(x,y) { this.m = A; //
把结构函数A作为一个惯常函数引用给临时措施m this.m(x); // 执行协会函数A;
delete this.m; // 清除临时措施this.m this.y = y; this.method =
function(){ return this.y; } } var a = new A(1); var b = new B(2,3);
console.log(a.say()); //输出1, 执行协会函数A中的say方法
console.log(b.say()); //输出2, 能执行该办法求证被再而三了A中的方法
console.log(b.method()); // 输出3, 构造函数也负有自己的章程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function A(x) {
    this.x = x;
    this.say = function(){
        return this.x;
    }
}
function B(x,y) {
    this.m = A; // 把构造函数A作为一个普通函数引用给临时方法m
    this.m(x);  // 执行构造函数A;
    delete this.m; // 清除临时方法this.m
    this.y = y;
    this.method = function(){
        return this.y;
    }
}
var a = new A(1);
var b = new B(2,3);
console.log(a.say()); //输出1, 执行构造函数A中的say方法
console.log(b.say()); //输出2, 能执行该方法说明被继承了A中的方法
console.log(b.method()); // 输出3, 构造函数也拥有自己的方法

上边的代码已毕了简便的类继承的底子,然而在纷纭的编程中是不会选取方面的办法的,因为地点的代码不够严峻;代码的耦合性高;大家能够运用更好的主意如下:

JavaScript

function A(x) { this.x = x; } A.prototype.getX = function(){ return
this.x; } // 实例化A var a = new A(1); console.log(a.x); // 1
console.log(a.getX()); // 输出1 //
现行我们来创设构造函数B,让其B继承与A,如下代码: function B(x,y) {
this.y = y; A.call(this,x); } B.prototype = new A(); // 原型继承
console.log(B.prototype.constructor); //
输出构造函数A,指针指向与协会函数A B.prototype.constructor = B; //
重新设置构造函数,使之指向B console.log(B.prototype.constructor); //
指向构造函数B B.prototype.getY = function(){ return this.y; } var b =
new B(1,2); console.log(b.x); // 1 console.log(b.getX()); // 1
console.log(b.getY()); // 2 //
下边是出现说法对构造函数getX举行重写的章程如下: B.prototype.getX =
function(){ return this.x; } var b2 = new B(10,20);
console.log(b2.getX()); // 输出10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
function A(x) {
    this.x = x;
}
A.prototype.getX = function(){
    return this.x;
}
// 实例化A
var a = new A(1);
console.log(a.x); // 1
console.log(a.getX()); // 输出1
// 现在我们来创建构造函数B,让其B继承与A,如下代码:
function B(x,y) {
    this.y = y;
    A.call(this,x);
}
B.prototype = new A();  // 原型继承
console.log(B.prototype.constructor); // 输出构造函数A,指针指向与构造函数A
B.prototype.constructor = B;          // 重新设置构造函数,使之指向B
console.log(B.prototype.constructor); // 指向构造函数B
B.prototype.getY = function(){
    return this.y;
}
var b = new B(1,2);
console.log(b.x); // 1
console.log(b.getX()); // 1
console.log(b.getY()); // 2
 
// 下面是演示对构造函数getX进行重写的方法如下:
B.prototype.getX = function(){
    return this.x;
}
var b2 = new B(10,20);
console.log(b2.getX());  // 输出10

上面大家来分析上面的代码:

在构造函数B内,使用A.call(this,x);那句代码的含义是:大家都精晓使用call或者apply方法可以变更this指针指向,从而可以已毕类的三番五次,因而在B构造函数内,把x的参数传递给A构造函数,并且继续于结构函数A中的属性和办法;

选取那句代码:B.prototype = new A();  能够完成原型继承,也就是B可以继承A中的原型所有的办法;console.log(B.prototype.constructor); 打印出输出构造函数A,指针指向与布局函数A;大家精通的是,当定义构造函数时候,其原型对象默许是一个Object类型的一个实例,其布局器默许会被安装为构造函数本身,如果改变构造函数prototype属性值,使其针对性于另一个目的的话,那么新对象就不会拥有原来的constructor的值,比如第三遍打印console.log(B.prototype.constructor); 指向于被实例化后的构造函数A,重写设置B的constructor的属性值的时候,第二次打印就本着于我B;因此B继承与构造A及其原型的拥有属性和办法,当然大家也得以对构造函数B重写构造函数A中的方法,如上边最终几句代码是对协会函数A中的getX方法开展重写,来贯彻和谐的事体~;

五:提出利用封装类完结持续

封装类完成再三再四的基本原理:先定义一个封装函数extend;该函数有2个参数,Sub代表子类,Sup代表超类;在函数内,先定义一个空函数F, 用来完成效益中转,先设置F的原型为超类的原型,然后把空函数的实例传递给子类的原型,使用一个空函数的功利是:幸免直接实例化超类可能会带动系统性能问题,比如超类的实例很大的话,实例化会占用很多内存;

一般来说代码:

JavaScript

function extend(Sub,Sup) { //Sub代表子类,Sup代表超类 //
首先定义一个空函数 var F = function(){}; // 设置空函数的原型为超类的原型
F.prototype = Sup.prototype; // 实例化空函数,并把超类原型引用传递给子类
Sub.prototype = new F(); // 重置子类原型的构造器为子类自身
Sub.prototype.constructor = Sub; //
在子类中保存超类的原型,防止子类与超类耦合 Sub.sup = Sup.prototype;
if(Sup.prototype.constructor === Object.prototype.constructor) { //
检测超类原型的构造器是不是为原型自身 Sup.prototype.constructor = Sup; } }
测试代码如下: // 上面大家定义2个类A和类B,大家指标是兑现B继承于A
function A(x) { this.x = x; this.getX = function(){ return this.x; } }
A.prototype.add = function(){ return this.x + this.x; } A.prototype.mul
= function(){ return this.x * this.x; } // 构造函数B function B(x){
A.call(this,x); // 继承构造函数A中的所有属性及办法 } extend(B,A); //
B继承于A var b = new B(11); console.log(b.getX()); // 11
console.log(b.add()); // 22 console.log(b.mul()); // 121

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
function extend(Sub,Sup) {
    //Sub表示子类,Sup表示超类
    // 首先定义一个空函数
    var F = function(){};
 
    // 设置空函数的原型为超类的原型
    F.prototype = Sup.prototype;
 
// 实例化空函数,并把超类原型引用传递给子类
    Sub.prototype = new F();
 
    // 重置子类原型的构造器为子类自身
    Sub.prototype.constructor = Sub;
 
    // 在子类中保存超类的原型,避免子类与超类耦合
    Sub.sup = Sup.prototype;
 
    if(Sup.prototype.constructor === Object.prototype.constructor) {
        // 检测超类原型的构造器是否为原型自身
        Sup.prototype.constructor = Sup;
    }
 
}
测试代码如下:
// 下面我们定义2个类A和类B,我们目的是实现B继承于A
function A(x) {
    this.x = x;
    this.getX = function(){
        return this.x;
    }
}
A.prototype.add = function(){
    return this.x + this.x;
}
A.prototype.mul = function(){
    return this.x * this.x;
}
// 构造函数B
function B(x){
    A.call(this,x); // 继承构造函数A中的所有属性及方法
}
extend(B,A);  // B继承于A
var b = new B(11);
console.log(b.getX()); // 11
console.log(b.add());  // 22
console.log(b.mul());  // 121

注意:在封装函数中,有诸如此类一句代码:Sub.sup = Sup.prototype; 大家后天得以来领会下它的意思:

比如说在B继承与A后,我给B函数的原型再定义一个与A相同的原型相同的办法add();

正如代码

JavaScript

extend(B,A); // B继承于A var b = new B(11); B.prototype.add =
function(){ return this.x + “” + this.x; } console.log(b.add()); // 1111

1
2
3
4
5
6
extend(B,A);  // B继承于A
var b = new B(11);
B.prototype.add = function(){
    return this.x + "" + this.x;
}
console.log(b.add()); // 1111

那就是说B函数中的add方法会覆盖A函数中的add方法;由此为了不掩盖A类中的add()方法,且调用A函数中的add方法;能够如下编写代码:

JavaScript

B.prototype.add = function(){ //return this.x + “” + this.x; return
B.sup.add.call(this); } console.log(b.add()); // 22

1
2
3
4
5
B.prototype.add = function(){
    //return this.x + "" + this.x;
    return B.sup.add.call(this);
}
console.log(b.add()); // 22

B.sup.add.call(this); 中的B.sup就包括了组织函数A函数的指针,因而包括A函数的具备属性和办法;由此得以调用A函数中的add方法;

如上是兑现持续的二种方法,类继承和原型继承,但是那么些后续无法持续DOM对象,也不扶助继承系统静态对象,静态方法等;比如Date对象如下:

JavaScript

// 使用类继承Date对象 function D(){ Date.apply(this,arguments); //
调用Date对象,对其引用,已毕继承 } var d = new D();
console.log(d.toLocaleString()); // [object object]

1
2
3
4
5
6
// 使用类继承Date对象
function D(){
    Date.apply(this,arguments); // 调用Date对象,对其引用,实现继承
}
var d = new D();
console.log(d.toLocaleString()); // [object object]

如上代码运行打印出object,大家可以见到使用类继承不能完成系统静态方法date对象的继续,因为她不是大约的函数结构,对申明,赋值和伊始化都开展了打包,因而无法继续;

下边大家再来看看使用原型继承date对象;

JavaScript

function D(){} D.prototype = new D(); var d = new D();
console.log(d.toLocaleString());//[object object]

1
2
3
4
function D(){}
D.prototype = new D();
var d = new D();
console.log(d.toLocaleString());//[object object]

咱俩从代码中观望,使用原型继承也不知道该如何做持续Date静态方法;不过大家得以如下封装代码继承:

JavaScript

function D(){ var d = new Date(); // 实例化Date对象 d.get = function(){
// 定义本地点法,直接调用Date对象的艺术 console.log(d.toLocaleString());
} return d; } var d = new D(); d.get(); // 2015/12/21 晚上12:08:38

1
2
3
4
5
6
7
8
9
function D(){
    var d = new Date();  // 实例化Date对象
    d.get = function(){ // 定义本地方法,间接调用Date对象的方法
        console.log(d.toLocaleString());
    }
    return d;
}
var d = new D();
d.get(); // 2015/12/21 上午12:08:38

六:精晓使用复制继承

复制继承的基本原理是:先规划一个空对象,然后使用for-in循环来遍历对象的分子,将该目的的分子一个一个复制给新的空对象里面;那样就已毕了复制继承了;如下代码:

JavaScript

function A(x,y) { this.x = x; this.y = y; this.add = function(){ return
this.x + this.y; } } A.prototype.mul = function(){ return this.x *
this.y; } var a = new A(2,3); var obj = {}; for(var i in a) { obj[i] =
a[i]; } console.log(obj); // object console.log(obj.x); // 2
console.log(obj.y); // 3 console.log(obj.add()); // 5
console.log(obj.mul()); // 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function A(x,y) {
    this.x = x;
    this.y = y;
    this.add = function(){
        return this.x + this.y;
    }
}
A.prototype.mul = function(){
    return this.x * this.y;
}
var a = new A(2,3);
var obj = {};
for(var i in a) {
    obj[i] = a[i];
}
console.log(obj); // object
console.log(obj.x); // 2
console.log(obj.y); // 3
console.log(obj.add()); // 5
console.log(obj.mul()); // 6

如上代码:先定义一个构造函数A,函数里面有2个属性x,y,还有一个add方法,该构造函数原型有一个mul方法,首先实列化下A后,再创制一个空对象obj,遍历对象一个个复制给空对象obj,从地点的打印效果来看,大家得以观察已经完毕了复制继承了;对于复制继承,大家得以封装成如下方法来调用:

JavaScript

// 为Function增加复制继承方法 Function.prototype.extend = function(o) {
for(var i in o) { //把参数对象的成员复制给当下目的的构造函数原型对象
this.constructor.prototype[i] = o[i]; } } // 测试代码如下: var o =
function(){}; o.extend(new A(1,2)); console.log(o.x); // 1
console.log(o.y); // 2 console.log(o.add()); // 3 console.log(o.mul());
// 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 为Function扩展复制继承方法
Function.prototype.extend = function(o) {
    for(var i in o) {
        //把参数对象的成员复制给当前对象的构造函数原型对象
        this.constructor.prototype[i] = o[i];
    }
}
// 测试代码如下:
var o = function(){};
o.extend(new A(1,2));
console.log(o.x);  // 1
console.log(o.y);  // 2
console.log(o.add()); // 3
console.log(o.mul()); // 2

上面封装的增加继承方法中的this对象指向于当下实列化后的靶子,而不是指向于构造函数本身,由此要利用原型伸张成员来说,就须要利用constructor属性来指向它的构造器,然后通过prototype属性指向构造函数的原型;

复制继承有如下优点:

1. 它不可能继承系统主旨对象的只读方法和性能

2. 如若目的数据非常多以来,这样一个个复制的话,性能是非凡低的;

3. 惟有对象被实列化后,才能给遍历对象的分子和特性,相对来说不够灵活;

4. 复制继承只是简短的赋值,所以只要赋值的对象是引用类型的目标的话,可能会存在一些副成效;如上大家看看有如上有的弱点,下边我们得以采纳clone(克隆的办法)来优化下:

基本思路是:为Function扩大一个方法,该方法可以把参数对象赋值赋值一个空构造函数的原型对象,然后实列化构造函数并回到实列对象,那样该目的就颇具了该目的的具有成员;代码如下:

JavaScript

Function.prototype.clone = function(o){ function Temp(){};
Temp.prototype = o; return Temp(); } // 测试代码如下:
Function.clone(new A(1,2)); console.log(o.x); // 1 console.log(o.y); //
2 console.log(o.add()); // 3 console.log(o.mul()); // 2

1
2
3
4
5
6
7
8
9
10
11
Function.prototype.clone = function(o){
    function Temp(){};
    Temp.prototype = o;
    return Temp();
}
// 测试代码如下:
Function.clone(new A(1,2));
console.log(o.x);  // 1
console.log(o.y);  // 2
console.log(o.add()); // 3
console.log(o.mul()); // 2

2 赞 19 收藏 1
评论

亚洲必赢官网 1

一:精通构造函数原型(prototype)机制

介绍

深远精晓JavaScript体系(18):面向对象编程之ECMAScript达成,

介绍

本章是关于ECMAScript面向对象达成的第2篇,第1篇大家谈论的是概论和CEMAScript的可比,如若您还尚未读第1篇,在拓展本章此前,我强烈提出你先读一下第1篇,因为本篇实在太长了(35页)。

英文原稿:
注:由于篇幅太长了,难免出现错误,时刻保持核对中。

在概论里,大家延伸到了ECMAScript,现在,当大家精通它OOP达成时,大家再来准确定义一下:
复制代码 代码如下:
ECMAScript is an object-oriented programming language supporting
delegating inheritance based on prototypes.

ECMAScript是一种面向对象语言,扶助基于原型的委托式继承。
大家将从最主题的数据类型来分析,首先要打听的是ECMAScript用原始值(primitive
values)和对象(objects)来不一致实体,由此有些文章里说的“在JavaScript里,一切都是对象”是漏洞百出的(不完全对),原始值就是大家这边要钻探的一对数据类型。

数据类型

固然ECMAScript是足以动态转化项目标动态弱类型语言,它仍然有数据类型的。也就是说,一个对象要属于一个如实的品种。
标准规范里定义了9种数据类型,但唯有6种是在ECMAScript程序里可以直接访问的,它们是:Undefined、Null、Boolean、String、Number、Object。

其余3种档次只可以在促成级别访问(ECMAScript对象是不能够利用这么些品种的)并用以规范来分解一些操作行为、保存中间值。那3连串型是:Reference、List和Completion。

从而,Reference是用来解释delete、typeof、this那样的操作符,并且带有一个基对象和一个特性名称;List描述的是参数列表的行为(在new说明式和函数调用的时候);Completion是用来诠释行为break、continue、return和throw语句的。

原始值类型 回头来看6中用来ECMAScript程序的数据类型,前5种是原始值类型,包罗Undefined、Null、Boolean、String、Number、Object。
原始值类型例子:
复制代码 代码如下:
var a = undefined;
var b = null;
var c = true;
var d = ‘test’;
var e = 10;

这一个值是在底层上平昔促成的,他们不是object,所以没有原型,没有构造函数。

二伯注:这个原生值和大家平日用的(Boolean、String、Number、Object)纵然名字上一般,但不是同一个事物。所以typeof(true)和typeof(Boolean)结果是分歧的,因为typeof(Boolean)的结果是function,所以函数Boolean、String、Number是有原型的(上面的读写属性章节也会波及)。

想了然数据是哪体系型用typeof是最为不过了,有个例证须要专注一下,若是用typeof来判断null的花色,结果是object,为啥吧?因为null的连串是概念为Null的。
复制代码 代码如下:
alert(typeof null); // “object”

来得”object”原因是因为专业就是那般规定的:对于Null值的typeof字符串值重回”object“。

正规没有想象解释那几个,不过Brendan Eich
(JavaScript发明人)注意到null相对于undefined大部分都是用以对象现身的地方,例如设置一个目的为空引用。然则多少文档里有些气人将之归咎为bug,而且将该bug放在Brendan
Eich也涉足座谈的bug列表里,结果就是天然,仍旧把typeof
null的结果设置为object(即使262-3的正儿八经是定义null的品类是Null,262-5业已将标准修改为null的类型是object了)。

Object类型

随之,Object类型(不要和Object构造函数混淆了,现在只谈谈抽象类型)是描述
ECMAScript对象的绝无仅有一个数据类型。

Object is an unordered collection of key-value pairs.
目的是一个包含key-value对的无序会聚

对象的key值被称之为属性,属性是原始值和其他对象的器皿。如果属性的值是函数大家称它为形式。

例如:
复制代码 代码如下:
var x = { // 对象”x”有3个属性: a, b, c
  a: 10, // 原始值
  b: {z: 100}, // 对象”b”有一个属性z
  c: function () { // 函数(方法)
    alert(‘method x.c’);
  }
};
 
alert(x.a); // 10
alert(x.b); // [object Object]
alert(x.b.z); // 100
x.c(); // ‘method x.c’

动态性

正如我辈在第17章中提出的,ES中的对象是一点一滴动态的。那代表,在程序执行的时候我们得以任意地抬高,修改或删除对象的性质。

例如:
复制代码 代码如下:
var foo = {x: 10};
 
// 添加新属性
foo.y = 20;
console.log(foo); // {x: 10, y: 20}
 
// 将属性值修改为函数
foo.x = function () {
  console.log(‘foo.x’);
};
 
foo.x(); // ‘foo.x’
 
// 删除属性
delete foo.x;
console.log(foo); // {y: 20}

有些属性不可能被改动——(只读属性、已删除属性或不足配置的性质)。
我们将稍后在性能特性里上课。

其它,ES5标准规定,静态对象无法伸张新的习性,并且它的特性页无法去除或者涂改。他们是所谓的冰冻对象,可以透过采纳Object.freeze(o)方法赢得。
复制代码 代码如下:
var foo = {x: 10};
 
// 冻结对象
Object.freeze(foo);
console.log(Object.isFrozen(foo)); // true
 
// 无法修改
foo.x = 100;
 
// 不可以增添
foo.y = 200;
 
// 不能去除
delete foo.x;
 
console.log(foo); // {x: 10}

在ES5专业里,也运用Object.preventExtensions(o)方法幸免扩张,或者应用Object.defineProperty(o)方法来定义属性:
复制代码 代码如下:
var foo = {x : 10};
 
Object.defineProperty(foo, “y”, {
  value: 20,
  writable: false, // 只读
  configurable: false // 不可配置
});
 
// 不可以改改
foo.y = 200;
 
// 不可以去除
delete foo.y; // false
 
// 防治增加
Object.preventExtensions(foo);
console.log(Object.isExtensible(foo)); // false
 
// 不可以添加新属性
foo.z = 30;
 
console.log(foo); {x: 10, y: 20}

松手对象、原生对象及宿主对象

有须要须求小心的是正统还分别了那内置对象、元素对象和宿主对象。

放置对象和要素对象是被ECMAScript规范定义和促成的,两者之间的出入卑不足道。所有ECMAScript落成的靶子都是原生对象(其中有些是停放对象、一些在程序执行的时候成立,例如用户自定义对象)。内置对象是原生对象的一个子集、是在先后起初以前放置到ECMAScript里的(例如,parseInt,
Match等)。所有的宿主对象是由宿主环境提供的,日常是浏览器,并可能包涵如window、alert等。

只顾,宿主对象可能是ES自身落成的,完全符合规范的语义。从这一点以来,他们能称之为“原生宿主”对象(尽快很理论),但是专业没有概念“原生宿主”对象的概念。

Boolean,String和Number对象

别的,规范也定义了部分原生的特种包装类,那一个目的是:

1.布尔目标
2.字符串对象
3.数字对象

那么些目的的创始,是因而相应的放到构造器创造,并且包涵原生值作为其里面属性,这一个目的足以转换省原始值,反之亦然。

复制代码 代码如下:
var c = new Boolean(true);
var d = new String(‘test’);
var e = new Number(10);
 
// 转换成原始值
// 使用不带new关键字的函数
с = Boolean(c);
d = String(d);
e = Number(e);
 
// 重新转换成对象
с = Object(c);
d = Object(d);
e = Object(e);

此外,也有目的是由新鲜的放到构造函数创造:
Function(函数对象构造器)、Array(数修筑造器)
RegExp(正则表明式构造器)、Math(数学模块)、
Date(日期的构造器)等等,那些目的也是Object对象类型的值,他们互相的不相同是由其中属性管理的,大家在下边研究那个情节。

字面量Literal

对此多个目的的值:对象(object),数组(array)和正则表明式(regular
expression),他们分别有简写的标示符称为:对象起先化器、数组先河化器、和正则说明式开首化器:
复制代码 代码如下:
// 等价于new Array(1, 2, 3);
// 或者array = new Array();
// array[0] = 1;
// array[1] = 2;
// array[2] = 3;
var array = [1, 2, 3];
 
// 等价于
// var object = new Object();
// object.a = 1;
// object.b = 2;
// object.c = 3;
var object = {a: 1, b: 2, c: 3};
 
// 等价于new RegExp(“^\\d+$”, “g”)
var re = /^\d+$/g;

注意,借使上述八个目的开展重新赋值名称到新的品类上的话,那随着的贯彻语义就是按照新赋值的类型来选用,例如在脚下的Rhino和老版本SpiderMonkey
1.7的完毕上,会中标以new关键字的构造器来创设对象,但有些已毕(当前Spider/TraceMonkey)字面量的语义在品种变更之后却不自然改变。
复制代码 代码如下:
var getClass = Object.prototype.toString;
 
Object = Number;
 
var foo = new Object;
alert([foo, getClass.call(foo)]); // 0, “[object Number]”
 
var bar = {};
 
// Rhino, SpiderMonkey 1.7中 – 0, “[object Number]”
// 其它: still “[object Object]”, “[object Object]”
alert([bar, getClass.call(bar)]);
 
// Array也是相同的职能
Array = Number;
 
foo = new Array;
alert([foo, getClass.call(foo)]); // 0, “[object Number]”
 
bar = [];
 
// Rhino, SpiderMonkey 1.7中 – 0, “[object Number]”
// 其它: still “”, “[object Object]”
alert([bar, getClass.call(bar)]);
 
// 但对RegExp,字面量的语义是不被改动的。 semantics of the literal
// isn’t being changed in all tested implementations
 
RegExp = Number;
 
foo = new RegExp;
alert([foo, getClass.call(foo)]); // 0, “[object Number]”
 
bar = /(?!)/g;
alert([bar, getClass.call(bar)]); // /(?!)/g, “[object RegExp]”

正则表明式字面量和RegExp对象

瞩目,上边2个例证在第三版的正儿八经里,正则表明式的语义都是等价的,regexp字面量只在一句里设有,并且再分析阶段创立,但RegExp构造器成立的却是新目标,所以那或许会促成出一部分难题,如lastIndex的值在测试的时候结果是荒唐的:
复制代码 代码如下:
for (var k = 0; k < 4; k++) {
  var re = /ecma/g;
  alert(re.lastIndex); // 0, 4, 0, 4
  alert(re.test(“ecmascript”)); // true, false, true, false
}
 
// 对比
 
for (var k = 0; k < 4; k++) {
  var re = new RegExp(“ecma”, “g”);
  alert(re.lastIndex); // 0, 0, 0, 0
  alert(re.test(“ecmascript”)); // true, true, true, true
}

注:不过那几个题材在第5版的ES规范都曾经校勘了,不管是依照字面量的仍旧构造器的,正则都是开立异目的。

提到数组

各种文字静态啄磨,JavaScript对象(日常是用对象早先化器{}来成立)被称之为哈希表哈希表或其他不难的名称:哈希(Ruby或Perl里的概念),
管理数组(PHP里的定义),词典 (Python里的定义)等。

除非这么的术语,首倘诺因为她们的构造都是一般的,就是应用“键-值”对来储存对象,完全符合“关联数组
”或“哈希表 ”理论定义的数据结构。
别的,哈希表抽象数据类型寻常是在贯彻层面使用。

不过,即使术语上来讲述这么些概念,但实际这些是荒谬,从ECMAScript来看:ECMAScript唯有一个对象以及项目以及它的子类型,那和“键-值”对存储没有何样界别,由此在那上头没有特意的概念。
因为任何对象的内部属性都得以储存为键-值”对:
复制代码 代码如下:
var a = {x: 10};
a[‘y’] = 20;
a.z = 30;
 
var b = new Number(1);
b.x = 10;
b.y = 20;
b[‘z’] = 30;
 
var c = new Function(”);
c.x = 10;
c.y = 20;
c[‘z’] = 30;
 
// 等等,任意对象的子类型”subtype”

别的,由于在ECMAScript中目的可以是空的,所以”hash”的概念在此处也是不科学的:
复制代码 代码如下:
Object.prototype.x = 10;
 
var a = {}; // 创建空”hash”
 
alert(a[“x”]); // 10, 但不为空
alert(a.toString); // function
 
a[“y”] = 20; // 添加新的键值对到 “hash”
alert(a[“y”]); // 20
 
Object.prototype.y = 20; // 添加原型属性
 
delete a[“y”]; // 删除
alert(a[“y”]); // 但那里key和value依旧有值 – 20

请留意,
ES5规范可以让大家创设没原型的目标(使用Object.create(null)方法已毕)对,从这么些角度来说,那样的对象可以称作哈希表:
复制代码 代码如下:
var aHashTable = Object.create(null);
console.log(aHashTable.toString); // 未定义

除此以外,一些性能有一定的getter /
setter方法​​,所以也可能导致混淆这些定义:
复制代码 代码如下:
var a = new String(“foo”);
a[‘length’] = 10;
alert(a[‘length’]); // 3

然则,即便认为“哈希”可能有一个“原型”(例如,在Ruby或Python里委托哈希对象的类),在ECMAScript里,这几个术语也是不对的,因为2个表示法之间没有语义上的分别(即用点表示法a.b和a[“b”]表示法)。

在ECMAScript中的“property属性”的定义语义上和”key”、数组索引、方法没有分别的,那里所有目标的属性读写都要安份守己统一的条条框框:检查原型链。

在下边Ruby的例证中,我们得以看看语义上的不相同:
复制代码 代码如下:
a = {}
a.class # Hash
 
a.length # 0
 
# new “key-value” pair
a[‘length’] = 10;
 
# 语义上,用点访问的是性质或艺术,而不是key
 
a.length # 1
 
# 而索引器访问访问的是hash里的key
 
a[‘length’] # 10
 
# 就接近于在存活对象上动态注明Hash类
# 然后声称新属性或措施
 
class Hash
  def z
    100
  end
end
 
# 新特性可以访问
 
a.z # 100
 
# 但不是”key”
 
a[‘z’] # nil

ECMA-262-3正规并不曾概念“哈希”(以及近似)的定义。不过,有这么的布局理论的话,那也许那些命名的靶子。

对象转换

将目标转化成原始值可以用valueOf方法,正如大家所说的,当函数的构造函数调用做为function(对于某些类其余),但若是不用new关键字就是将目的转化成原始值,就一定于隐式的valueOf方法调用:
复制代码 代码如下:
var a = new Number(1);
var primitiveA = Number(a); // 隐式”valueOf”调用
var alsoPrimitiveA = a.valueOf(); // 显式调用
 
alert([
  typeof a, // “object”
  typeof primitiveA, // “number”
  typeof alsoPrimitiveA // “number”
]);

那种艺术允许对象参加种种操作,例如:
复制代码 代码如下:
var a = new Number(1);
var b = new Number(2);
 
alert(a + b); // 3
 
// 甚至
 
var c = {
  x: 10,
  y: 20,
  valueOf: function () {
    return this.x + this.y;
  }
};
 
var d = {
  x: 30,
  y: 40,
  // 和c的valueOf功效雷同
  valueOf: c.valueOf
};
 
alert(c + d); // 100

valueOf的默认值会根据依照目的的花色变更(如若不被掩盖的话),对某些对象,他重临的是this——例如:Object.prototype.valueOf(),还有总计型的值:Date.prototype.valueOf()重返的是日期时间:
复制代码 代码如下:
var a = {};
alert(a.valueOf() === a); // true, “valueOf”返回this
 
var d = new Date();
alert(d.valueOf()); // time
alert(d.valueOf() === d.getTime()); // true

别的,对象还有一个更原始的代表性——字符串展现。
这一个toString方法是有限支撑的,它在好几操作上是电动使用的:
复制代码 代码如下:
var a = {
  valueOf: function () {
    return 100;
  },
  toString: function () {
    return ‘__test’;
  }
};
 
// 那个操作里,toString方法自动调用
alert(a); // “__test”
面向对象编程之ECMAScript已毕,深切通晓。 
// 可是此间,调用的却是valueOf()方法
alert(a + 10); // 110
 
// 但,一旦valueOf删除将来
// toString又足以活动调用了
delete a.valueOf;
alert(a + 10); // “_test10”

Object.prototype上定义的toString方法具有非同日常意义,它回到的大家上面将要钻探的中间[[Class]]属性值。

和转化成原始值(ToPrimitive)相比较,将值转化成对象类型也有一个转速规范(ToObject)。

一个显式方法是接纳内置的Object构造函数作为function来调用ToObject(有些接近通过new关键字也足以):
复制代码 代码如下:
var n = Object(1); // [object Number]
var s = Object(‘test’); // [object String]
 
// 一些近乎,使用new操作符也可以
var b = new Object(true); // [object Boolean]
 
// 应用参数new Object的话创制的是粗略对象
var o = new Object(); // [object Object]
 
// 要是参数是一个现有的目的
// 那创造的结果就是简单重返该目的
var a = [];
alert(a === new Object(a)); // true
alert(a === Object(a)); // true

有关调用内置构造函数,使用仍然不适用new操作符没有通用规则,取决于构造函数。
例如Array或Function当使用new操作符的构造函数或者不应用new操作符的概括函数使用发生相同的结果的:
复制代码 代码如下:
var a = Array(1, 2, 3); // [object Array]
var b = new Array(1, 2, 3); // [object Array]
var c = [1, 2, 3]; // [object Array]
 
var d = Function(”); // [object Function]
var e = new Function(”); // [object Function]

稍微操作符使用的时候,也有一对浮现和隐式转化:
复制代码 代码如下:
var a = 1;
var b = 2;
 
// 隐式
var c = a + b; // 3, number
var d = a + b + ‘5’ // “35”, string
 
// 显式
var e = ’10’; // “10”, string
var f = +e; // 10, number
var g = parseInt(e, 10); // 10, number
 
// 等等

属性的特色

持有的属性(property) 都得以有诸多特点(attributes)。

1.{ReadOnly}——忽略向属性赋值的写操作尝,但只读属性能够由宿主环境作为改变——也就是说不是“恒定值”
;
2.{DontEnum}——属性无法被for..in循环枚举
3.{DontDelete}——糊了delete操作符的一言一动被忽视(即删不掉);
4.{Internal}——内部属性,没闻名字(仅在贯彻层面使用),ECMAScript里不能访问那样的性能。

注意,在ES5里{ReadOnly},{DontEnum}和{DontDelete}被重新命名为[[Writable]],[[Enumerable]]和[[Configurable]],可以手工通过Object.defineProperty或类似的方式来治本那个属性。

复制代码 代码如下:
var foo = {};
 
Object.defineProperty(foo, “x”, {
  value: 10,
  writable: true, // 即{ReadOnly} = false
  enumerable: false, // 即{DontEnum} = true
  configurable: true // 即{DontDelete} = false
});
 
console.log(foo.x); // 10
 
// 通过descriptor获取特性集attributes
var desc = Object.getOwnPropertyDescriptor(foo, “x”);
 
console.log(desc.enumerable); // false
console.log(desc.writable); // true
// 等等

内部属性和艺术

亚洲必赢官网 ,目的也得以有内部属性(已毕规模的一有些),并且ECMAScript程序不可以直接访问(可是上面我们将见到,一些兑现允许访问一些如此的属性)。
那个属性通过嵌套的中括号[[
]]开展走访。大家来看中间的一对,那些属性的讲述可以到专业里查看到。

每个对象都应当完毕如下内部属性和章程:

1.[[Prototype]]——对象的原型(将在下边详细介绍)
2.[[Class]]——字符串对象的一种象征(例如,Object Array ,Function
Object,Function等);用来分别对象
3.[[Get]]——得到属性值的措施
4.[[Put]]——设置属性值的不二法门
5.[[CanPut]]——检查属性是不是可写
6.[[HasProperty]]——检查对象是或不是已经拥有该属性
7.[[Delete]]——从目的删除该属性
8.[[DefaultValue]]再次来到对象对于的原始值(调用valueOf方法,某些对象可能会抛出TypeError格外)。
因此Object.prototype.toString()方法可以直接得到内部属性[[Class]]的值,该措施应该回到下列字符串:
“[object ” + [[Class]] + “]” 。例如:
复制代码 代码如下:
var getClass = Object.prototype.toString;
 
getClass.call({}); // [object Object]
getClass.call([]); // [object Array]
getClass.call(new Number(1)); // [object Number]
// 等等

本条功用日常是用来检查对象用的,但业内上说宿主对象的[[Class]]可以为任意值,包蕴内置对象的[[Class]]属性的值,所以理论上来看是不可能100%来确保准确的。例如,document.childNodes.item(…)方法的[[Class]]特性,在IE里重临”String”,但其余完成里再次回到的着实”Function”。
复制代码 代码如下:
// in IE – “String”, in other – “Function”
alert(getClass.call(document.childNodes.item));

构造函数

因而,正如大家地点提到的,在ECMAScript中的对象是透过所谓的构造函数来创设的。

Constructor is a function that creates and initializes the newly created
object.
构造函数是一个函数,用来创立并开端化新创设的靶子。
目的创制(内存分配)是由构造函数的其中方法[[Construct]]肩负的。该内部方法的一颦一笑是概念好的,所有的构造函数都是利用该方法来为新目标分配内存的。

而起初化是通过新建对象上下上调用该函数来治本的,那是由构造函数的中间方法[[Call]]来负总责的。

专注,用户代码只可以在起初化阶段访问,纵然在初叶化阶段大家得以回到差其他对象(忽略第一等级创造的tihs对象):
复制代码 代码如下:
function A() {
  // 更新新成立的靶子
  this.x = 10;
  // 但重临的是见仁见智的目的
  return [1, 2, 3];
}
 
var a = new A();
console.log(a.x, a); undefined, [1, 2, 3]

引用15章函数——成立函数的算法小节,我们可以看到该函数是一个原生对象,蕴含[[Construct]]
]和[[Call]]
]性能以及显示的prototype原型属性——以后目的的原型(注:NativeObject是对此native
object原生对象的预约,在下边的伪代码中使用)。
复制代码 代码如下:
F = new NativeObject();
 
F.[[Class]] = “Function”
 
…. // 其它性质
 
F.[[Call]] = <reference to function> // function自身
 
F.[[Construct]] = internalConstructor // 普通的里边构造函数
 
…. // 别的性质
 
// F构造函数成立的目的原型
__objectPrototype = {};
__objectPrototype.constructor = F // {DontEnum}
F.prototype = __objectPrototype

[[Call]] ]是除[[Class]]特性(那里等同于”Function”
)之外区分对象的显要格局,因而,对象的中间[[Call]]特性作为函数调用。
那样的目的用typeof运算操作符的话重返的是”function”。不过它至关重若是和原生对象有关,有些景况的完毕在用typeof获取值的是差距等的,例如:window.alert
(…)在IE中的效果:
复制代码 代码如下:
// IE浏览器中 – “Object”, “object”, 其余浏览器 – “Function”,
“function”
alert(Object.prototype.toString.call(window.alert));
alert(typeof window.alert); // “Object”

里头方法[[Construct]]是通过使用带new运算符的构造函数来激活的,正如大家所说的那几个办法是负担内存分配和对象创造的。如若没有参数,调用构造函数的括号也得以简简单单:
复制代码 代码如下:
function A(x) { // constructor А
  this.x = x || 10;
}
 
// 不传参数的话,括号也足以大致
var a = new A; // or new A();
alert(a.x); // 10
 
// 显式传入参数x
var b = new A(20);
alert(b.x); // 20

大家也亮堂,构造函数(初步化阶段)里的shis被装置为新创设的目标 。

让我们商量一下对象成立的算法。

目的创立的算法

里面方法[[Construct]] 的行事足以描述成如下:
复制代码 代码如下:
F.[[Construct]](initialParameters):
 
O = new NativeObject();
 
// 属性[[Class]]被安装为”Object”
O.[[Class]] = “Object”
 
// 引用F.prototype的时候取得该对象g
var __objectPrototype = F.prototype;
 
// 如果__objectPrototype是对象,就:
O.[[Prototype]] = __objectPrototype
// 否则:
O.[[Prototype]] = Object.prototype;
// 这里O.[[Prototype]]是Object对象的原型
 
// 新创设对象最先化的时候利用了F.[[Call]]
// 将this设置为新创造的对象O
// 参数和F里的initialParameters是均等的
R = F.[[Call]](initialParameters); this === O;
// 这里R是[[Call]]的再次来到值
// 在JS里看,像这样:
// R = F.apply(O, initialParameters);
 
// 如果R是对象
return R
// 否则
return O

请留心五个至关紧要特色:

1.率先,新成立对象的原型是从当前天天函数的prototype属性获取的(那代表同一个构造函数创制的四个创制对象的原型能够不相同是因为函数的prototype属性也足以分歧)。
2.其次,正如我们地点提到的,若是在对象初阶化的时候,[[Call]]归来的是目的,那正好是用于所有new操作符的结果:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10 – 从原型上获得
 
// 设置.prototype属性为新对象
// 为何显式表明.constructor属性将在上面表明
A.prototype = {
  constructor: A,
  y: 100
};
 
var b = new A();
// 对象”b”有了新属性
alert(b.x); // undefined
alert(b.y); // 100 – 从原型上获取
 
// 但a对象的原型如故可以博得原来的结果
alert(a.x); // 10 – 从原型上获取
 
function B() {
  this.x = 10;
  return new Array();
}
 
// 假若”B”构造函数没有重返(或重临this)
// 那么this对象就足以采纳,然而上面的气象再次来到的是array
var b = new B();
alert(b.x); // undefined
alert(Object.prototype.toString.call(b)); // [object Array]

让大家来详细询问一下原型

原型

各类对象都有一个原型(一些连串对象除了)。原型通讯是透过中间的、隐式的、不可直接访问[[Prototype]]原型属性来举办的,原型可以是一个对象,也足以是null值。

属性构造函数(Property constructor)

上面的例证有有2个第一的知识点,第二个是有关函数的constructor属性的prototype属性,在函数成立的算法里,大家通晓constructor属性在函数创制阶段被设置为函数的prototype属性,constructor属性的值是函数自身的基本点引用:

复制代码 代码如下:
function A() {}
var a = new A();
alert(a.constructor); // function A() {}, by delegation
alert(a.constructor === A); // true

一般而言在那种气象下,存在着一个误区:constructor构造属性作为新制造对象自我的属性是谬误的,不过,正如我们所寓目的的,这一个特性属于原型并且经过延续来拜访对象。

经过持续constructor属性的实例,可以直接获得的原型对象的引用:
复制代码 代码如下:
function A() {}
A.prototype.x = new Number(10);
 
var a = new A();
alert(a.constructor.prototype); // [object Object]
 
alert(a.x); // 10, 通过原型
// 和a.[[Prototype]].x效果等同
alert(a.constructor.prototype.x); // 10
 
alert(a.constructor.prototype.x === a.x); // true

但请留心,函数的constructor和prototype属性在对象成立将来都可以重新定义的。在那种境况下,对象失去上面所说的编制。倘若因而函数的prototype属性去编辑元素的prototype原型的话(添加新对象或改动现有对象),实例准将看到新添加的性质。

可是,如若大家彻底改变函数的prototype属性(通过分配一个新的目标),那本来构造函数的引用就是不见,那是因为大家创制的对象不包含constructor属性:
复制代码 代码如下:
function A() {}
A.prototype = {
  x: 10
};
 
var a = new A();
alert(a.x); // 10
alert(a.constructor === A); // false!

因此,对函数的原型引用须求手工復苏:
复制代码 代码如下:
function A() {}
A.prototype = {
  constructor: A,
  x: 10
};
 
var a = new A();
alert(a.x); // 10
alert(a.constructor === A); // true

专注就算手动恢复了constructor属性,和原先丢失的原型比较,{DontEnum}特性没有了,也就是说A.prototype里的for..in循环语句不支持了,可是第5版正式里,通过[[Enumerable]]
特性提供了决定可枚举状态enumerable的力量。
复制代码 代码如下:
var foo = {x: 10};
 
Object.defineProperty(foo, “y”, {
  value: 20,
  enumerable: false // aka {DontEnum} = true
});
 
console.log(foo.x, foo.y); // 10, 20
 
for (var k in foo) {
  console.log(k); // only “x”
}
 
var xDesc = Object.getOwnPropertyDescriptor(foo, “x”);
var yDesc = Object.getOwnPropertyDescriptor(foo, “y”);
 
console.log(
  xDesc.enumerable, // true
  yDesc.enumerable  // false
);

显式prototype和隐式[[Prototype]]属性

寻常,一个目的的原型通过函数的prototype属性显式引用是不得法的,他援引的是同一个目的,对象的[[Prototype]]属性:

a.[[Prototype]] —-> Prototype <—- A.prototype

此外,
实例的[[Prototype]]值确实是在构造函数的prototype属性上得到的。

不过,提交prototype属性不会影响已经成立对象的原型(唯有在构造函数的prototype属性改变的时候才会影响到),就是说新创造的对象才有有新的原型,而已创建对象仍旧引用到原来的旧原型(那些原型已经无法被再被涂改了)。
复制代码 代码如下:
// 在改动A.prototype原型此前的图景
a.[[Prototype]] —-> Prototype <—- A.prototype
 
// 修改之后
A.prototype —-> New prototype // 新对象会具备这一个原型
a.[[Prototype]] —-> Prototype // 指导的原来的原型上

例如:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
A.prototype = {
  constructor: A,
  x: 20
  y: 30
};
 
// 对象a是经过隐式的[[Prototype]]引用从石油的prototype上获得的值
alert(a.x); // 10
alert(a.y) // undefined
 
var b = new A();
 
// 但新目的是从新原型上赢得的值
alert(b.x); // 20
alert(b.y) // 30

因此,有的作品说“动态修改原型将震慑所有的靶子都会具有新的原型”是荒谬的,新原型仅仅在原型修改之后的新创设对象上生效。

那里的要紧规则是:对象的原型是目的的创设的时候创立的,并且在此之后无法修改为新的目标,假设依然引用到同一个目的,可以因而构造函数的显式prototype引用,对象创制未来,只可以对原型的性质进行添加或改动。

非标准的__proto__属性

唯独,有些落成(例如SpiderMonkey),提供了不正规的__proto__显式属性来引用对象的原型:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
var __newPrototype = {
  constructor: A,
  x: 20,
  y: 30
};
 
// 引用到新对象
A.prototype = __newPrototype;
 
var b = new A();
alert(b.x); // 20
alert(b.y); // 30
 
// “a”对象使用的依旧是旧的原型
alert(a.x); // 10
alert(a.y); // undefined
 
// 显式修改原型
a.__proto__ = __newPrototype;
 
// 现在”а”对象引用的是新对象
alert(a.x); // 20
alert(a.y); // 30

注意,ES5提供了Object.getPrototypeOf(O)方法,该办法直接重返对象的[[Prototype]]性能——实例的初阶原型。
可是,和__proto__对待,它只是getter,它不允许set值。
复制代码 代码如下:
var foo = {};
Object.getPrototypeOf(foo) == Object.prototype; // true

对象独立于构造函数 因为实例的原型独立于构造函数和构造函数的prototype属性,构造函数已毕了祥和的第一工作(成立对象)未来可以去除。原型对象通过引用[[Prototype]]性能持续存在:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
// 设置A为null – 显示引用构造函数
A = null;
 
// 但要是.constructor属性没有改动的话,
// 如故得以透过它创立对象
var b = new a.constructor();
alert(b.x); // 10
 
// 隐式的引用也删除掉
delete a.constructor.prototype.constructor;
delete b.constructor.prototype.constructor;
 
// 通过A的构造函数再也无法成立对象了
// 但那2个目标依旧有和好的原型
alert(a.x); // 10
alert(b.x); // 10

instanceof操作符的表征 大家是经过构造函数的prototype属性来浮现引用原型的,那和instanceof操作符有关。该操作符是和原型链一起干活的,而不是构造函数,考虑到这点,当检测对象的时候屡次会有误解:
复制代码 代码如下:
if (foo instanceof Foo) {
  …
}

那不是用来检测对象foo是还是不是是用Foo构造函数创立的,所有instanceof运算符只必要一个目的属性——foo.[[Prototype]],在原型链中从Foo.prototype起先检查其是不是存在。instanceof运算符是通过构造函数里的内部方法[[HasInstance]]来激活的。

让我们来看看那些例子:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
alert(a instanceof A); // true
 
// 假使设置原型为null
A.prototype = null;
 
// …”a”如故得以经过a.[[Prototype]]走访原型
alert(a.x); // 10
 
// 不过,instanceof操作符不可以再正常使用了
// 因为它是从构造函数的prototype属性来兑现的
alert(a instanceof A); // 错误,A.prototype不是目的

一方面,可以由构造函数来创立对象,但假设目的的[[Prototype]]性能和构造函数的prototype属性的值设置的是均等的话,instanceof检查的时候会再次来到true:
复制代码 代码如下:
function B() {}
var b = new B();
 
alert(b instanceof B); // true
 
function C() {}
 
var __proto = {
  constructor: C
};
 
C.prototype = __proto;
b.__proto__ = __proto;
 
alert(b instanceof C); // true
alert(b instanceof B); // false

原型可以存放方法并共享属性 大部分主次里应用原型是用来囤积对象的措施、默许状态和共享对象的属性。

其实,对象足以具备自己的气象 ,但方法一般是同一的。
因而,为了内存优化,方法一般是在原型里定义的。
那表示,这一个构造函数创制的享有实例都足以共享找个格局。
复制代码 代码如下:
function A(x) {
  this.x = x || 100;
}
 
A.prototype = (function () {
 
  // 发轫化上下文
  // 使用额外的靶子
 
  var _someSharedVar = 500;
 
  function _someHelper() {
    alert(‘internal helper: ‘ + _someSharedVar);
  }
 
  function method1() {
    alert(‘method1: ‘ + this.x);
  }
 
  function method2() {
    alert(‘method2: ‘ + this.x);
    _someHelper();
  }
 
  // 原型自身
  return {
    constructor: A,
    method1: method1,
    method2: method2
  };
 
})();
 
var a = new A(10);
var b = new A(20);
 
a.method1(); // method1: 10
a.method2(); // method2: 10, internal helper: 500
 
b.method1(); // method1: 20
b.method2(); // method2: 20, internal helper: 500
 
// 2个对象使用的是原型里同样的主意
alert(a.method1 === b.method1); // true
alert(a.method2 === b.method2); // true

读写属性

正如我辈提到,读取和写入属性值是通过中间的[[Get]]和[[Put]]艺术。这一个内部方法是由此性能访问器激活的:点标记法或者索引标记法:
复制代码 代码如下:
// 写入
foo.bar = 10; // 调用了[[Put]]
 
console.log(foo.bar); // 10, 调用了[[Get]]
console.log(foo[‘bar’]); // 效果一样

让大家用伪代码来看一下那几个格局是哪些做事的:

[[Get]]方法

[[Get]]也会从原型链中查询属性,所以经过对象也足以访问原型中的属性。

O.[[Get]](P):
复制代码 代码如下:
// 如若是协调的习性,就回来
if (O.hasOwnProperty(P)) {
  return O.P;
}
 
// 否则,继续分析原型
var __proto = O.[[Prototype]];
 
// 假使原型是null,重返undefined
// 这是唯恐的:最顶层Object.prototype.[[Prototype]]是null
if (__proto === null) {
  return undefined;
}
 
// 否则,对原型链递归调用[[Get]],在各层的原型中查找属性
// 直到原型为null
return __proto.[[Get]](P)

请注意,因为[[Get]]在如下情形也会重临undefined:
复制代码 代码如下:
if (window.someObject) {
  …
}

此处,在window里没有找到someObject属性,然后会在原型里找,原型的原型里找,以此类推,要是都找不到,按照定义就再次来到undefined。

专注:in操作符也足以负担寻找属性(也会招来原型链):
复制代码 代码如下:
if (‘someObject’ in window) {
  …
}

那有助于防止有些卓殊题材:比如固然someObject存在,在someObject等于false的时候,第一批次检测就通可是。

[[Put]]方法

[[Put]]方法可以创建、更新目的自我的性质,并且掩盖原型里的同名属性。

O.[[Put]](P, V):
复制代码 代码如下:
// 假如无法给属性写值,就退出
if (!O.[[CanPut]](P)) {
  return;
}
 
// 假如目的没有自己的特性,就创办它
// 所有的attributes特性都是false
if (!O.hasOwnProperty(P)) {
  createNewProperty(O, P, attributes: {
    ReadOnly: false,
    DontEnum: false,
    DontDelete: false,
    Internal: false
  });
}
 
// 倘使属性存在就安装值,但不改动attributes特性
O.P = V
 
return;

例如:
复制代码 代码如下:
Object.prototype.x = 100;
 
var foo = {};
console.log(foo.x); // 100, 继承属性
 
foo.x = 10; // [[Put]]
console.log(foo.x); // 10, 自身性质
 
delete foo.x;
console.log(foo.x); // 重新是100,继承属性
请留心,无法遮盖原型里的只读属性,赋值结果将忽略,那是由中间方法[[CanPut]]控制的。

// 例如,属性length是只读的,大家来掩盖一下length试试
 
function SuperString() {
  /* nothing */
}
 
SuperString.prototype = new String(“abc”);
 
var foo = new SuperString();
 
console.log(foo.length); // 3, “abc”的长度
 
// 尝试掩盖
foo.length = 5;
console.log(foo.length); // 依然是3

但在ES5的粗暴情势下,即使掩盖只读属性的话,会保存TypeError错误。

属性访问器

内部方法[[Get]]和[[Put]]在ECMAScript里是透过点符号或者索引法来激活的,假设属性标示符是法定的名字的话,可以通过“.”来访问,而索引方运行动态定义名称。
复制代码 代码如下:
var a = {testProperty: 10};
 
alert(a.testProperty); // 10, 点
alert(a[‘testProperty’]); // 10, 索引
 
var propertyName = ‘Property’;
alert(a[‘test’ + propertyName]); // 10, 动态属性通过索引的艺术

此处有一个可怜重大的特征——属性访问器总是接纳ToObject规范来相比较“.”左侧的值。那种隐式转化和这句“在JavaScript中一切都是对象”有关系,(然则,当大家早已通晓了,JavaScript里不是兼具的值都是目标)。

若是对原始值举行性能访问器取值,访问之前会先对原始值举办对象包装(包蕴原始值),然后通过包装的靶子进行访问属性,属性访问之后,包装对象就会被删除。

例如:
复制代码 代码如下:
var a = 10; // 原始值
 
// 可是可以访问方法(如同对象一样)
alert(a.toString()); // “10”
 
// 其余,大家得以在a上创造一个心属性
a.test = 100; // 好像是没难题的
 
// 但,[[Get]]措施没有回到该属性的值,重返的却是undefined
alert(a.test); // undefined

那么,为啥整个例子里的原始值能够访问toString格局,而无法访问新创制的test属性呢?

答案很简短:

率先,正如我们所说,使用性质访问器未来,它早已不是原始值了,而是一个打包过的中游对象(整个例子是利用new
Number(a)),而toString方法那时候是经过原型链查找到的:
复制代码 代码如下:
// 执行a.toString()的原理:
 

  1. wrapper = new Number(a);
  2. wrapper.toString(); // “10”
  3. delete wrapper;

接下来,[[Put]]措施创设新特性时候,也是透过包装装的目的进行的:
复制代码 代码如下:
// 执行a.test = 100的原理:
 

  1. wrapper = new Number(a);
  2. wrapper.test = 100;
  3. delete wrapper;

俺们看到,在第3步的时候,包装的对象以及去除了,随着新创制的属性页被删除了——删除包装对象自我。

下一场利用[[Get]]赢得test值的时候,再一回成立了包装对象,但此时包装的目的已经远非test属性了,所以回来的是undefined:
复制代码 代码如下:
// 执行a.test的原理:
 

  1. wrapper = new Number(a);
  2. wrapper.test; // undefined

那种措施诠释了原始值的读取方式,其余,任何原始值借使常常用在走访属性的话,时间效用考虑,都是一直用一个对象替代它;与此相反,倘使不常常访问,或者只是用来计算的话,到可以保存那种样式。

继承

我们精通,ECMAScript是应用基于原型的委托式继承。链和原型在原型链里已经提到过了。其实,所有寄托的已毕和原型链的摸索分析都缩水到[[Get]]方法了。

即使您一点一滴知晓[[Get]]主意,这JavaScript中的继承那个题材将不解自答了。

时常在论坛上谈论JavaScript中的继承时,我都是用一行代码来突显,事实上,大家不须求成立任何对象或函数,因为该语言已经是依照继承的了,代码如下:
复制代码 代码如下:
alert(1..toString()); // “1”

大家已经了然了[[Get]]艺术和特性访问器的原理了,我们来看看都暴发了何等:

1.第一,从原始值1,通过new Number(1)创设包装对象
2.然后toString方法是从那个包裹对象上持续取得的

何以是继承的?
因为在ECMAScript中的对象可以有温馨的属性,包装对象在那种状态下并未toString方法。
由此它是从原理里继续的,即Number.prototype。

只顾有个神秘的地点,在上头的例子中的多个点不是一个漏洞至极多。第一点是表示小数部分,第三个才是一个属性访问器:
复制代码 代码如下:
1.toString(); // 语法错误!
 
(1).toString(); // OK
 
1..toString(); // OK
 
1[‘toString’](); // OK

原型链

让大家来得如何为用户定义对象成立原型链,格外不难:
复制代码 代码如下:
function A() {
  alert(‘A.[[Call]] activated’);
  this.x = 10;
}
A.prototype.y = 20;
 
var a = new A();
alert([a.x, a.y]); // 10 (自身), 20 (继承)
 
function B() {}
 
// 如今的原型链情势就是安装对象的原型为此外一个新对象
B.prototype = new A();
 
// 修复原型的constructor属性,否则的话是A了
B.prototype.constructor = B;
 
var b = new B();
alert([b.x, b.y]); // 10, 20, 2个都是后续的
 
// [[Get]] b.x:
// b.x (no) –>
// b.[[Prototype]].x (yes) – 10
 
// [[Get]] b.y
// b.y (no) –>
// b.[[Prototype]].y (no) –>
// b.[[Prototype]].[[Prototype]].y (yes) – 20
 
// where b.[[Prototype]] === B.prototype,
// and b.[[Prototype]].[[Prototype]] === A.prototype

那种方法有三个特点:

第一,B.prototype将富含x属性。乍一看那也许不对,你恐怕会想x属性是在A里定义的同时B构造函数也是那样期望的。即使原型继承正常情状是没难点的,但B构造函数有时候可能不须要x属性,与基于class的持续相比较,所有的性质都复制到后代子类里了。

固然,尽管有须要(模拟基于类的三番五遍)将x属性赋给B构造函数创制的对象上,有一部分方法,我们后来来呈现其中一种方式。

说不上,这不是一个表征而是缺点——子类原型创造的时候,构造函数的代码也推行了,大家得以观望音信”A.[[Call]]
activated”呈现了两回——当用A构造函数创制对象赋给B.prototype属性的时候,其它一场是a对象创立自己的时候!

上边的事例相比较紧要,在父类的构造函数抛出的不胜:可能实际目标创造的时候要求检讨吧,但很明朗,同样的case,也就是就是使用那几个父对象作为原型的时候就会出错。
复制代码 代码如下:
function A(param) {
  if (!param) {
    throw ‘Param required’;
  }
  this.param = param;
}
A.prototype.x = 10;
 
var a = new A(20);
alert([a.x, a.param]); // 10, 20
 
function B() {}
B.prototype = new A(); // Error

别的,在父类的构造函数有太多代码的话也是一种缺点。

焚薮而田这一个“作用”和题材,程序员使用原型链的专业形式(上边展现),主要目标就是在中等包装构造函数的开创,那些包裹构造函数的链里包括需求的原型。
复制代码 代码如下:
function A() {
  alert(‘A.[[Call]] activated’);
  this.x = 10;
}
A.prototype.y = 20;
 
var a = new A();
alert([a.x, a.y]); // 10 (自身), 20 (集成)
 
function B() {
  // 或者应用A.apply(this, arguments)
  B.superproto.constructor.apply(this, arguments);
}
 
// 继承:通过空的中等构造函数将原型连在一起
var F = function () {};
F.prototype = A.prototype; // 引用
B.prototype = new F();
B.superproto = A.prototype; // 呈现引用到别的一个原型上, “sugar”
 
// 修复原型的constructor属性,否则的就是A了
B.prototype.constructor = B;
 
var b = new B();
alert([b.x, b.y]); // 10 (自身), 20 (集成)

注意,大家在b实例上创立了友好的x属性,通过B.superproto.constructor调用父构造函数来引用新成立对象的上下文。

俺们也修复了父构造函数在创制子原型的时候不须要的调用,此时,新闻”A.[[Call]]
activated”在必要的时候才会来得。

为了在原型链里重复雷同的一举一动(中间构造函数创制,设置superproto,苏醒原有构造函数),上边的模板可以封装成一个非常方面的工具函数,其目的是一连原型的时候不是基于构造函数的实际名称。
复制代码 代码如下:
function inherit(child, parent) {
  var F = function () {};
  F.prototype = parent.prototype
  child.prototype = new F();
  child.prototype.constructor = child;
  child.superproto = parent.prototype;
  return child;
}

因此,继承:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
function B() {}
inherit(B, A); // 连接原型
 
var b = new B();
alert(b.x); // 10, 在A.prototype查找到

也有过多语法情势(包装而成),但所有的语法行都是为着削减上述代码里的作为。

比如说,倘诺我们把高中级的构造函数放到外面,就足以优化后边的代码(因而,唯有一个函数被创立),然后重用它:
复制代码 代码如下:
var inherit = (function(){
  function F() {}
  return function (child, parent) {
    F.prototype = parent.prototype;
    child.prototype = new F;
    child.prototype.constructor = child;
    child.superproto = parent.prototype;
    return child;
  };
})();

是因为目标的忠实原型是[[Prototype]]性能,那意味着F.prototype可以很简单修改和任用,因为经过new
F制造的child.prototype可以从child.prototype的脚下值里获取[[Prototype]]:
复制代码 代码如下:
function A() {}
A.prototype.x = 10;
 
function B() {}
inherit(B, A);
 
B.prototype.y = 20;
 
B.prototype.foo = function () {
  alert(“B#foo”);
};
 
var b = new B();
alert(b.x); // 10, 在A.prototype里查到
 
function C() {}
inherit(C, B);
 
// 使用”superproto”语法糖
// 调用父原型的同名方法
 
C.ptototype.foo = function () {
  C.superproto.foo.call(this);
  alert(“C#foo”);
};
 
var c = new C();
alert([c.x, c.y]); // 10, 20
 
c.foo(); // B#foo, C#foo

小心,ES5为原型链标准化了这一个工具函数,那就是Object.create方法。ES3能够行使以下办法贯彻:
复制代码 代码如下:
Object.create ||
Object.create = function (parent, properties) {
  function F() {}
  F.prototype = parent;
  var child = new F;
  for (var k in properties) {
    child[k] = properties[k].value;
  }
  return child;
}

// 用法
var foo = {x: 10};
var bar = Object.create(foo, {y: {value: 20}});
console.log(bar.x, bar.y); // 10, 20

其余,所有模仿现在根据类的经典一而再情势都是基于那个条件落成的,现在得以见见,它实际上不是根据类的接轨,而是连接原型的一个很有益于的代码重用。

结论

本章内容早已很丰裕和详尽了,希望那些材料对你有用,并且消除你对ECMAScript的疑问,要是你有别的难题,请留言,大家一块谈谈。

介绍
本章是关于ECMAScript面向对象完毕的第2篇,第1篇大家谈论的是概论和CEM…

 

本章是有关ECMAScript面向对象已毕的第2篇,第1篇大家研商的是概论和CEMAScript的比较,若是你还未曾读第1篇,在展开本章从前,我强烈提议你先读一下第1篇,因为本篇实在太长了(35页)。

prototype是javascript达成与管理持续的一种机制,也是面向对象的安插性思想.构造函数的原型存储着引用对象的一个指针,该指针指向与一个原型对象,对象内部存储着函数的原始属性和艺术;我们可以珍重prototype属性,可以访问原型内部的性质和方法。

英文原稿:
注:由于篇幅太长了,难免出现谬误,时刻保持校对中。

 

在概论里,我们延伸到了ECMAScript,现在,当大家知道它OOP落成时,我们再来准确定义一下:

当构造函数被实列化后,所有的实例对象都可以访问构造函数的原型成员,如若在原型中宣示一个成员,所有的实列方法都足以共享它,比如如下代码:

复制代码 代码如下:

 

ECMAScript is an object-oriented programming language supporting
delegating inheritance based on prototypes.

// 构造函数A 它的原型有一个getName方法

function A(name){

this.name = name;

}

A.prototype.getName = function(){

return this.name;

}

// 实列化2次后 该2个实列都有原型getName方法;如下代码

var instance1 = new A(“longen1”);

var instance2 = new A(“longen2”);

console.log(instance1.getName()); //longen1

console.log(instance2.getName()); // longen2

ECMAScript是一种面向对象语言,协助基于原型的委托式继承。
咱俩将从最中心的数据类型来分析,首先要询问的是ECMAScript用原始值(primitive
values)和目标(objects)来分别实体,由此有些作品里说的“在JavaScript里,一切都是对象”是荒唐的(不完全对),原始值就是大家那里要切磋的片段数据类型。

 

数据类型

原型具有普通对象协会,可以将别的一般对象设置为原型对象;
一般景况下,对象都继承与Object,也足以领略Object是颇具目标的超类,Object是一直不原型的,而构造函数拥有原型,由此实列化的靶子也是Object的实列,如下代码:

纵然ECMAScript是足以动态转化项目标动态弱类型语言,它仍旧有数据类型的。也就是说,一个对象要属于一个翔实的品种。
标准规范里定义了9种数据类型,但唯有6种是在ECMAScript程序里可以直接访问的,它们是:Undefined、Null、Boolean、String、Number、Object。

 

其余3种档次只好在落到实处级别访问(ECMAScript对象是不能选择这么些类其他)并用以规范来解释一些操作行为、保存中间值。这3种档次是:Reference、List和Completion。

// 实列化对象是构造函数的实列

console.log(instance1 instanceof A); //true

console.log(instance2 instanceof A); // true

 

// 实列化对象也是Object的实列

console.log(instance1 instanceof Object); //true

console.log(instance2 instanceof Object); //true

 

//Object 对象是装有目的的超类,因而构造函数也是Object的实列

console.log(A instanceof Object); // true

 

// 不过实列化对象 不是Function对象的实列 如下代码

console.log(instance1 instanceof Function); // false

console.log(instance2 instanceof Function); // false

 

// 不过Object与Function有关联 如下代码表明

console.log(Function instanceof Object); // true

console.log(Object instanceof Function); // true

之所以,Reference是用来解释delete、typeof、this那样的操作符,并且带有一个基对象和一个特性名称;List描述的是参数列表的行事(在new表明式和函数调用的时候);Completion是用来诠释行为break、continue、return和throw语句的。

 

原始值类型 回头来看6中用来ECMAScript程序的数据类型,前5种是原始值类型,包含Undefined、Null、Boolean、String、Number、Object。
原始值类型例子:

如上代码,Function是Object的实列,也得以是Object也是Function的实列;他们是2个例外的构造器,我们一连看如下代码:

复制代码 代码如下:

 

var a = undefined;
var b = null;
var c = true;
var d = ‘test’;
var e = 10;

var f = new Function();

var o = new Object();

console.log(“————“);

console.log(f instanceof Function); //true

console.log(o instanceof Function); // false

console.log(f instanceof Object); // true

console.log(o instanceof Object); // true

这一个值是在底部上直接促成的,他们不是object,所以并未原型,没有构造函数。

 

公公注:那个原生值和大家一贯用的(Boolean、String、Number、Object)尽管名字上相似,但不是同一个东西。所以typeof(true)和typeof(Boolean)结果是分裂的,因为typeof(Boolean)的结果是function,所以函数Boolean、String、Number是有原型的(上边的读写属性章节也会涉嫌)。

我们知晓,在原型上平添成员属性或者措施的话,它被所有的实列化对象所共享属性和办法,不过只要实列化对象有和原型相同的积极分子成员名字的话,那么它取到的成员是本实列化对象,要是本实列对象中没有的话,那么它会到原型中去找寻该成员,要是原型找到就回到,否则的会重返undefined,如下代码测试

想通晓数据是哪一种档次用typeof是最为不过了,有个例证须求专注一下,如若用typeof来判断null的项目,结果是object,为啥吗?因为null的品种是概念为Null的。

 

复制代码 代码如下:

function B(){

this.name = “longen2”;

}

B.prototype.name = “AA”;

B.prototype.getName = function(){

return this.name;

};

 

var b1 = new B();

// 在本实列查找,找到就回到,否则到原型查找

console.log(b1.name); // longen2

 

// 在本实列没有找到该办法,就到原型去探寻

console.log(b1.getName());//longen2

 

//
若是在本实列没有找到的话,到原型上追寻也未曾找到的话,就再次回到undefined

console.log(b1.a); // undefined

 

//
现在自己使用delete运算符删除本地实列属性,那么取到的是就是原型属性了,如下代码:

delete b1.name;

console.log(b1.name); // AA

alert(typeof null); // “object”

 

来得”object”原因是因为专业就是这么规定的:对于Null值的typeof字符串值重回”object“。

二:领会原型域链的定义

正式没有设想解释这几个,可是Brendan Eich
(JavaScript发明人)注意到null相对于undefined一大半都是用于对象出现的地点,例如设置一个对象为空引用。可是多少文档里多少气人将之归纳为bug,而且将该bug放在Brendan
Eich也插足座谈的bug列表里,结果就是后天,照旧把typeof
null的结果设置为object(即使262-3的正统是定义null的品种是Null,262-5早已将标准修改为null的花色是object了)。

 

Object类型

原型的优点是力所能及以目的社团为载体,创造大气的实列,那个实列能共享原型中的成员(属性和格局);同时也可以动用原型完毕面向对象中的继承机制~
如下代码:上边大家来看这些布局函数AA和结构函数BB,当BB.prototype = new
AA(11);执行那些的时候,那么B就一而再与A,B中的原型就有x的属性值为11

随即,Object类型(不要和Object构造函数混淆了,现在只谈谈抽象类型)是描述
ECMAScript对象的唯一一个数据类型。

 

Object is an unordered collection of key-value pairs.
对象是一个分包key-value对的无序聚集

function AA(x){

this.x = x;

}

function BB(x) {

this.x = x;

}

BB.prototype = new AA(11);

console.log(BB.prototype.x); //11

 

// 大家再来精通原型继承和原型链的定义,代码如下,都有注释

function A(x) {

this.x = x;

}

// 在A的原型上定义一个特性x = 0

A.prototype.x = 0;

function B(x) {

this.x = x;

}

B.prototype = new A(1);

对象的key值被称呼属性,属性是原始值和其余对象的容器。若是属性的值是函数大家称它为艺术

 

例如:

实列化A new A(1)的时候 在A函数内this.x =1, B.prototype = new
A(1);B.prototype 是A的实列 也就是B继承于A, 即B.prototype.x = 1;
如下代码:

复制代码 代码如下:

 

var x = { // 对象”x”有3个属性: a, b, c
  a: 10, // 原始值
  b: {z: 100}, // 对象”b”有一个属性z
  c: function () { // 函数(方法)
    alert(‘method x.c’);
  }
};
 
alert(x.a); // 10
alert(x.b); // [object Object]
alert(x.b.z); // 100
x.c(); // ‘method x.c’

console.log(B.prototype.x); // 1

// 定义C的构造函数

function C(x) {

this.x = x;

}

C.prototype = new B(2);

动态性

 

正如大家在第17章中提议的,ES中的对象是一点一滴动态的。那意味着,在程序执行的时候大家能够无限制地足够,修改或删除对象的习性。

C.prototype = new B(2); 也就是C.prototype 是B的实列,C继承于B;那么new
B(2)的时候 在B的构造函数内 this.x = 2;那么 C的原型上会有一个性质x =2
即C.prototype.x = 2; 如下代码:

例如:

 

复制代码 代码如下:

console.log(C.prototype.x); // 2

var foo = {x: 10};
 
// 添加新属性
foo.y = 20;
console.log(foo); // {x: 10, y: 20}
 
// 将属性值修改为函数
foo.x = function () {
  console.log(‘foo.x’);
};
 
foo.x(); // ‘foo.x’
 
// 删除属性
delete foo.x;
console.log(foo); // {y: 20}

 

多少属性无法被涂改——(只读属性、已去除属性或不足配置的性能)。
大家将稍后在性能特性里上课。

上边是实列化 var d = new C(3);
实列化C的构造函数时候,那么在C的构造函数内this.x = 3;
因而如下打印实列化后的d.x = 3;如下代码:

此外,ES5正规规定,静态对象不可以扩展新的习性,并且它的习性页无法去除或者涂改。他们是所谓的冻结对象,可以透过动用Object.freeze(o)方法得到。

 

复制代码 代码如下:

var d = new C(3);

console.log(d.x); // 3

var foo = {x: 10};
 
// 冻结对象
Object.freeze(foo);
console.log(Object.isFrozen(foo)); // true
 
// 不能够修改
foo.x = 100;
 
// 不能扩充
foo.y = 200;
 
// 不可能去除
delete foo.x;
 
console.log(foo); // {x: 10}

 

在ES5正式里,也利用Object.preventExtensions(o)方法防止伸张,或者应用Object.defineProperty(o)方法来定义属性:

删除d.x 再拜访d.x的时候
本实列对象被删掉,只可以从原型上去寻找;由于C.prototype = new B(2);
也就是C继承于B,由此C的原型也有x = 2;即C.prototype.x = 2; 如下代码:

复制代码 代码如下:

 

var foo = {x : 10};
 
Object.defineProperty(foo, “y”, {
  value: 20,
  writable: false, // 只读
  configurable: false // 不可配置
});
 
// 不可以改改
foo.y = 200;
 
// 无法去除
delete foo.y; // false
 
// 防治增添
Object.preventExtensions(foo);
console.log(Object.isExtensible(foo)); // false
 
// 不可以添加新属性
foo.z = 30;
 
console.log(foo); {x: 10, y: 20}

delete d.x;

console.log(d.x); //2

停放对象、原生对象及宿主对象

 

有须求必要小心的是专业还分别了那内置对象、元素对象和宿主对象。

删去C.prototype.x后,我们从上边代码知道,C是延续于B的,自身的原型被删掉后,会去搜寻父元素的原型链,由此在B的原型上找到x
=1; 如下代码:

内置对象和要素对象是被ECMAScript规范定义和已毕的,两者之间的差别微不足道。所有ECMAScript已毕的目的都是原生对象(其中有些是置于对象、一些在程序执行的时候创制,例如用户自定义对象)。内置对象是原生对象的一个子集、是在程序先河从前放置到ECMAScript里的(例如,parseInt,
Match等)。所有的宿主对象是由宿主环境提供的,平常是浏览器,并可能包罗如window、alert等。

 

只顾,宿主对象可能是ES自身落成的,完全符合规范的语义。从那点以来,他们能称之为“原生宿主”对象(尽快很理论),可是专业没有定义“原生宿主”对象的概念。

delete C.prototype.x;

console.log(d.x); // 1

Boolean,String和Number对象

 

除此以外,规范也定义了有些原生的奇特包装类,这么些目的是:

当删除B的原型属性x后,由于B是继承于A的,由此会从父元素的原型链上查找A原型上是否有x的性能,即使有的话,就回到,否则看A是或不是有继续,没有继续的话,继续往Object上去寻找,假使没有找到就重回undefined
因而当删除B的原型x后,delete B.prototype.x; 打印出A上的原型x=0;
如下代码:

1.布尔目的
2.字符串对象
3.数字对象

 

这个目标的创导,是因此相应的嵌入构造器制造,并且包罗原生值作为其里面属性,这几个目的足以转换省原始值,反之亦然。

delete B.prototype.x;

console.log(d.x); // 0

 

// 继续删除A的原型x后 结果尚未找到,就再次来到undefined了;

delete A.prototype.x;

console.log(d.x); // undefined

复制代码 代码如下:

 

var c = new Boolean(true);
var d = new String(‘test’);
var e = new Number(10);
 
// 转换成原始值
// 使用不带new关键字的函数
с = Boolean(c);
d = String(d);
e = Number(e);
 
// 重新转换成对象
с = Object(c);
d = Object(d);
e = Object(e);

在javascript中,一切都是对象,Function和Object都是函数的实列;构造函数的父原型指向于Function原型,Function.prototype的父原型指向与Object的原型,Object的父原型也本着与Function原型,Object.prototype是颇具原型的顶层;

其它,也有对象是由新鲜的松开构造函数创制:
Function(函数对象构造器)、Array(数修筑造器)
RegExp(正则表明式构造器)、Math(数学模块)、
Date(日期的构造器)等等,这一个目标也是Object对象类型的值,他们互相的分别是由其中属性管理的,大家在底下商量那么些情节。

 

字面量Literal

一般来说代码:

对此多少个对象的值:对象(object),数组(array)和正则表明式(regular
expression),他们各自有简写的标记符称为:对象伊始化器、数组伊始化器、和正则表达式早先化器:

 

复制代码 代码如下:

Function.prototype.a = function(){

console.log(“我是父原型Function”);

}

Object.prototype.a = function(){

console.log(“我是 父原型Object”);

}

function A(){

this.a = “a”;

}

A.prototype = {

B: function(){

console.log(“b”);

}

}

// Function 和 Object都是函数的实列 如下:

console.log(A instanceof Function); // true

console.log(A instanceof Object); // true

 

// A.prototype是一个对象,它是Object的实列,但不是Function的实列

console.log(A.prototype instanceof Function); // false

console.log(A.prototype instanceof Object); // true

 

// Function是Object的实列 同是Object也是Function的实列

console.log(Function instanceof Object); // true

console.log(Object instanceof Function); // true

 

/*

* Function.prototype是Object的实列
但是Object.prototype不是Function的实列

* 表明Object.prototype是所有父原型的顶层

*/

console.log(Function.prototype instanceof Object); //true

console.log(Object.prototype instanceof Function); // false

// 等价于new Array(1, 2, 3);
// 或者array = new Array();
// array[0] = 1;
// array[1] = 2;
// array[2] = 3;
var array = [1, 2, 3];
 
// 等价于
// var object = new Object();
// object.a = 1;
// object.b = 2;
// object.c = 3;
var object = {a: 1, b: 2, c: 3};
 
// 等价于new RegExp(“^\\d+$”, “g”)
var re = /^\d+$/g;

 

专注,尽管上述多个对象举行双重赋值名称到新的项目上的话,这随着的完毕语义就是依据新赋值的花色来利用,例如在眼前的Rhino和老版本SpiderMonkey
1.7的贯彻上,会中标以new关键字的构造器来成立对象,但稍事已毕(当前Spider/TraceMonkey)字面量的语义在类型变更未来却不自然改变。

三:领悟原型继承机制

复制代码 代码如下:

 

var getClass = Object.prototype.toString;
 
Object = Number;
 
var foo = new Object;
alert([foo, getClass.call(foo)]); // 0, “[object Number]”
 
var bar = {};
 
// Rhino, SpiderMonkey 1.7中 – 0, “[object Number]”
// 其它: still “[object Object]”, “[object Object]”
alert([bar, getClass.call(bar)]);
 
// Array也是均等的功效
Array = Number;
 
foo = new Array;
alert([foo, getClass.call(foo)]); // 0, “[object Number]”
 
bar = [];
 
// Rhino, SpiderMonkey 1.7中 – 0, “[object Number]”
// 其它: still “”, “[object Object]”
alert([bar, getClass.call(bar)]);
 
// 但对RegExp,字面量的语义是不被改动的。 semantics of the literal
// isn’t being changed in all tested implementations
 
RegExp = Number;
 
foo = new RegExp;
alert([foo, getClass.call(foo)]); // 0, “[object Number]”
 
bar = /(?!)/g;
alert([bar, getClass.call(bar)]); // /(?!)/g, “[object RegExp]”

构造函数都有一个指针指向原型,Object.prototype是怀有原型对象的顶层,比如如下代码:

正则表明式字面量和RegExp对象

 

注意,上边2个例子在第三版的科班里,正则表达式的语义都是等价的,regexp字面量只在一句里存在,并且再分析阶段创立,但RegExp构造器成立的却是新对象,所以那恐怕会招致出有些难点,如lastIndex的值在测试的时候结果是不对的:

var obj = {};

Object.prototype.name = “tugenhua”;

console.log(obj.name); // tugenhua

复制代码 代码如下:

 

for (var k = 0; k < 4; k++) {
  var re = /ecma/g;
  alert(re.lastIndex); // 0, 4, 0, 4
  alert(re.test(“ecmascript”)); // true, false, true, false
}
 
// 对比
 
for (var k = 0; k < 4; k++) {
  var re = new RegExp(“ecma”, “g”);
  alert(re.lastIndex); // 0, 0, 0, 0
  alert(re.test(“ecmascript”)); // true, true, true, true
}

给Object.prototype
定义一个性能,通过字面量构建的靶子的话,都会从父类那边得到Object.prototype的属性;

注:可是这个标题在第5版的ES规范都已经改良了,不管是基于字面量的依旧构造器的,正则都是成立新对象。

 

涉嫌数组

从上边代码大家了解,原型继承的不二法门是:要是A必要延续于B,那么A.prototype(A的原型)
= new B()(作为B的实列) 即可完毕A继承于B;
因而大家下边可以伊始化一个空的构造函数;然后把对象赋值给构造函数的原型,然后回到该构造函数的实列;
即可完成延续; 如下代码:

各类文字静态啄磨,JavaScript对象(平常是用对象初阶化器{}来创立)被称作哈希表哈希表或其余简单的名目:哈希(Ruby或Perl里的定义),
管理数组(PHP里的定义),词典 (Python里的概念)等。

 

唯有如此的术语,首假若因为她们的构造都是相似的,就是采纳“键-值”对来囤积对象,完全符合“关联数组
”或“哈希表 ”理论定义的数据结构。
其它,哈希表抽象数据类型经常是在实现规模使用。

if(typeof Object.create !== ‘function’) {

Object.create = function(o) {

var F = new Function();

F.prototype = o;

return new F();

}

}

var a = {

name: ‘longen’,

getName: function(){

return this.name;

}

};

var b = {};

b = Object.create(a);

console.log(typeof b); //object

console.log(b.name); // longen

console.log(b.getName()); // longen

然则,即使术语上来叙述这一个定义,但事实上那些是不当,从ECMAScript来看:ECMAScript唯有一个对象以及项目以及它的子类型,那和“键-值”对存储没有怎么分别,由此在那上头没有特其他概念。
因为任何对象的内部属性都可以储存为键-值”对:

 

复制代码 代码如下:

如上代码:大家先检测Object是还是不是业已有Object.create该措施;假若没有的话就创建一个;
该形式内创立一个空的构造器,把参数对象传递给构造函数的原型,最终回到该构造函数的实列,就兑现了接二连三形式;如上测试代码:先定义一个a对象,有成员属性name=’longen’,还有一个getName()方法;最终回来该name属性;
然后定义一个b空对象,使用Object.create(a);把a对象继承给b对象,因而b对象也有性能name和分子方法getName();

var a = {x: 10};
a[‘y’] = 20;
a.z = 30;
 
var b = new Number(1);
b.x = 10;
b.y = 20;
b[‘z’] = 30;
 
var c = new Function(”);
c.x = 10;
c.y = 20;
c[‘z’] = 30;
 
// 等等,任意对象的子类型”subtype”

 

其它,由于在ECMAScript中目的可以是空的,所以”hash”的定义在此间也是不正确的:

明亮原型查找原理:对象查找先在该构造函数内搜索对应的特性,若是该对象没有该属性的话,

复制代码 代码如下:

 

Object.prototype.x = 10;
 
var a = {}; // 创建空”hash”
 
alert(a[“x”]); // 10, 但不为空
alert(a.toString); // function
 
a[“y”] = 20; // 添加新的键值对到 “hash”
alert(a[“y”]); // 20
 
Object.prototype.y = 20; // 添加原型属性
 
delete a[“y”]; // 删除
alert(a[“y”]); // 但此间key和value依然有值 – 20

那么javascript会试着从该原型上去寻找,如若原型对象中也绝非该属性的话,那么它们会从原型中的原型去搜寻,直到查找的Object.prototype也没有该属性的话,那么就会再次来到undefined;由此我们想要仅在该目标内搜寻的话,为了进步性能,大家可以利用hasOwnProperty()来判定该目的内有没有该属性,若是有的话,就举办代码(使用for-in循环查找):如下:

请小心,
ES5正式可以让咱们创设没原型的靶子(使用Object.create(null)方法完毕)对,从那么些角度来说,这样的目的可以称为哈希表:

 

复制代码 代码如下:

var obj = {

“name”:’tugenhua’,

“age”:’28’

};

// 使用for-in循环

for(var i in obj) {

if(obj.hasOwnProperty(i)) {

console.log(obj[i]); //tugenhua 28

}

}

var aHashTable = Object.create(null);
console.log(aHashTable.toString); // 未定义

 

其它,一些属性有特定的getter /
setter方法​​,所以也说不定造成混淆那个概念:

如上利用for-in循环查找对象里面的属性,不过大家须要了然的是:for-in循环查找对象的性质,它是不有限支撑顺序的,for-in循环和for循环;最本色的区分是:for循环是有各样的,for-in循环遍历对象是无序的,由此大家若是需要对象有限接济顺序的话,能够把目的转换为数组来,然后再使用for循环遍历即可;

复制代码 代码如下:

 

var a = new String(“foo”);
a[‘length’] = 10;
alert(a[‘length’]); // 3

上边大家来谈谈原型继承的长处和缺陷

唯独,固然认为“哈希”可能有一个“原型”(例如,在Ruby或Python里委托哈希对象的类),在ECMAScript里,那个术语也是有失水准的,因为2个表示法之间从未语义上的差异(即用点表示法a.b和a[“b”]表示法)。

 

在ECMAScript中的“property属性”的定义语义上和”key”、数组索引、方法没有分开的,那里有着目的的性质读写都要根据统一的规则:检查原型链。

// 先看下边的代码:

// 定义构造函数A,定义特权属性和特权方法

function A(x) {

this.x1 = x;

this.getX1 = function(){

return this.x1;

}

}

// 定义构造函数B,定义特权属性和特权方法

function B(x) {

this.x2 = x;

this.getX2 = function(){

return this.x1 + this.x2;

}

}

B.prototype = new A(1);

在上边Ruby的例证中,大家可以观看语义上的不相同:

 

复制代码 代码如下:

B.prototype = new
A(1);那句代码执行的时候,B的原型继承于A,由此B.prototype也有A的性质和艺术,即:B.prototype.x1
= 1; B.prototype.getX1 方法;可是B也有投机的特权属性x2和特权方法getX2;
如下代码:

a = {}
a.class # Hash
 
a.length # 0
 
# new “key-value” pair
a[‘length’] = 10;
 
# 语义上,用点访问的是性质或艺术,而不是key
 
a.length # 1
 
# 而索引器访问访问的是hash里的key
 
a[‘length’] # 10
 
# 就类似于在存活对象上动态评释Hash类
# 然后声称新属性或方法
 
class Hash
  def z
    100
  end
end
 
# 新特性可以访问
 
a.z # 100
 
# 但不是”key”
 
a[‘z’] # nil

 

ECMA-262-3标准并没有概念“哈希”(以及近似)的定义。可是,有诸如此类的布局理论的话,那可能这几个命名的对象。

function C(x) {

this.x3 = x;

this.getX3 = function(){

return this.x3 + this.x2;

}

}

C.prototype = new B(2);

C.prototype = new
B(2);那句代码执行的时候,C的原型继承于B,因而C.prototype.x2 = 2;
C.prototype.getX2方法且C也有谈得来的特权属性x3和特权方法getX3,

var b = new B(2);

var c = new C(3);

console.log(b.x1); // 1

console.log(c.x1); // 1

console.log(c.getX3()); // 5

console.log(c.getX2()); // 3

var b = new B(2);

对象转换

 

将目的转化成原始值能够用valueOf方法,正如我们所说的,当函数的构造函数调用做为function(对于某些类型的),但假如不用new关键字就是将对象转化成原始值,就一定于隐式的valueOf方法调用:

实列化B的时候 b.x1
首先会在构造函数内查找x1属性,没有找到,由于B的原型继承于A,因而A有x1属性,由此B.prototype.x1
= 1找到了;var c = new C(3);
实列化C的时候,从上面的代码可以看看C继承于B,B继承于A,因而在C函数中绝非找到x1属性,会往原型继续搜寻,直到找到父元素A有x1属性,因而c.x1
= 1;c.getX3()方法; 再次来到this.x3+this.x2 this.x3 = 3;this.x2
是B的性质,由此this.x2 = 2;c.getX2(); 查找的格局也同等,不再解释

复制代码 代码如下:

 

var a = new Number(1);
var primitiveA = Number(a); // 隐式”valueOf”调用
var alsoPrimitiveA = a.valueOf(); // 显式调用
 
alert([
  typeof a, // “object”
  typeof primitiveA, // “number”
  typeof alsoPrimitiveA // “number”
]);

prototype的短处与亮点如下:

那种措施允许对象参加各个操作,例如:

 

复制代码 代码如下:

可取是:可以允许多少个目的实列共享原型对象的积极分子及艺术,

var a = new Number(1);
var b = new Number(2);
 
alert(a + b); // 3
 
// 甚至
 
var c = {
  x: 10,
  y: 20,
  valueOf: function () {
    return this.x + this.y;
  }
};
 
var d = {
  x: 30,
  y: 40,
  // 和c的valueOf功用雷同
  valueOf: c.valueOf
};
 
alert(c + d); // 100

 

valueOf的默许值会基于根据目标的连串变更(假诺不被覆盖的话),对一些对象,他归来的是this——例如:Object.prototype.valueOf(),还有总括型的值:Date.prototype.valueOf()重返的是日期时间:

缺点是:1. 各个构造函数唯有一个原型,由此不直接协理多重继承;

复制代码 代码如下:

 

var a = {};
alert(a.valueOf() === a); // true, “valueOf”返回this
 
var d = new Date();
alert(d.valueOf()); // time
alert(d.valueOf() === d.getTime()); // true

2.
无法很好地支撑多参数或动态参数的父类。在原型继承阶段,用户还无法控制以

除此以外,对象还有一个更原始的代表性——字符串展现。
那几个toString方法是牢靠的,它在好几操作上是自行使用的:

 

复制代码 代码如下:

怎么着参数来实列化构造函数。

var a = {
  valueOf: function () {
    return 100;
  },
  toString: function () {
    return ‘__test’;
  }
};
 
// 这几个操作里,toString方法自动调用
alert(a); // “__test”
 
// 可是此地,调用的却是valueOf()方法
alert(a + 10); // 110
 
// 但,一旦valueOf删除未来
// toString又可以自动调用了
delete a.valueOf;
alert(a + 10); // “_test10”

 

Object.prototype上定义的toString方法具有特种含义,它回到的我们下边将要研商的其中[[Class]]属性值。

四:了解使用类继承(继承的更好的方案)

和转化成原始值(ToPrimitive)相比较,将值转化成对象类型也有一个转折规范(ToObject)。

 

一个显式方法是运用内置的Object构造函数作为function来调用ToObject(有些看似通过new关键字也足以):

类继承也称为构造函数继承,在子类中施行父类的构造函数;达成原理是:可以将一个协会函数A的办法赋值给另一个构造函数B,然后调用该格局,使社团函数A在结构函数B内部被实施,那时候构造函数B就有所了协会函数A中的属性和方法,那就是利用类继承达成B继承与A的基本原理;

复制代码 代码如下:

 

var n = Object(1); // [object Number]
var s = Object(‘test’); // [object String]
 
// 一些近似,使用new操作符也可以
var b = new Object(true); // [object Boolean]
 
// 应用参数new Object的话创立的是粗略对象
var o = new Object(); // [object Object]
 
// 倘若参数是一个共处的目的
// 那创建的结果就是不难重返该目的
var a = [];
alert(a === new Object(a)); // true
alert(a === Object(a)); // true

如下代码完毕demo:

关于调用内置构造函数,使用照旧不适用new操作符没有通用规则,取决于构造函数。
例如Array或Function当使用new操作符的构造函数或者不选择new操作符的粗略函数使用发生相同的结果的:

 

复制代码 代码如下:

function A(x) {

this.x = x;

this.say = function(){

return this.x;

}

}

function B(x,y) {

this.m = A; // 把组织函数A作为一个一般性函数引用给临时方法m

this.m(x); // 执行社团函数A;

delete this.m; // 清除临时措施this.m

this.y = y;

this.method = function(){

return this.y;

}

}

var a = new A(1);

var b = new B(2,3);

console.log(a.say()); //输出1, 执行组织函数A中的say方法

console.log(b.say()); //输出2, 能执行该方法求证被延续了A中的方法

console.log(b.method()); // 输出3, 构造函数也具备和谐的点子

var a = Array(1, 2, 3); // [object Array]
var b = new Array(1, 2, 3); // [object Array]
var c = [1, 2, 3]; // [object Array]
 
var d = Function(”); // [object Function]
var e = new Function(”); // [object Function]

 

稍稍操作符使用的时候,也有一些出示和隐式转化:

地方的代码完毕了简短的类继承的功底,可是在复杂的编程中是不会使用方面的法子的,因为上边的代码不够严刻;代码的耦合性高;大家得以拔取更好的主意如下:

复制代码 代码如下:

 

var a = 1;
var b = 2;
 
// 隐式
var c = a + b; // 3, number
var d = a + b + ‘5’ // “35”, string
 
// 显式
var e = ’10’; // “10”, string
var f = +e; // 10, number
var g = parseInt(e, 10); // 10, number
 
// 等等

function A(x) {

this.x = x;

}

A.prototype.getX = function(){

return this.x;

}

// 实例化A

var a = new A(1);

console.log(a.x); // 1

console.log(a.getX()); // 输出1

// 现在我们来创制构造函数B,让其B继承与A,如下代码:

function B(x,y) {

this.y = y;

A.call(this,x);

}

B.prototype = new A(); // 原型继承

console.log(B.prototype.constructor); //
输出构造函数A,指针指向与布局函数A

B.prototype.constructor = B; // 重新安装构造函数,使之指向B

console.log(B.prototype.constructor); // 指向结构函数B

B.prototype.getY = function(){

return this.y;

}

var b = new B(1,2);

console.log(b.x); // 1

console.log(b.getX()); // 1

console.log(b.getY()); // 2

 

// 下边是出现说法对构造函数getX进行重写的法子如下:

B.prototype.getX = function(){

return this.x;

}

var b2 = new B(10,20);

console.log(b2.getX()); // 输出10

性能的特征

 

装有的性质(property) 都足以有成百上千表征(attributes)。

上边大家来分析下面的代码:

1.{ReadOnly}——忽略向属性赋值的写操作尝,但只读属性可以由宿主环境作为改变——也就是说不是“恒定值”
;
2.{DontEnum}——属性无法被for..in循环枚举
3.{DontDelete}——糊了delete操作符的作为被忽略(即删不掉);
4.{Internal}——内部属性,没出名字(仅在贯彻层面使用),ECMAScript里不可以访问那样的性能。

 

注意,在ES5里{ReadOnly},{DontEnum}和{DontDelete}被重新命名为[[Writable]],[[Enumerable]]和[[Configurable]],可以手工通过Object.defineProperty或近似的艺术来管理这么些属性。

在构造函数B内,使用A.call(this,x);那句代码的意义是:大家都知道使用call或者apply方法可以转移this指针指向,从而可以完成类的存续,因而在B构造函数内,把x的参数传递给A构造函数,并且一连于结构函数A中的属性和艺术;

复制代码 代码如下:

 

var foo = {};
 
Object.defineProperty(foo, “x”, {
  value: 10,
  writable: true, // 即{ReadOnly} = false
  enumerable: false, // 即{DontEnum} = true
  configurable: true // 即{DontDelete} = false
});
 
console.log(foo.x); // 10
 
// 通过descriptor获取特性集attributes
var desc = Object.getOwnPropertyDescriptor(foo, “x”);
 
console.log(desc.enumerable); // false
console.log(desc.writable); // true
// 等等

接纳那句代码:B.prototype = new A();
可以完成原型继承,也就是B可以继承A中的原型所有的法子;console.log(B.prototype.constructor);
打印出输出构造函数A,指针指向与布局函数A;大家精晓的是,当定义构造函数时候,其原型对象默许是一个Object类型的一个实例,其布局器默许会被设置为构造函数本身,如若改变构造函数prototype属性值,使其针对性于另一个目的的话,那么新目标就不会持有原来的constructor的值,比如第四遍打印console.log(B.prototype.constructor);
指向于被实例化后的构造函数A,重写设置B的constructor的属性值的时候,第二次打印就对准于我B;因而B继承与构造A及其原型的兼具属性和方法,当然大家也可以对构造函数B重写构造函数A中的方法,如下边最后几句代码是对结构函数A中的getX方法进行重写,来完毕自己的事务~;

其中属性和章程

 

目的也足以有内部属性(完毕规模的一片段),并且ECMAScript程序不可能直接访问(可是上面大家将看到,一些贯彻允许访问片段如此的特性)。
这一个属性通过嵌套的中括号[[
]]举办走访。大家来看中间的局地,那几个属性的叙述能够到正规里查看到。

五:提议采纳封装类完结再而三

各样对象都应该已毕如下内部属性和办法:

 

1.[[Prototype]]——对象的原型(将在底下详细介绍)
2.[[Class]]——字符串对象的一种象征(例如,Object Array ,Function
Object,Function等);用来分别对象
3.[[Get]]——获得属性值的法子
4.[[Put]]——设置属性值的点子
5.[[CanPut]]——检查属性是不是可写
6.[[HasProperty]]——检校对象是不是早已怀有该属性
7.[[Delete]]——从目的删除该属性
8.[[DefaultValue]]再次来到对象对于的原始值(调用valueOf方法,某些对象可能会抛出TypeError卓殊)。
由此Object.prototype.toString()方法可以直接拿到内部属性[[Class]]的值,该措施应该回到下列字符串:
“[object ” + [[Class]] + “]” 。例如:

封装类落成一连的基本原理:先定义一个封装函数extend;该函数有2个参数,Sub代表子类,Sup代表超类;在函数内,先定义一个空函数F,
用来兑现效益中转,先设置F的原型为超类的原型,然后把空函数的实例传递给子类的原型,使用一个空函数的便宜是:防止直接实例化超类可能会带动系统特性难题,比如超类的实例很大的话,实例化会占用很多内存;

复制代码 代码如下:

 

var getClass = Object.prototype.toString;
 
getClass.call({}); // [object Object]
getClass.call([]); // [object Array]
getClass.call(new Number(1)); // [object Number]
// 等等

正如代码:

以此效用平常是用来检核对象用的,但业内上说宿主对象的[[Class]]可以为任意值,包罗内置对象的[[Class]]属性的值,所以理论上来看是不可以100%来有限支持准确的。例如,document.childNodes.item(…)方法的[[Class]]特性,在IE里重回”String”,但任何完成里重临的真正”Function”。

 

复制代码 代码如下:

function extend(Sub,Sup) {

//Sub表示子类,Sup表示超类

// 首先定义一个空函数

var F = function(){};

 

// 设置空函数的原型为超类的原型

F.prototype = Sup.prototype;

 

// 实例化空函数,并把超类原型引用传递给子类

Sub.prototype = new F();

 

// 重置子类原型的构造器为子类自身

Sub.prototype.constructor = Sub;

 

// 在子类中保存超类的原型,防止子类与超类耦合

Sub.sup = Sup.prototype;

 

if(Sup.prototype.constructor === Object.prototype.constructor) {

// 检测超类原型的构造器是不是为原型自身

Sup.prototype.constructor = Sup;

}

 

}

测试代码如下:

// 上边大家定义2个类A和类B,大家目标是兑现B继承于A

function A(x) {

this.x = x;

this.getX = function(){

return this.x;

}

}

A.prototype.add = function(){

return this.x + this.x;

}

A.prototype.mul = function(){

return this.x * this.x;

}

// 构造函数B

function B(x){

A.call(this,x); // 继承构造函数A中的所有属性及办法

}

extend(B,A); // B继承于A

var b = new B(11);

console.log(b.getX()); // 11

console.log(b.add()); // 22

console.log(b.mul()); // 121

// in IE – “String”, in other – “Function”
alert(getClass.call(document.childNodes.item));

 

构造函数

注意:在封装函数中,有那样一句代码:Sub.sup = Sup.prototype;
大家现在可以来精晓下它的意思:

于是,正如我们地方提到的,在ECMAScript中的对象是因而所谓的构造函数来创建的。

 

Constructor is a function that creates and initializes the newly created
object.
构造函数是一个函数,用来创建并开始化新成立的对象。
目的创造(内存分配)是由构造函数的里边方法[[Construct]]负责的。该内部方法的表现是概念好的,所有的构造函数都是运用该措施来为新目的分配内存的。

譬如在B继承与A后,我给B函数的原型再定义一个与A相同的原型相同的主意add();

而初阶化是经过新建对象上下上调用该函数来管理的,那是由构造函数的内部方法[[Call]]来负总责的。

 

小心,用户代码只好在先导化阶段访问,即使在初始化阶段大家得以回来不一致的靶子(忽略第一等级创制的tihs对象):

如下代码

复制代码 代码如下:

 

function A() {
  // 更新新创造的对象
  this.x = 10;
  // 但回来的是例外的靶子
  return [1, 2, 3];
}
 
var a = new A();
console.log(a.x, a); undefined, [1, 2, 3]

extend(B,A); // B继承于A

var b = new B(11);

B.prototype.add = function(){

return this.x + “” + this.x;

}

console.log(b.add()); // 1111

引用15章函数——创制函数的算法小节,大家得以观察该函数是一个原生对象,包涵[[Construct]]
]和[[Call]]
]特性以及浮现的prototype原型属性——将来目标的原型(注:NativeObject是对于native
object原生对象的预订,在底下的伪代码中选用)。

 

复制代码 代码如下:

那就是说B函数中的add方法会覆盖A函数中的add方法;由此为了不掩盖A类中的add()方法,且调用A函数中的add方法;可以如下编写代码:

F = new NativeObject();
 
F.[[Class]] = “Function”
 
…. // 其它性质
 
F.[[Call]] = <reference to function> // function自身
 
F.[[Construct]] = internalConstructor // 普通的其中构造函数
 
…. // 别的性质
 
// F构造函数创立的目的原型
__objectPrototype = {};
__objectPrototype.constructor = F // {DontEnum}
F.prototype = __objectPrototype

 

[[Call]] ]是除[[Class]]特性(那里等同于”Function”
)之外区分对象的第一措施,由此,对象的其中[[Call]]特性作为函数调用。
那样的对象用typeof运算操作符的话重返的是”function”。可是它最紧如果和原生对象有关,有些情形的落到实处在用typeof获取值的是不等同的,例如:window.alert
(…)在IE中的效果:

B.prototype.add = function(){

//return this.x + “” + this.x;

return B.sup.add.call(this);

}

console.log(b.add()); // 22

复制代码 代码如下:

 

// IE浏览器中 – “Object”, “object”, 其余浏览器 – “Function”,
“function”
alert(Object.prototype.toString.call(window.alert));
alert(typeof window.alert); // “Object”

B.sup.add.call(this);
中的B.sup就隐含了协会函数A函数的指针,因此包蕴A函数的享有属性和艺术;因而可以调用A函数中的add方法;

其中方法[[Construct]]是经过动用带new运算符的构造函数来激活的,正如我们所说的那一个方式是背负内存分配和对象创设的。假若没有参数,调用构造函数的括号也得以简不难单:

 

复制代码 代码如下:

如上是完成持续的二种情势,类继承和原型继承,可是那些后续不可能继续DOM对象,也不扶助继承系统静态对象,静态方法等;比如Date对象如下:

function A(x) { // constructor А
  this.x = x || 10;
}
 
// 不传参数的话,括号也足以概括
var a = new A; // or new A();
alert(a.x); // 10
 
// 显式传入参数x
var b = new A(20);
alert(b.x); // 20

 

大家也了解,构造函数(起先化阶段)里的shis被安装为新创立的目的 。

// 使用类继承Date对象

function D(){

Date.apply(this,arguments); // 调用Date对象,对其引用,达成延续

}

var d = new D();

console.log(d.toLocaleString()); // [object object]

让我们琢磨一下目的创立的算法。

 

目标制造的算法

如上代码运行打印出object,大家得以见见使用类继承无法完成系统静态方法date对象的再而三,因为他不是简约的函数结构,对注脚,赋值和开头化都开展了打包,由此不可能持续;

内部方法[[Construct]] 的作为足以描述成如下:

 

复制代码 代码如下:

上面我们再来看看使用原型继承date对象;

F.[[Construct]](initialParameters):
 
O = new NativeObject();
 
// 属性[[Class]]被装置为”Object”
O.[[Class]] = “Object”
 
// 引用F.prototype的时候取得该对象g
var __objectPrototype = F.prototype;
 
// 如果__objectPrototype是对象,就:
O.[[Prototype]] = __objectPrototype
// 否则:
O.[[Prototype]] = Object.prototype;
// 这里O.[[Prototype]]是Object对象的原型
 
// 新创设对象开首化的时候使用了F.[[Call]]
// 将this设置为新创造的对象O
// 参数和F里的initialParameters是均等的
R = F.[[Call]](initialParameters); this === O;
// 这里R是[[Call]]的再次回到值
// 在JS里看,像这样:
// R = F.apply(O, initialParameters);
 
// 如果R是对象
return R
// 否则
return O

 

请小心多个基本点特色:

function D(){}

D.prototype = new D();

var d = new D();

console.log(d.toLocaleString());//[object object]

1.首先,新创设对象的原型是从当前时时函数的prototype属性获取的(那意味着同一个构造函数成立的多个成立对象的原型能够不一致是因为函数的prototype属性也足以差异)。
2.其次,正如我们地方提到的,要是在对象开头化的时候,[[Call]]回来的是目标,那刚好是用于所有new操作符的结果:

 

复制代码 代码如下:

咱俩从代码中见到,使用原型继承也无从继续Date静态方法;可是大家得以如下封装代码继承:

function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10 – 从原型上取得
 
// 设置.prototype属性为新目的
// 为啥显式评释.constructor属性将在底下表明
A.prototype = {
  constructor: A,
  y: 100
};
 
var b = new A();
// 对象”b”有了新属性
alert(b.x); // undefined
alert(b.y); // 100 – 从原型上得到
 
// 但a对象的原型仍旧可以收获原来的结果
alert(a.x); // 10 – 从原型上得到
 
function B() {
  this.x = 10;
  return new Array();
}
 
// 假使”B”构造函数没有回到(或重临this)
// 那么this对象就足以拔取,可是下面的气象重临的是array
var b = new B();
alert(b.x); // undefined
alert(Object.prototype.toString.call(b)); // [object Array]

 

让大家来详细摸底一下原型

function D(){

var d = new Date(); // 实例化Date对象

d.get = function(){ // 定义本地方法,直接调用Date对象的措施

console.log(d.toLocaleString());

}

return d;

}

var d = new D();

d.get(); // 2015/12/21 上午12:08:38

原型

 

各种对象都有一个原型(一些连串对象除了)。原型通讯是经过内部的、隐式的、不可直接访问[[Prototype]]原型属性来举办的,原型可以是一个目的,也可以是null值。

六:了然使用复制继承

属性构造函数(Property constructor)

 

下面的例证有有2个基本点的知识点,第三个是关于函数的constructor属性的prototype属性,在函数创立的算法里,大家了然constructor属性在函数创制阶段被设置为函数的prototype属性,constructor属性的值是函数自身的基本点引用:

复制继承的基本原理是:先规划一个空对象,然后拔取for-in循环来遍历对象的成员,将该目的的成员一个一个复制给新的空对象里面;这样就贯彻了复制继承了;如下代码:

复制代码 代码如下:

 

function A() {}
var a = new A();
alert(a.constructor); // function A() {}, by delegation
alert(a.constructor === A); // true

function A(x,y) {

this.x = x;

this.y = y;

this.add = function(){

return this.x + this.y;

}

}

A.prototype.mul = function(){

return this.x * this.y;

}

var a = new A(2,3);

var obj = {};

for(var i in a) {

obj[i] = a[i];

}

console.log(obj); // object

console.log(obj.x); // 2

console.log(obj.y); // 3

console.log(obj.add()); // 5

console.log(obj.mul()); // 6

一般在那种情景下,存在着一个误区:constructor构造属性作为新创造对象自我的属性是漏洞百出的,不过,正如我们所见到的的,那一个特性属于原型并且通过一连来访问对象。

 

因此持续constructor属性的实例,可以直接得到的原型对象的引用:

如上代码:先定义一个构造函数A,函数里面有2个属性x,y,还有一个add方法,该构造函数原型有一个mul方法,首先实列化下A后,再创设一个空对象obj,遍历对象一个个复制给空对象obj,从地方的打印效果来看,我们可以看来已经完成了复制继承了;对于复制继承,大家得以封装成如下方法来调用:

复制代码 代码如下:

 

function A() {}
A.prototype.x = new Number(10);
 
var a = new A();
alert(a.constructor.prototype); // [object Object]
 
alert(a.x); // 10, 通过原型
// 和a.[[Prototype]].x效果同样
alert(a.constructor.prototype.x); // 10
 
alert(a.constructor.prototype.x === a.x); // true

// 为Function扩充复制继承方法

Function.prototype.extend = function(o) {

for(var i in o) {

//把参数对象的分子复制给当下指标的构造函数原型对象

this.constructor.prototype[i] = o[i];

}

}

// 测试代码如下:

var o = function(){};

o.extend(new A(1,2));

console.log(o.x); // 1

console.log(o.y); // 2

console.log(o.add()); // 3

console.log(o.mul()); // 2

但请留心,函数的constructor和prototype属性在目的创设未来都可以重复定义的。在那种状态下,对象失去上边所说的机制。借使由此函数的prototype属性去编辑元素的prototype原型的话(添加新对象或修改现有对象),实例中校看到新添加的属性。

 

但是,如若大家彻底改变函数的prototype属性(通过分配一个新的对象),那本来构造函数的引用就是丢失,那是因为我们制造的靶子不包蕴constructor属性:

下边封装的恢弘继承方法中的this对象指向于当下实列化后的靶子,而不是指向于构造函数本身,因而要使用原型扩张成员来说,就需求利用constructor属性来指向它的构造器,然后通过prototype属性指向构造函数的原型;

复制代码 代码如下:

 

function A() {}
A.prototype = {
  x: 10
};
 
var a = new A();
alert(a.x); // 10
alert(a.constructor === A); // false!

复制继承有如下优点:

就此,对函数的原型引用须要手工恢复生机:

 

复制代码 代码如下:

  1. 它不可能继续系统焦点对象的只读方法和性质

function A() {}
A.prototype = {
  constructor: A,
  x: 10
};
 
var a = new A();
alert(a.x); // 10
alert(a.constructor === A); // true

 

留神就算手动复苏了constructor属性,和原先丢失的原型相比较,{DontEnum}特性没有了,也就是说A.prototype里的for..in循环语句不支持了,然则第5版正式里,通过[[Enumerable]]
特性提供了控制可枚举状态enumerable的能力。

  1. 假定目标数据极度多的话,那样一个个复制的话,性能是万分低的;

复制代码 代码如下:

 

var foo = {x: 10};
 
Object.defineProperty(foo, “y”, {
  value: 20,
  enumerable: false // aka {DontEnum} = true
});
 
console.log(foo.x, foo.y); // 10, 20
 
for (var k in foo) {
  console.log(k); // only “x”
}
 
var xDesc = Object.getOwnPropertyDescriptor(foo, “x”);
var yDesc = Object.getOwnPropertyDescriptor(foo, “y”);
 
console.log(
  xDesc.enumerable, // true
  yDesc.enumerable  // false
);

  1. 只有对象被实列化后,才能给遍历对象的成员和属性,相对来说不够利索;

显式prototype和隐式[[Prototype]]属性

 

普通,一个目的的原型通过函数的prototype属性显式引用是不得法的,他援引的是同一个目标,对象的[[Prototype]]属性:

4.
复制继承只是简短的赋值,所以假诺赋值的指标是引用类型的靶子的话,可能会设有一些副效用;如上大家见到有如上有的败笔,上边我们得以选拔clone(克隆的办法)来优化下:

a.[[Prototype]] —-> Prototype <—- A.prototype

 

此外,
实例的[[Prototype]]值确实是在构造函数的prototype属性上收获的。

基本思路是:为Function扩充一个措施,该方法可以把参数对象赋值赋值一个空构造函数的原型对象,然后实列化构造函数并回到实列对象,那样该对象就具有了该目标的持有成员;代码如下:

但是,提交prototype属性不会潜移默化已经创造对象的原型(只有在构造函数的prototype属性改变的时候才会影响到),就是说新创制的对象才有有新的原型,而已成立对象仍然引用到原来的旧原型(这些原型已经没办法被再被涂改了)。

 

复制代码 代码如下:

Function.prototype.clone = function(o){

function Temp(){};

Temp.prototype = o;

return Temp();

}

// 测试代码如下:

Function.clone(new A(1,2));

console.log(o.x); // 1

console.log(o.y); // 2

console.log(o.add()); // 3

console.log(o.mul()); // 2

// 在改动A.prototype原型在此之前的情形
a.[[Prototype]] —-> Prototype <—- A.prototype
 
// 修改之后
A.prototype —-> New prototype // 新对象会有着这么些原型
a.[[Prototype]] —-> Prototype // 率领的原来的原型上

例如:

复制代码 代码如下:

function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
A.prototype = {
  constructor: A,
  x: 20
  y: 30
};
 
// 对象a是经过隐式的[[Prototype]]引用从石油的prototype上收获的值
alert(a.x); // 10
alert(a.y) // undefined
 
var b = new A();
 
// 但新目的是从新原型上得到的值
alert(b.x); // 20
alert(b.y) // 30

因而,有的作品说“动态修改原型将震慑所有的对象都会有所新的原型”是荒唐的,新原型仅仅在原型修改以后的新创设对象上生效。

此处的最首要规则是:对象的原型是目的的创设的时候创设的,并且在此之后无法改改为新的目标,即使仍旧引用到同一个对象,可以经过构造函数的显式prototype引用,对象创设以后,只好对原型的性能进行添加或改动。

非标准的__proto__属性

不过,有些已毕(例如SpiderMonkey),提供了不正规的__proto__显式属性来引用对象的原型:

复制代码 代码如下:

function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
var __newPrototype = {
  constructor: A,
  x: 20,
  y: 30
};
 
// 引用到新对象
A.prototype = __newPrototype;
 
var b = new A();
alert(b.x); // 20
alert(b.y); // 30
 
// “a”对象使用的依然是旧的原型
alert(a.x); // 10
alert(a.y); // undefined
 
// 显式修改原型
a.__proto__ = __newPrototype;
 
// 现在”а”对象引用的是新目的
alert(a.x); // 20
alert(a.y); // 30

只顾,ES5提供了Object.getPrototypeOf(O)方法,该办法直接回到对象的[[Prototype]]属性——实例的始发原型。
然则,和__proto__比较,它只是getter,它不容许set值。

复制代码 代码如下:

var foo = {};
Object.getPrototypeOf(foo) == Object.prototype; // true

目的独立于构造函数 因为实例的原型独立于构造函数和构造函数的prototype属性,构造函数完结了上下一心的要紧办事(创立对象)未来可以去除。原型对象通过引用[[Prototype]]性能持续存在:

复制代码 代码如下:

function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
// 设置A为null – 呈现引用构造函数
A = null;
 
// 但要是.constructor属性没有更改的话,
// 仍旧得以经过它创设对象
var b = new a.constructor();
alert(b.x); // 10
 
// 隐式的引用也删除掉
delete a.constructor.prototype.constructor;
delete b.constructor.prototype.constructor;
 
// 通过A的构造函数再也无法创立对象了
// 但那2个目的依旧有友好的原型
alert(a.x); // 10
alert(b.x); // 10

instanceof操作符的特色 大家是通过构造函数的prototype属性来显示引用原型的,那和instanceof操作符有关。该操作符是和原型链一起工作的,而不是构造函数,考虑到那或多或少,当检测对象的时候屡次会有误解:

复制代码 代码如下:

if (foo instanceof Foo) {
  …
}

这不是用来检测对象foo是还是不是是用Foo构造函数创立的,所有instanceof运算符只须要一个对象属性——foo.[[Prototype]],在原型链中从Foo.prototype起首反省其是或不是存在。instanceof运算符是通过构造函数里的内部方法[[HasInstance]]来激活的。

让大家来探视这几个事例:

复制代码 代码如下:

function A() {}
A.prototype.x = 10;
 
var a = new A();
alert(a.x); // 10
 
alert(a instanceof A); // true
 
// 借使设置原型为null
A.prototype = null;
 
// …”a”仍然可以通过a.[[Prototype]]做客原型
alert(a.x); // 10
 
// 但是,instanceof操作符不可能再正常使用了
// 因为它是从构造函数的prototype属性来落实的
alert(a instanceof A); // 错误,A.prototype不是目的

单向,可以由构造函数来成立对象,但如果目的的[[Prototype]]特性和构造函数的prototype属性的值设置的是平等的话,instanceof检查的时候会重回true:

复制代码 代码如下:

function B() {}
var b = new B();
 
alert(b instanceof B); // true
 
function C() {}
 
var __proto = {
  constructor: C
};
 
C.prototype = __proto;
b.__proto__ = __proto;
 
alert(b instanceof C); // true
alert(b instanceof B); // false

原型能够存放方法并共享属性 大部主次里使用原型是用来囤积对象的法子、默许状态和共享对象的习性。

其实,对象足以拥有自己的情事 ,但方法一般是如出一辙的。
因而,为了内存优化,方法一般是在原型里定义的。
那象征,这些构造函数成立的拥有实例都可以共享找个艺术。

复制代码 代码如下:

function A(x) {
  this.x = x || 100;
}
 
A.prototype = (function () {
 
  // 起初化上下文
  // 使用额外的对象
 
  var _someSharedVar = 500;
 
  function _someHelper() {
    alert(‘internal helper: ‘ + _someSharedVar);
  }
 
  function method1() {
    alert(‘method1: ‘ + this.x);
  }
 
  function method2() {
    alert(‘method2: ‘ + this.x);
    _someHelper();
  }
 
  // 原型自身
  return {
    constructor: A,
    method1: method1,
    method2: method2
  };
 
})();
 
var a = new A(10);
var b = new A(20);
 
a.method1(); // method1: 10
a.method2(); // method2: 10, internal helper: 500
 
b.method1(); // method1: 20
b.method2(); // method2: 20, internal helper: 500
 
// 2个对象使用的是原型里平等的不二法门
alert(a.method1 === b.method1); // true
alert(a.method2 === b.method2); // true

读写属性

正如大家关系,读取和写入属性值是因而内部的[[Get]]和[[Put]]方式。那几个内部方法是透过性能访问器激活的:点标记法或者索引标记法:

复制代码 代码如下:

// 写入
foo.bar = 10; // 调用了[[Put]]
 
console.log(foo.bar); // 10, 调用了[[Get]]
console.log(foo[‘bar’]); // 效果等同

让我们用伪代码来看一下这个主意是什么行事的:

[[Get]]方法

[[Get]]也会从原型链中查询属性,所以经过对象也足以访问原型中的属性。

O.[[Get]](P):

复制代码 代码如下:

// 如若是协调的特性,就回去
if (O.hasOwnProperty(P)) {
  return O.P;
}
 
// 否则,继续分析原型
var __proto = O.[[Prototype]];
 
// 假诺原型是null,重返undefined
// 那是唯恐的:最顶层Object.prototype.[[Prototype]]是null
if (__proto === null) {
  return undefined;
}
 
// 否则,对原型链递归调用[[Get]],在各层的原型中查找属性
// 直到原型为null
return __proto.[[Get]](P)

请注意,因为[[Get]]在如下景况也会再次回到undefined:

复制代码 代码如下:

if (window.someObject) {
  …
}

此地,在window里没有找到someObject属性,然后会在原型里找,原型的原型里找,以此类推,倘使都找不到,按照定义就重临undefined。

只顾:in操作符也可以承担寻找属性(也会招来原型链):

复制代码 代码如下:

if (‘someObject’ in window) {
  …
}

那促进防止有些非同平日题材:比如就是someObject存在,在someObject等于false的时候,首轮检测就通可是。

[[Put]]方法

[[Put]]艺术可以制造、更新目的自我的性能,并且掩盖原型里的同名属性。

O.[[Put]](P, V):

复制代码 代码如下:

// 如果不可能给属性写值,就淡出
if (!O.[[CanPut]](P)) {
  return;
}
 
// 假如目的没有我的特性,就创造它
// 所有的attributes特性都是false
if (!O.hasOwnProperty(P)) {
  createNewProperty(O, P, attributes: {
    ReadOnly: false,
    DontEnum: false,
    DontDelete: false,
    Internal: false
  });
}
 
// 倘若属性存在就安装值,但不改变attributes特性
O.P = V
 
return;

例如:

复制代码 代码如下:

Object.prototype.x = 100;
 
var foo = {};
console.log(foo.x); // 100, 继承属性
 
foo.x = 10; // [[Put]]
console.log(foo.x); // 10, 自身性质
 
delete foo.x;
console.log(foo.x); // 重新是100,继承属性
请留心,无法遮住原型里的只读属性,赋值结果将忽略,这是由其中方法[[CanPut]]控制的。

// 例如,属性length是只读的,大家来覆盖一下length试试
 
function SuperString() {
  /* nothing */
}
 
SuperString.prototype = new String(“abc”);
 
var foo = new SuperString();
 
console.log(foo.length); // 3, “abc”的长度
 
// 尝试掩盖
foo.length = 5;
console.log(foo.length); // 依然是3

但在ES5的从严情势下,如若掩盖只读属性的话,会保存TypeError错误。

属性访问器

中间方法[[Get]]和[[Put]]在ECMAScript里是由此点符号或者索引法来激活的,倘使属性标示符是法定的名字的话,可以经过“.”来拜访,而索引方运行动态定义名称。

复制代码 代码如下:

var a = {testProperty: 10};
 
alert(a.testProperty); // 10, 点
alert(a[‘testProperty’]); // 10, 索引
 
var propertyName = ‘Property’;
alert(a[‘test’ + propertyName]); // 10, 动态属性通过索引的措施

那边有一个格外关键的特色——属性访问器总是利用ToObject规范来相比“.”左边的值。那种隐式转化和那句“在JavaScript中一切都是对象”有提到,(不过,当大家早就知道了,JavaScript里不是享有的值都是目的)。

假如对原始值进行性能访问器取值,访问此前会先对原始值进行对象包装(包罗原始值),然后通过包装的对象开展走访属性,属性访问之后,包装对象就会被删除。

例如:

复制代码 代码如下:

var a = 10; // 原始值
 
// 可是可以访问方法(如同对象一样)
alert(a.toString()); // “10”
 
// 其余,大家得以在a上成立一个心属性
a.test = 100; // 好像是没难点的
 
// 但,[[Get]]措施没有重回该属性的值,再次回到的却是undefined
alert(a.test); // undefined

那么,为啥整个例子里的原始值可以访问toString格局,而无法访问新创制的test属性呢?

答案很简短:

率先,正如大家所说,使用性质访问器将来,它早已不是原始值了,而是一个打包过的中游对象(整个例子是行使new
Number(a)),而toString方法那时候是经过原型链查找到的:

复制代码 代码如下:

// 执行a.toString()的原理:
 

  1. wrapper = new Number(a);
  2. wrapper.toString(); // “10”
  3. delete wrapper;

接下来,[[Put]]措施创制新特性时候,也是透过包装装的靶子开展的:

复制代码 代码如下:

// 执行a.test = 100的原理:
 

  1. wrapper = new Number(a);
  2. wrapper.test = 100;
  3. delete wrapper;

咱俩看到,在第3步的时候,包装的目的以及去除了,随着新创设的属性页被剔除了——删除包装对象自我。

然后拔取[[Get]]获取test值的时候,再一遍创设了打包对象,但此刻包装的对象已经没有test属性了,所以回来的是undefined:

复制代码 代码如下:

// 执行a.test的原理:
 

  1. wrapper = new Number(a);
  2. wrapper.test; // undefined

那种方法诠释了原始值的读取方式,别的,任何原始值若是日常用在拜访属性的话,时间功效考虑,都是一贯用一个对象替代它;与此相反,如果不日常访问,或者只是用来总括的话,到可以保存那种样式。

继承

大家精晓,ECMAScript是使用基于原型的委托式继承。链和原型在原型链里已经涉嫌过了。其实,所有寄托的落到实处和原型链的探寻分析都缩水到[[Get]]方法了。

借使你完全领悟[[Get]]方法,那JavaScript中的继承这些题材将不解自答了。

时不时在论坛上谈论JavaScript中的继承时,我都是用一行代码来体现,事实上,大家不必要创建任何对象或函数,因为该语言已经是根据继承的了,代码如下:

复制代码 代码如下:

alert(1..toString()); // “1”

我们曾经知道了[[Get]]措施和属性访问器的法则了,大家来探望都发出了什么:

1.先是,从原始值1,通过new Number(1)创制包装对象
2.然后toString方法是从那么些包裹对象上接轨取得的

为啥是三番五次的?
因为在ECMAScript中的对象足以有谈得来的性质,包装对象在那种情景下并未toString方法。
由此它是从原理里接二连三的,即Number.prototype。

留意有个神秘的地方,在上头的例子中的多少个点不是一个张冠李戴。第一点是象征小数部分,第三个才是一个性质访问器:

复制代码 代码如下:

1.toString(); // 语法错误!
 
(1).toString(); // OK
 
1..toString(); // OK
 
1[‘toString’](); // OK

原型链

让大家来得什么为用户定义对象创建原型链,格外不难:

复制代码 代码如下:

function A() {
  alert(‘A.[[Call]] activated’);
  this.x = 10;
}
A.prototype.y = 20;
 
var a = new A();
alert([a.x, a.y]); // 10 (自身), 20 (继承)
 
function B() {}
 
// 近来的原型链形式就是设置对象的原型为其余一个新对象
B.prototype = new A();
 
// 修复原型的constructor属性,否则的话是A了
B.prototype.constructor = B;
 
var b = new B();
alert([b.x, b.y]); // 10, 20, 2个都是后续的
 
// [[Get]] b.x:
// b.x (no) –>
// b.[[Prototype]].x (yes) – 10
 
// [[Get]] b.y
// b.y (no) –>
// b.[[Prototype]].y (no) –>
// b.[[Prototype]].[[Prototype]].y (yes) – 20
 
// where b.[[Prototype]] === B.prototype,
// and b.[[Prototype]].[[Prototype]] === A.prototype

那种措施有五个特性:

先是,B.prototype将包蕴x属性。乍一看那也许不对,你或许会想x属性是在A里定义的同时B构造函数也是如此期望的。即使原型继承正常状态是没难题的,但B构造函数有时候可能不要求x属性,与基于class的持续比较,所有的特性都复制到后代子类里了。

尽管,假若有须求(模拟基于类的屡次三番)将x属性赋给B构造函数创造的对象上,有一些方法,我们后来来体现其中一种艺术。

协助,那不是一个特征而是缺点——子类原型创设的时候,构造函数的代码也实践了,大家得以看出音信”A.[[Call]]
activated”突显了五遍——当用A构造函数创设对象赋给B.prototype属性的时候,其余一场是a对象创造自己的时候!

下边的例证相比较主要,在父类的构造函数抛出的百般:可能实际目标创造的时候需求检查呢,但很显明,同样的case,也就是就是应用那个父对象作为原型的时候就会出错。

复制代码 代码如下:

function A(param) {
  if (!param) {
    throw ‘Param required’;
  }
  this.param = param;
}
A.prototype.x = 10;
 
var a = new A(20);
alert([a.x, a.param]); // 10, 20
 
function B() {}
B.prototype = new A(); // Error

其它,在父类的构造函数有太多代码的话也是一种缺点。

化解这个“作用”和题材,程序员使用原型链的正儿八经形式(上面浮现),紧要目标就是在中等包装构造函数的创造,那几个包裹构造函数的链里包括必要的原型。

复制代码 代码如下:

function A() {
  alert(‘A.[[Call]] activated’);
  this.x = 10;
}
A.prototype.y = 20;
 
var a = new A();
alert([a.x, a.y]); // 10 (自身), 20 (集成)
 
function B() {
  // 或者利用A.apply(this, arguments)
  B.superproto.constructor.apply(this, arguments);
}
 
// 继承:通过空的高中级构造函数将原型连在一起
var F = function () {};
F.prototype = A.prototype; // 引用
B.prototype = new F();
B.superproto = A.prototype; // 显示引用到此外一个原型上, “sugar”
 
// 修复原型的constructor属性,否则的就是A了
B.prototype.constructor = B;
 
var b = new B();
alert([b.x, b.y]); // 10 (自身), 20 (集成)

留意,我们在b实例上创办了投机的x属性,通过B.superproto.constructor调用父构造函数来引用新成立对象的上下文。

俺们也修复了父构造函数在创设子原型的时候不要求的调用,此时,新闻”A.[[Call]]
activated”在必要的时候才会来得。

为了在原型链里重复同一的行事(中间构造函数创制,设置superproto,恢复生机原有构造函数),上面的沙盘可以封装成一个不行方面的工具函数,其目标是连续原型的时候不是依据构造函数的其实名称。

复制代码 代码如下:

function inherit(child, parent) {
  var F = function () {};
  F.prototype = parent.prototype
  child.prototype = new F();
  child.prototype.constructor = child;
  child.superproto = parent.prototype;
  return child;
}

因此,继承:

复制代码 代码如下:

function A() {}
A.prototype.x = 10;
 
function B() {}
inherit(B, A); // 连接原型
 
var b = new B();
alert(b.x); // 10, 在A.prototype查找到

也有成千成万语法格局(包装而成),但所有的语法行都是为着削减上述代码里的一举一动。

譬如,如若大家把高中级的构造函数放到外面,就足以优化后面的代码(因而,唯有一个函数被创制),然后重用它:

复制代码 代码如下:

var inherit = (function(){
  function F() {}
  return function (child, parent) {
    F.prototype = parent.prototype;
    child.prototype = new F;
    child.prototype.constructor = child;
    child.superproto = parent.prototype;
    return child;
  };
})();

出于目的的真实性原型是[[Prototype]]性能,这代表F.prototype可以很不难修改和选定,因为通过new
F制造的child.prototype可以从child.prototype的眼前值里获取[[Prototype]]:

复制代码 代码如下:

function A() {}
A.prototype.x = 10;
 
function B() {}
inherit(B, A);
 
B.prototype.y = 20;
 
B.prototype.foo = function () {
  alert(“B#foo”);
};
 
var b = new B();
alert(b.x); // 10, 在A.prototype里查到
 
function C() {}
inherit(C, B);
 
// 使用”superproto”语法糖
// 调用父原型的同名方法
 
C.ptototype.foo = function () {
  C.superproto.foo.call(this);
  alert(“C#foo”);
};
 
var c = new C();
alert([c.x, c.y]); // 10, 20
 
c.foo(); // B#foo, C#foo

留神,ES5为原型链标准化了这么些工具函数,这就是Object.create方法。ES3足以动用以下情势贯彻:

复制代码 代码如下:

Object.create ||
Object.create = function (parent, properties) {
  function F() {}
  F.prototype = parent;
  var child = new F;
  for (var k in properties) {
    child[k] = properties[k].value;
  }
  return child;
}

// 用法
var foo = {x: 10};
var bar = Object.create(foo, {y: {value: 20}});
console.log(bar.x, bar.y); // 10, 20

其余,所有模仿现在按照类的经典一连格局都是依照那么些规格已毕的,现在可以观察,它实际上不是依照类的后续,而是连接原型的一个很便宜的代码重用。

结论

本章内容已经很丰裕和详尽了,希望那个资料对你有用,并且消除你对ECMAScript的难点,若是您有任何难题,请留言,大家共同钻探。

网站地图xml地图