菜单

JavaScript 创建对象的七种植艺术

2018年11月18日 - JavaScript

JavaScript 创建对象的七栽方式

2017/06/20 · JavaScript
· 对象

原文出处: Xuthus
Blog   

JavaScript创建对象的法门发生诸多,通过Object构造函数或对象字面量的方为堪创建单个对象,显然这简单栽办法会时有发生大量的双重代码,并无抱量产。接下来介绍七种非常经典的创建对象的措施,他们啊每有利弊。

图片 1

工厂模式

function createPerson(name, job) { var o = new Object() o.name = name
o.job = job o.sayName = function() { console.log(this.name) } return o }
var person1 = createPerson(‘Jiang’, ‘student’) var person2 =
createPerson(‘X’, ‘Doctor’)

1
2
3
4
5
6
7
8
9
10
11
function createPerson(name, job) {
  var o = new Object()
  o.name = name
  o.job = job
  o.sayName = function() {
    console.log(this.name)
  }
  return o
}
var person1 = createPerson(‘Jiang’, ‘student’)
var person2 = createPerson(‘X’, ‘Doctor’)

足多多不好调用这个厂函数,每次都见面回来一个含两只特性和一个主意的靶子

工厂模式则缓解了创办多只一般对象的题材,但是没有解决对象识别问题,即未可知掌握一个靶的型

JavaScript创建对象的措施产生好多,通过Object构造函数或对象字面量的不二法门呢得以创造单个对象,显然这点儿栽艺术会发大量的重复代码,并无吻合量产。接下来介绍七种非常经典的创建对象的办法,他们吗各出利弊。

构造函数模式

function Person(name, job) { this.name = name this.job = job
this.sayName = function() { console.log(this.name) } } var person1 = new
Person(‘Jiang’, ‘student’) var person2 = new Person(‘X’, ‘Doctor’)

1
2
3
4
5
6
7
8
9
function Person(name, job) {
  this.name = name
  this.job = job
  this.sayName = function() {
    console.log(this.name)
  }
}
var person1 = new Person(‘Jiang’, ‘student’)
var person2 = new Person(‘X’, ‘Doctor’)

莫显示的创建对象,使用new来调用是构造函数,使用new后会活动执行如下操作

运用这个主意创建对象可以检测对象类型

person1 instanceof Object // true person1 instanceof Person //true

1
2
person1 instanceof Object // true
person1 instanceof Person //true

可是使用构造函数创建对象,每个方法都使以每个实例上再也创设同浅

图片 2

原型模式

function Person() { } Person.prototype.name = ‘Jiang’
Person.prototype.job = ‘student’ Person.prototype.sayName = function() {
console.log(this.name) } var person1 = new Person()

1
2
3
4
5
6
7
8
function Person() {
}
Person.prototype.name = ‘Jiang’
Person.prototype.job = ‘student’
Person.prototype.sayName = function() {
  console.log(this.name)
}
var person1 = new Person()

拿信息一直抬高到原型对象上。使用原型的裨益是得给拥有的实例对象共享它所包含的属性与措施,不必在构造函数中定义对象实例信息。

原型是一个特别重大的定义,在平篇稿子看明白proto以及prototype的关系和界别中讲的坏详尽

双重简明的写法

function Person() { } Person.prototype = { name: ‘jiang’, job:
‘student’, sayName: function() { console.log(this.name) } } var person1
= new Person()

1
2
3
4
5
6
7
8
9
10
function Person() {
}
Person.prototype = {
  name: ‘jiang’,
  job: ‘student’,
  sayName: function() {
    console.log(this.name)
  }
}
var person1 = new Person()

以Person.prototype设置为当一个以目标字面量形式创建的靶子,但是会导致.constructor不以对Person了。

使用这种措施,完全重复写了默认的Person.prototype对象,因此 .constructor呢未会见满怀于这边

Person.prototype.constructor === Person // false

1
Person.prototype.constructor === Person  // false

一旦要是特性的言语,可以手动添加

function Person() { } Person.prototype = { constructor:Person name:
‘jiang’, job: ‘student’, sayName: function() { console.log(this.name) }
}

1
2
3
4
5
6
7
8
9
10
function Person() {
}
Person.prototype = {
  constructor:Person
  name: ‘jiang’,
  job: ‘student’,
  sayName: function() {
    console.log(this.name)
  }
}

唯独这种方式尚是不足够好,应为constructor属性默认是不可枚举的,这样一直装,它将凡可枚举的。所以可以下,Object.defineProperty方法

Object.defineProperty(Person.prototype, ‘constructor’, { enumerable:
false, value: Person })

1
2
3
4
Object.defineProperty(Person.prototype, ‘constructor’, {
  enumerable: false,
  value: Person
})

缺点

下原型,所有的性都用受共享,这是独好可怜的长处,同样会带一些弱点

原型中有着属性实例是叫过多实例共享的,这种共享于函数非常恰当。对于那些带有基本值的性质也勉强可以,毕竟实例属性可以遮挡原型属性。但是引用类型值,就见面起问题了

function Person() { } Person.prototype = { name: ‘jiang’, friends:
[‘Shelby’, ‘Court’] } var person1 = new Person() var person2 = new
Person() person1.friends.push(‘Van’) console.log(person1.friends)
//[“Shelby”, “Court”, “Van”] console.log(person2.friends)
//[“Shelby”, “Court”, “Van”] console.log(person1.friends ===
person2.friends) // true

1
2
3
4
5
6
7
8
9
10
11
12
function Person() {
}
Person.prototype = {
  name: ‘jiang’,
  friends: [‘Shelby’, ‘Court’]
}
var person1 = new Person()
var person2 = new Person()
person1.friends.push(‘Van’)
console.log(person1.friends) //["Shelby", "Court", "Van"]
console.log(person2.friends) //["Shelby", "Court", "Van"]
console.log(person1.friends === person2.friends) // true

friends存在与原型中,实例person1和person2因于与一个原型,person1修改了援的勤组,也会影响及实例person2受到

工厂模式

组成以构造函数模式以及原型模式

马上是采取最常见、认同度最高的一致种植创建于定义类型的不二法门。它好化解点那些模式之弱点

使是模式可吃每个实例都见面发好的如出一辙卖实例属性副本,但与此同时又共享着对法的援

这样的话,即使实例属性修改引用类型的价,也非会见潜移默化外实例的属于性值了

function Person(name) { this.name = name this.friends = [‘Shelby’,
‘Court’] } Person.prototype.sayName = function() {
console.log(this.name) } var person1 = new Person() var person2 = new
Person() person1.friends.push(‘Van’) console.log(person1.friends)
//[“Shelby”, “Court”, “Van”] console.log(person2.friends) //
[“Shelby”, “Court”] console.log(person1.friends === person2.friends)
//false

1
2
3
4
5
6
7
8
9
10
11
12
13
function Person(name) {
  this.name = name
  this.friends = [‘Shelby’, ‘Court’]
}
Person.prototype.sayName = function() {
  console.log(this.name)
}
var person1 = new Person()
var person2 = new Person()
person1.friends.push(‘Van’)
console.log(person1.friends)  //["Shelby", "Court", "Van"]
console.log(person2.friends) // ["Shelby", "Court"]
console.log(person1.friends === person2.friends) //false
function createPerson(name, job) {   var o = new Object()   o.name = name   o.job = job   o.sayName = function() {     console.log(this.name)   }   return o } var person1 = createPerson('Jiang', 'student') var person2 = createPerson('X', 'Doctor') 

动态原型模式

动态原型模式将富有信息都封闭装在了构造函数中,初始化的早晚,通过检测某个应该留存的方式上使得,来支配是否需要初始化原型

function Person(name, job) { // 属性 this.name = name this.job = job //
方法 if(typeof this.sayName !== ‘function’) { Person.prototype.sayName =
function() { console.log(this.name) } } } var person1 = new
Person(‘Jiang’, ‘Student’) person1.sayName()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function Person(name, job) {
  // 属性
  this.name = name
  this.job = job
 
  // 方法
  if(typeof this.sayName !== ‘function’) {
    Person.prototype.sayName = function() {
       console.log(this.name)
    }
  }
 
}
var person1 = new Person(‘Jiang’, ‘Student’)
person1.sayName()

惟有以sayName方法不存的下,才见面用她上加至原型中。这段代码只见面最先调用构造函数的时节才会实施。

事后原型已经完结初始化,不需以开什么修改了

这边对原型所举行的改,能够马上在拥有实例中得到反映

副,if语句检查的可以是初始化之后应该存在的其它性质或措施,所以不要因此同样怪堆的if语句检查各个一个性能与方法,只要检查一个尽管尽

可以多软调用这个厂函数,每次都见面回去一个富含两单特性和一个计的靶子

寄生构造函数模式

这种模式之为主考虑便是创建一个函数,该函数的图才是包裹创建对象的代码,然后还回去新建的靶子

function Person(name, job) { var o = new Object() o.name = name o.job =
job o.sayName = function() { console.log(this.name) } return o } var
person1 = new Person(‘Jiang’, ‘student’) person1.sayName()

1
2
3
4
5
6
7
8
9
10
11
function Person(name, job) {
  var o = new Object()
  o.name = name
  o.job = job
  o.sayName = function() {
    console.log(this.name)
  }
  return o
}
var person1 = new Person(‘Jiang’, ‘student’)
person1.sayName()

斯模式,除了行使new操作符并将施用的包裹函数叫做构造函数之外,和工厂模式几乎一模一样

构造函数如果不回来对象,默认为会回来一个初的目标,通过当构造函数的终极添加一个return语句,可以重写调用构造函数时回来的价值

厂子模式则缓解了创造多独一般对象的题材,但是尚未解决对象识别问题,即非可知知晓一个靶的档次

妥善构造函数模式

首先知道稳妥对象指的是无国有性质,而且其方式也未引用this。

妥善对象极其适合当片平安环境被(这些环境会禁止用this和new),或预防数据被其他应用程序改动时用

妥善构造函数模式及寄生模式类似,有零星接触不同:一是创建对象的实例方法无引用this,而是不使new操作符调用构造函数

function Person(name, job) { var o = new Object() o.name = name o.job =
job o.sayName = function() { console.log(name) } return o } var person1
= Person(‘Jiang’, ‘student’) person1.sayName()

1
2
3
4
5
6
7
8
9
10
11
function Person(name, job) {
  var o = new Object()
  o.name = name
  o.job = job
  o.sayName = function() {
    console.log(name)
  }
  return o
}
var person1 = Person(‘Jiang’, ‘student’)
person1.sayName()

跟寄生构造函数模式一样,这样创建出来的目标以及构造函数之间从来不啊关联,instanceof操作符对他们从没意义

1 赞 4 收藏
评论

图片 3

构造函数模式

function Person(name, job) {   this.name = name   this.job = job   this.sayName = function() {     console.log(this.name)   } } var person1 = new Person('Jiang', 'student') var person2 = new Person('X', 'Doctor') 

从不展示的创建对象,使用new来调用者构造函数,使用new后会见自动执行如下操作

应用是点子创建对象可以检测对象类型

person1 instanceof Object // true person1 instanceof Person //true 

而是利用构造函数创建对象,每个方法还设当每个实例上重新创设同软

原型模式

function Person() { } Person.prototype.name = 'Jiang' Person.prototype.job = 'student' Person.prototype.sayName = function() {   console.log(this.name) } var person1 = new Person() 

用消息直接助长到原型对象及。使用原型的好处是好为所有的实例对象共享它所蕴含的属性和法,不必在构造函数中定义对象实例信息。

再也简便易行的写法

function Person() { } Person.prototype = {   name: 'jiang',   job: 'student',   sayName: function() {     console.log(this.name)   } } var person1 = new Person() 

用Person.prototype设置也当一个为目标字面量形式创建的靶子,但是会导致.constructor不在指向Person了。

运用这种措施,完全重复写了默认的Person.prototype对象,因此
.constructor也无见面满怀于这边

Person.prototype.constructor === Person // false 

若是需要是特性的语,可以手动添加

function Person() { } Person.prototype = {   constructor:Person   name: 'jiang',   job: 'student',   sayName: function() {     console.log(this.name)   } } 

唯独这种措施尚是勿敷好,应为constructor属性默认是不可枚举的,这样直接装,它用是可枚举的。所以可以上,Object.defineProperty方法

Object.defineProperty(Person.prototype, 'constructor', {   enumerable: false,   value: Person }) 

缺点

应用原型,所有的性能都以吃共享,这是只好挺的优点,同样会带一些弱点

原型中所有属性实例是叫过多实例共享的,这种共享于函数非常适用。对于那些带有基本值的性质为勉强可以,毕竟实例属性可以遮挡原型属性。但是引用类型值,就见面起问题了

function Person() { } Person.prototype = {   name: 'jiang',   friends: ['Shelby', 'Court'] } var person1 = new Person() var person2 = new Person() person1.friends.push('Van') console.log(person1.friends) //["Shelby", "Court", "Van"] console.log(person2.friends) //["Shelby", "Court", "Van"] console.log(person1.friends === person2.friends) // true 

friends存在与原型中,实例person1和person2借助为与一个原型,person1修改了援的数组,也会见影响及实例person2遭

结使用构造函数模式及原型模式

眼看是采取最普遍、认同度最高的平等种创建于定义类型的法门。它可以解决地方那些模式的败笔

采取这模式可以被每个实例都见面发和好之同份实例属性副本,但又还要共享着对章程的援

这样的话,即使实例属性修改引用类型的价值,也不见面影响其它实例的属性值了

function Person(name) {   this.name = name   this.friends = ['Shelby', 'Court'] } Person.prototype.sayName = function() {   console.log(this.name) } var person1 = new Person() var person2 = new Person() person1.friends.push('Van') console.log(person1.friends)  //["Shelby", "Court", "Van"] console.log(person2.friends) // ["Shelby", "Court"] console.log(person1.friends === person2.friends) //false 

动态原型模式

动态原型模式将富有信息都封装于了构造函数中,初始化的时,通过检测某个应该有的法上使得,来控制是否需要初始化原型

function Person(name, job) {   // 属性   this.name = name   this.job = job    // 方法   if(typeof this.sayName !== 'function') {     Person.prototype.sayName = function() {        console.log(this.name)     }   }  } var person1 = new Person('Jiang', 'Student') person1.sayName() 

只有以sayName方法无在的时节,才见面以它填补加至原型中。这段代码只见面最先调用构造函数的当儿才会实施。

而后原型已经完成初始化,不需以召开呀修改了

这里对原型所做的改,能够马上在拥有实例中获得反映

从,if语句检查的可是初始化之后应该留存的另外性质或措施,所以不用为此同雅堆的if语句检查各个一个属性与方法,只要检查一个尽管尽

寄生构造函数模式

这种模式的核心思维就是开创一个函数,该函数的用意仅是包装创建对象的代码,然后再度返新建的目标

function Person(name, job) {   var o = new Object()   o.name = name   o.job = job   o.sayName = function() {     console.log(this.name)   }   return o } var person1 = new Person('Jiang', 'student') person1.sayName() 

本条模式,除了采取new操作符并把施用的包函数叫做构造函数之外,和厂模式几乎同一

构造函数如果不回来对象,默认为会回来一个新的对象,通过在构造函数的尾声添加一个return语句,可以重写调用构造函数时返回的值

妥善构造函数模式

第一知道稳妥对象指的是尚未集体性质,而且那个艺术为非引用this。

妥善对象极其可当有安环境面临(这些环境会禁止采取this和new),或预防数据为另外应用程序改动时以

稳构造函数模式与寄生模式类似,有半点接触不同:一凡创建对象的实例方法无引用this,而是不使用new操作符调用构造函数

function Person(name, job) {   var o = new Object()   o.name = name   o.job = job   o.sayName = function() {     console.log(name)   }   return o } var person1 = Person('Jiang', 'student') person1.sayName() 

暨寄生构造函数模式一样,这样创建出来的靶子及构造函数之间从未什么关系,instanceof操作符对他们没有意义

【编辑推荐】

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图