xml地图|网站地图|网站标签 [设为首页] [加入收藏]

深入之创建对象的多种方式以及优缺点,JavaScr

来源:http://www.ccidsi.com 作者:集成经验 人气:72 发布时间:2019-05-02
摘要:JavaScript 深远之成立对象的有余主意以及优缺点 2017/05/28 · JavaScript· 对象 原稿出处: 冴羽    根源《JavaScript高等程序设计》 JavaScript 深刻之继续的多样艺术和优缺点 2017/05/28 · JavaS

JavaScript 深远之成立对象的有余主意以及优缺点

2017/05/28 · JavaScript · 对象

原稿出处: 冴羽   

根源《JavaScript高等程序设计》

JavaScript 深刻之继续的多样艺术和优缺点

2017/05/28 · JavaScript · 继承

原来的书文出处: 冴羽   

写在前方

这篇小说解说创造对象的各个措施,以及优缺点。

然则注意:

那篇小说更像是笔记,因为《JavaScript高档程序设计》写得真是太好了!

  1. 厂子形式

写在前面

本文批注JavaScript各样承继格局和优缺点。

然则注意:

这篇文章更像是笔记,哎,再让本人感慨一句:《JavaScript高档程序设计》写得真是太好了!

壹. 厂子情势

function createPerson(name) { var o = new Object(); o.name = name; o.getName = function () { console.log(this.name); }; return o; } var person1 = createPerson('kevin');

1
2
3
4
5
6
7
8
9
10
11
function createPerson(name) {
    var o = new Object();
    o.name = name;
    o.getName = function () {
        console.log(this.name);
    };
 
    return o;
}
 
var person1 = createPerson('kevin');

缺陷:对象无法识别,因为具有的实例都指向3个原型

function createPerson(name) {

壹.原型链继承

function Parent () { this.name = 'kevin'; } Parent.prototype.getName = function () { console.log(this.name); } function Child () { } Child.prototype = new Parent(); var child1 = new Child(); console.log(child1.getName()) // kevin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function Parent () {
    this.name = 'kevin';
}
 
Parent.prototype.getName = function () {
    console.log(this.name);
}
 
function Child () {
 
}
 
Child.prototype = new Parent();
 
var child1 = new Child();
 
console.log(child1.getName()) // kevin

问题:

1.引用类型的性质被有着实例共享,比方:

function Parent () { this.names = ['kevin', 'daisy']; } function Child () { } Child.prototype = new Parent(); var child1 = new Child(); child1.names.push('yayu'); console.log(child1.names); // ["kevin", "daisy", "yayu"] var child2 = new Child(); console.log(child2.names); // ["kevin", "daisy", "yayu"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function Parent () {
    this.names = ['kevin', 'daisy'];
}
 
function Child () {
 
}
 
Child.prototype = new Parent();
 
var child1 = new Child();
 
child1.names.push('yayu');
 
console.log(child1.names); // ["kevin", "daisy", "yayu"]
 
var child2 = new Child();
 
console.log(child2.names); // ["kevin", "daisy", "yayu"]

2.在创制 Child 的实例时,无法向Parent传参

二. 构造函数形式

function Person(name) { this.name = name; this.getName = function () { console.log(this.name); }; } var person1 = new Person('kevin');

1
2
3
4
5
6
7
8
function Person(name) {
    this.name = name;
    this.getName = function () {
        console.log(this.name);
    };
}
 
var person1 = new Person('kevin');

优点:实例能够辨感觉二个一定的类别

缺点:每一遍创造实例时,各样方法都要被创制3回

    var o = new Object();

二.借出构造函数(精粹三番五次)

function Parent () { this.names = ['kevin', 'daisy']; } function Child () { Parent.call(this); } var child1 = new Child(); child1.names.push('yayu'); console.log(child1.names); // ["kevin", "daisy", "yayu"] var child2 = new Child(); console.log(child2.names); // ["kevin", "daisy"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function Parent () {
    this.names = ['kevin', 'daisy'];
}
 
function Child () {
    Parent.call(this);
}
 
var child1 = new Child();
 
child1.names.push('yayu');
 
console.log(child1.names); // ["kevin", "daisy", "yayu"]
 
var child2 = new Child();
 
console.log(child2.names); // ["kevin", "daisy"]

优点:

一.防止了引用类型的特性被全部实例共享

2.可以在 Child 中向 Parent 传参

举个例子:

function Parent (name) { this.name = name; } function Child (name) { Parent.call(this, name); } var child1 = new Child('kevin'); console.log(child1.name); // kevin var child2 = new Child('daisy'); console.log(child2.name); // daisy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function Parent (name) {
    this.name = name;
}
 
function Child (name) {
    Parent.call(this, name);
}
 
var child1 = new Child('kevin');
 
console.log(child1.name); // kevin
 
var child2 = new Child('daisy');
 
console.log(child2.name); // daisy

缺点:

艺术都在构造函数中定义,每趟创设实例都会创设一回方法。

2.一 构造函数情势优化

function Person(name) { this.name = name; this.getName = getName; } function getName() { console.log(this.name); } var person1 = new Person('kevin');

1
2
3
4
5
6
7
8
9
10
function Person(name) {
    this.name = name;
    this.getName = getName;
}
 
function getName() {
    console.log(this.name);
}
 
var person1 = new Person('kevin');

优点:化解了种种方法都要被重新创造的标题

缺点:那叫什么封装……

    o.name = name;

三.组合承继

原型链承继和经文延续双剑合璧。

function Parent (name) { this.name = name; this.colors = ['red', 'blue', 'green']; } Parent.prototype.getName = function () { console.log(this.name) } function Child (name, age) { Parent.call(this, name); this.age = age; } Child.prototype = new Parent(); var child1 = new Child('kevin', '18'); child1.colors.push('black'); console.log(child1.name); // kevin console.log(child1.age); // 18 console.log(child1.colors); // ["red", "blue", "green", "black"] var child2 = new Child('daisy', '20'); console.log(child2.name); // daisy console.log(child2.age); // 20 console.log(child2.colors); // ["red", "blue", "green"]

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 Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}
 
Parent.prototype.getName = function () {
    console.log(this.name)
}
 
function Child (name, age) {
 
    Parent.call(this, name);
    
    this.age = age;
 
}
 
Child.prototype = new Parent();
 
var child1 = new Child('kevin', '18');
 
child1.colors.push('black');
 
console.log(child1.name); // kevin
console.log(child1.age); // 18
console.log(child1.colors); // ["red", "blue", "green", "black"]
 
var child2 = new Child('daisy', '20');
 
console.log(child2.name); // daisy
console.log(child2.age); // 20
console.log(child2.colors); // ["red", "blue", "green"]

可取:融入原型链承袭和构造函数的独到之处,是 JavaScript 中最常用的再而三形式。

叁. 原型格局

function Person(name) { } Person.prototype.name = 'keivn'; Person.prototype.getName = function () { console.log(this.name); }; var person1 = new Person();

1
2
3
4
5
6
7
8
9
10
function Person(name) {
 
}
 
Person.prototype.name = 'keivn';
Person.prototype.getName = function () {
    console.log(this.name);
};
 
var person1 = new Person();

优点:方法不会再一次创制

缺点:1. 兼有的质量和措施都共享 二. 不可能开端化参数

    o.getName = function () {

4.原型式承接

function createObj(o) { function F(){} F.prototype = o; return new F(); }

1
2
3
4
5
function createObj(o) {
    function F(){}
    F.prototype = o;
    return new F();
}

就算 ES伍 Object.create 的模仿落成,将盛传的对象作为创立的对象的原型。

缺点:

包括引用类型的属性值始终都会共享相应的值,这一点跟原型链传承一样。

var person = { name: 'kevin', friends: ['daisy', 'kelly'] } var person1 = createObj(person); var person2 = createObj(person); person1.name = 'person1'; console.log(person2.name); // kevin person1.firends.push('taylor'); console.log(person2.friends); // ["daisy", "kelly", "taylor"]

1
2
3
4
5
6
7
8
9
10
11
12
13
var person = {
    name: 'kevin',
    friends: ['daisy', 'kelly']
}
 
var person1 = createObj(person);
var person2 = createObj(person);
 
person1.name = 'person1';
console.log(person2.name); // kevin
 
person1.firends.push('taylor');
console.log(person2.friends); // ["daisy", "kelly", "taylor"]

注意:修改person1.name的值,person2.name的值并未有发生更动,并不是因为person1person2有单独的 name 值,而是因为person1.name = 'person1',给person1增加了 name 值,并非修改了原型上的 name 值。

三.一 原型格局优化

function Person(name) { } Person.prototype = { name: 'kevin', getName: function () { console.log(this.name); } }; var person1 = new Person();

1
2
3
4
5
6
7
8
9
10
11
12
function Person(name) {
 
}
 
Person.prototype = {
    name: 'kevin',
    getName: function () {
        console.log(this.name);
    }
};
 
var person1 = new Person();

可取:封装性好了一点

缺点:重写了原型,丢失了constructor属性

        console.log(this.name);

5. 寄生式承袭

开创一个仅用于封装承继过程的函数,该函数在其间以某种情势来做增加对象,最终回来对象。

function createObj (o) { var clone = object.create(o); clone.sayName = function () { console.log('hi'); } return clone; }

1
2
3
4
5
6
7
function createObj (o) {
    var clone = object.create(o);
    clone.sayName = function () {
        console.log('hi');
    }
    return clone;
}

缺陷:跟借用构造函数形式同样,每一遍创立对象都会创制一次方法。

三.二 原型格局优化

function Person(name) { } Person.prototype = { constructor: Person, name: 'kevin', getName: function () { console.log(this.name); } }; var person1 = new Person();

1
2
3
4
5
6
7
8
9
10
11
12
13
function Person(name) {
 
}
 
Person.prototype = {
    constructor: Person,
    name: 'kevin',
    getName: function () {
        console.log(this.name);
    }
};
 
var person1 = new Person();

优点:实例能够透过constructor属性找到所属构造函数

症结:原型形式该有的后天不足依然有

    };

陆. 寄生组合式承袭

为了方便大家阅读,在那边再度一下整合承接的代码:

function Parent (name) { this.name = name; this.colors = ['red', 'blue', 'green']; } Parent.prototype.getName = function () { console.log(this.name) } function Child (name, age) { Parent.call(this, name); this.age = age; } Child.prototype = new Parent(); var child1 = new Child('kevin', '18'); console.log(child1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}
 
Parent.prototype.getName = function () {
    console.log(this.name)
}
 
function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}
 
Child.prototype = new Parent();
 
var child1 = new Child('kevin', '18');
 
console.log(child1)

组合承接最大的毛病是会调用三遍父构造函数。

一次是安装子类型实例的原型的时候:

Child.prototype = new Parent();

1
Child.prototype = new Parent();

二回在开立子类型实例的时候:

var child1 = new Child('kevin', '18');

1
var child1 = new Child('kevin', '18');

抚今追昔下 new 的效仿达成,其实在那句中,我们会推行:

Parent.call(this, name);

1
Parent.call(this, name);

在这边,我们又会调用了一次 Parent 构造函数。

故此,在那个事例中,倘诺大家打字与印刷 child一 目标,大家会发掘 Child.prototype 和 child壹 都有三个属性为colors,属性值为['red', 'blue', 'green']

那么大家该怎么样改正,防止那3次重复调用呢?

一旦大家不应用 Child.prototype = new Parent() ,而是直接的让 Child.prototype 访问到 Parent.prototype 呢?

探访如何落到实处:

function Parent (name) { this.name = name; this.colors = ['red', 'blue', 'green']; } Parent.prototype.getName = function () { console.log(this.name) } function Child (name, age) { Parent.call(this, name); this.age = age; } // 关键的三步 var F = function () {}; F.prototype = Parent.prototype; Child.prototype = new F(); var child1 = new Child('kevin', '18'); console.log(child一);

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
function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}
 
Parent.prototype.getName = function () {
    console.log(this.name)
}
 
function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}
 
// 关键的三步
var F = function () {};
 
F.prototype = Parent.prototype;
 
Child.prototype = new F();
 
 
var child1 = new Child('kevin', '18');
 
console.log(child1);

末段大家封装一下那个三番五次方法:

function object(o) { function F() {} F.prototype = o; return new F(); } function prototype(child, parent) { var prototype = object(parent.prototype); prototype.constructor = child; child.prototype = prototype; } // 当我们选用的时候: prototype(Child, Parent);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}
 
function prototype(child, parent) {
    var prototype = object(parent.prototype);
    prototype.constructor = child;
    child.prototype = prototype;
}
 
// 当我们使用的时候:
prototype(Child, Parent);

引用《JavaScript高端程序设计》中对寄生组合式承袭的陈赞就是:

那种办法的高效能呈现它只调用了贰次 Parent 构造函数,并且因而幸免了在 Parent.prototype 上边创设不要求的、多余的品质。与此同时,原型链还能保证不改变;因而,还是能够平常使用 instanceof 和 isPrototypeOf。开荒人士普及以为寄生组合式承接是援引类型最出彩的持续范式。

4. 结缘情势

构造函数情势与原型形式双剑合璧。

function Person(name) { this.name = name; } Person.prototype = { constructor: Person, getName: function () { console.log(this.name); } }; var person1 = new Person();

1
2
3
4
5
6
7
8
9
10
11
12
function Person(name) {
    this.name = name;
}
 
Person.prototype = {
    constructor: Person,
    getName: function () {
        console.log(this.name);
    }
};
 
var person1 = new Person();

可取:该共享的共享,该民用的村办,使用最分布的章程

症结:有的人正是愿意1切都写在1块儿,即更加好的封装性

    return o;

深深连串

JavaScript深切体系目录地址:。

JavaScript深远种类估计写十5篇左右,目的在于帮大家捋顺JavaScript底层知识,入眼教学如原型、功效域、实践上下文、变量对象、this、闭包、按值传递、call、apply、bind、new、承继等难题概念。

万一有不当可能不严刻的地点,请务必给予指正,11分感激。若是喜欢照旧具备启发,迎接star,对小编也是一种鞭策。

  1. JavaScirpt 深远之从原型到原型链
  2. JavaScript 深刻之词法成效域和动态成效域
  3. JavaScript 深刻之实施上下文栈
  4. JavaScript 深远之变量对象
  5. JavaScript 深刻之作用域链
  6. JavaScript 深远之从 ECMAScript 规范解读 this
  7. JavaScript 深刻之实行上下文
  8. JavaScript 深刻之闭包
  9. JavaScript 深切之参数按值传递
  10. JavaScript 深入之call和apply的模拟实现
  11. JavaScript 深切之bind的模仿实现
  12. JavaScript 长远之new的萧规曹随达成
  13. JavaScript 深刻之类数组对象与 arguments
  14. JavaScript 深切之创制对象的四种格局以及优缺点

    1 赞 3 收藏 评论

图片 1

4.一 动态原型方式

function Person(name) { this.name = name; if (typeof this.getName != "function") { Person.prototype.getName = function () { console.log(this.name); } } } var person1 = new Person();

1
2
3
4
5
6
7
8
9
10
function Person(name) {
    this.name = name;
    if (typeof this.getName != "function") {
        Person.prototype.getName = function () {
            console.log(this.name);
        }
    }
}
 
var person1 = new Person();

小心:使用动态原型情势时,无法用对象字面量重写原型

解释下何以:

function Person(name) { this.name = name; if (typeof this.getName != "function") { Person.prototype = { constructor: Person, getName: function () { console.log(this.name); } } } } var person壹 = new Person('kevin'); var person二 = new Person('daisy'); // 报错 并从未该方式person一.getName(); // 注释掉上边的代码,那句是能够举行的。 person二.getName();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function Person(name) {
    this.name = name;
    if (typeof this.getName != "function") {
        Person.prototype = {
            constructor: Person,
            getName: function () {
                console.log(this.name);
            }
        }
    }
}
 
var person1 = new Person('kevin');
var person2 = new Person('daisy');
 
// 报错 并没有该方法
person1.getName();
 
// 注释掉上面的代码,这句是可以执行的。
person2.getName();

为了表达这么些难题,如果发轫荐行var person1 = new Person('kevin')

若是对 new 和 apply 的平底实施进度不是很熟稔,能够阅读底部相关链接中的作品。

咱俩想起下 new 的落到实处步骤:

  1. 率先新建三个目标
  2. 接下来将目标的原型指向 Person.prototype
  3. 然后 Person.apply(obj)
  4. 回到那个目的

专注那年,回看下 apply 的落实步骤,会施行 obj.Person 方法,那年就能实行 if 语句里的剧情,注意构造函数的 prototype 属性指向了实例的原型,使用字面量情势平素覆盖 Person.prototype,并不会改动实例的原型的值,person1照旧是指向了原先的原型,而不是 Person.prototype。而此前的原型是从未有过 getName 方法的,所以就报错了!

假如你就是想用字面量格局写代码,能够品味下那种:

function Person(name) { this.name = name; if (typeof this.getName != "function") { Person.prototype = { constructor: Person, getName: function () { console.log(this.name); } } return new Person(name); } } var person1 = new Person('kevin'); var person2 = new Person('daisy'); person1.getName(); // kevin person2.getName(); // daisy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function Person(name) {
    this.name = name;
    if (typeof this.getName != "function") {
        Person.prototype = {
            constructor: Person,
            getName: function () {
                console.log(this.name);
            }
        }
 
        return new Person(name);
    }
}
 
var person1 = new Person('kevin');
var person2 = new Person('daisy');
 
person1.getName(); // kevin
person2.getName();  // daisy

}

5.一 寄生构造函数格局

function Person(name) { var o = new Object(); o.name = name; o.getName = function () { console.log(this.name); }; return o; } var person1 = new Person('kevin'); console.log(person1 instanceof Person) // false console.log(person1 instanceof Object) // true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function Person(name) {
 
    var o = new Object();
    o.name = name;
    o.getName = function () {
        console.log(this.name);
    };
 
    return o;
 
}
 
var person1 = new Person('kevin');
console.log(person1 instanceof Person) // false
console.log(person1 instanceof Object)  // true

寄生构造函数格局,作者个人以为应该那样读:

寄生-构造函数-格局,也便是说寄生在构造函数的壹种艺术。

也便是说打着构造函数的招牌挂羊头卖狗肉,你看创立的实例使用 instanceof 都心有余而力不足指向构造函数!

那般方法能够在非正规意况下行使。举例大家想成立一个享有额外措施的异样数组,可是又不想直接修改Array构造函数,我们能够如此写:

function SpecialArray() { var values = new Array(); for (var i = 0, len = arguments.length; i len; i ) { values.push(arguments[i]); } values.toPipedString = function () { return this.join("|"); }; return values; } var colors = new SpecialArray('red', 'blue', 'green'); var colors2 = SpecialArray('red2', 'blue2', 'green2'); console.log(colors); console.log(colors.toPipedString()); // red|blue|green console.log(colors2); console.log(colors2.toPipedString()); // red2|blue2|green2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function SpecialArray() {
    var values = new Array();
 
    for (var i = 0, len = arguments.length; i  len; i ) {
        values.push(arguments[i]);
    }
 
    values.toPipedString = function () {
        return this.join("|");
    };
    return values;
}
 
var colors = new SpecialArray('red', 'blue', 'green');
var colors2 = SpecialArray('red2', 'blue2', 'green2');
 
 
console.log(colors);
console.log(colors.toPipedString()); // red|blue|green
 
console.log(colors2);
console.log(colors2.toPipedString()); // red2|blue2|green2

你会发觉,其实所谓的寄生构造函数方式便是比厂子方式在创造对象的时候,多使用了三个new,实际上两者的结果是同样的。

然则小编只怕是目的在于能像使用普通 Array 同样选取 SpecialArray,固然把 SpecialArray 当成函数也如出一辙能用,不过那并不是作者的本心,也变得不美观。

在能够行使其余情势的事态下,不要选用那种形式。

而是值得1提的是,下面例子中的循环:

for (var i = 0, len = arguments.length; i len; i ) { values.push(arguments[i]); }

1
2
3
for (var i = 0, len = arguments.length; i  len; i ) {
    values.push(arguments[i]);
}

能够替换到:

values.push.apply(values, arguments);

1
values.push.apply(values, arguments);

var person1 = createPerson('kevin');

5.二 稳妥构造函数情势

function person(name){ var o = new Object(); o.sayName = function(){ console.log(name); }; return o; } var person1 = person('kevin'); person1.sayName(); // kevin person1.name = "daisy"; person1.sayName(); // kevin console.log(person1.name); // daisy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function person(name){
    var o = new Object();
    o.sayName = function(){
        console.log(name);
    };
    return o;
}
 
var person1 = person('kevin');
 
person1.sayName(); // kevin
 
person1.name = "daisy";
 
person1.sayName(); // kevin
 
console.log(person1.name); // daisy

所谓稳当对象,指的是未有集体性质,而且其艺术也不引用 this 的目的。

与寄生构造函数方式有两点分化:

  1. 新成立的实例方法不引用 this
  2. 不利用 new 操作符调用构造函数

得当对象最契合在一些有惊无险的境况中。

妥帖构造函数形式也跟工厂情势同样,无法甄别对象所属类型。

缺点:对象不能辨别,因为全体的实例都对准二个原型

深远连串

JavaScript深刻种类目录地址:。

JavaScript深入体系推测写10伍篇左右,意在帮大家捋顺JavaScript底层知识,珍视疏解如原型、效能域、试行上下文、变量对象、this、闭包、按值传递、call、apply、bind、new、承接等难处概念。

假定有荒唐恐怕不小心翼翼的地点,请务必给予指正,11分多谢。如若喜欢可能持有启发,迎接star,对小编也是1种鞭策。

  1. JavaScirpt 深刻之从原型到原型链
  2. JavaScript 深远之词法功用域和动态作用域
  3. JavaScript 深远之试行上下文栈
  4. JavaScript 深刻之变量对象
  5. JavaScript 深切之作用域链
  6. JavaScript 深刻之从 ECMAScript 规范解读 this
  7. JavaScript 长远之实践上下文
  8. JavaScript 深入之闭包
  9. JavaScript 深切之参数按值传递
  10. JavaScript 深远之call和apply的模仿达成
  11. JavaScript 深远之bind的模拟落成
  12. JavaScript 长远之new的模仿落成
  13. JavaScript 深远之类数组对象与 arguments

    1 赞 收藏 评论

图片 2

  1. 构造函数方式

function Person(name) {

    this.name = name;

    this.getName = function () {

        console.log(this.name);

    };

}

var person1 = new Person('kevin');

可取:实例能够识别为一个一定的品类

缺陷:每趟成立实例时,各样方法都要被创制三回

二.一 构造函数情势优化

function Person(name) {

    this.name = name;

    this.getName = getName;

}

function getName() {

    console.log(this.name);

}

var person1 = new Person('kevin');

亮点:化解了种种方法都要被重复创造的主题素材

缺点:这叫什么封装……

  1. 原型方式

function Person(name) {

}

Person.prototype.name = 'keivn';

Person.prototype.getName = function () {

    console.log(this.name);

};

var person1 = new Person();

可取:方法不会另行创立

缺陷:1. 装有的品质和章程都共享 二. 不能够开端化参数

③.一 原型方式优化

function Person(name) {

}

Person.prototype = {

    name: 'kevin',

    getName: function () {

        console.log(this.name);

    }

};

var person1 = new Person();

var person1 = new Person();

可取:封装性好了一点

缺点:重写了原型,丢失了constructor属性

三.二 原型情势优化

function Person(name) {

}

Person.prototype = {

    constructor: Person,

    name: 'kevin',

    getName: function () {

        console.log(this.name);

    }

};

本文由68399皇家赌场发布于集成经验,转载请注明出处:深入之创建对象的多种方式以及优缺点,JavaScr

关键词: 68399皇家赌场 JavaScript 日记本

上一篇:深入之变量对象,变量对象详解

下一篇:没有了

最火资讯