>

工厂模式虽然解决了创建多个相似对象的问题,

- 编辑:澳门博发娱乐官网 -

工厂模式虽然解决了创建多个相似对象的问题,

寄生构造函数模式

这种模式的基本思想就是创建一个函数,该函数的作用仅仅是封装创建对象的代码,然后再返回新建的对象

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语句,可以重写调用构造函数时返回的值

这里还是要推荐下小编的web前端学习 群 : 687958461,不管你是小白还是大牛,小编我都欢迎,不定期分享干货,包括小编自己整理的一份最新的web前端资料和0基础入门教程,欢迎初学和进阶中的小伙伴。在不忙的时间我会给大家解惑。

动态原型模式

Person.prototype = {
name: 'Nicholas',
age: 29,
job: 'software engineer',
sayName: function () {
console.log(this.name);
}
};
//方式二对原型进行封装 设置成一个以对象字面量创建的新对象 其他都相同 但是constructor不再指向person
//如果必须要constructor指回原型,设置如下
Person.prototype = {
constructor:'person',
name: 'Nicholas',
age: 29,
job: 'software engineer',
sayName: function () {
console.log(this.name);
}
};
var person1 = new Person();
person1.name = 'Greg';
person1.sayName(); Greg
//删除定义在person1上的属性 继续查找原型属性
// delete person1.name;
person1.sayName(); //undefined
//检测某属性时定义在原型上还是当前对象上
// 使用hasOwnProperty方法 jsHint 单引 双引 交替用
console.log('person1.hasOwnProperty("name")' + person1.hasOwnProperty('name'));
//获得对象上所有的可枚举属性 使用 obj.keys()
var p1 = new Person();
p1.name = 'rachel';
p1.sayName = function () {
alert('p1.sayName()');
};
var p1keys = Object.keys(p1);
console.log('p1keys=' + p1keys);
//实例中的指针只指向原型,不指向构造函数
function Origin(){
}
var Ofriend= new Origin();
Origin.prototype ={
name:'Rachel',
age:'21'
};
console.log('Ofriend.name'+ Ofriend.name);
//若直接赋值给函数原型,此时指针指向原型的job,当前对象就可以查找到
// var friend = new Person();
// //注意此处是重写原型而不是构造函数
Person.prototype.job= 'Engineer';
console.log('friend.job ='+friend.job);

工厂模式

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')

可以无数次调用这个工厂函数,每次都会返回一个包含两个属性和一个方法的对象

工厂模式虽然解决了创建多个相似对象的问题,但是没有解决对象识别问题,即不能知道一个对象的类型

}

}

创建原型对象的两种方式

构造函数模式

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后会自动执行如下操作

  • 创建一个新对象
  • 这个新对象会被执行[[prototype]]链接
  • 这个新对象会绑定到函数调用的this
  • 返回这个对象

使用这个方式创建对象可以检测对象类型

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

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

但是使用构造函数创建对象,每个方法都要在每个实例上重新创建一次

console.log(this.name)

console.log(name)

组合使用原型模式和构造函数模式

原型模式的缺点:
1.它省略了为构造函数传递初始化参数这一环节,结果所有实例在 默认情况下都将取得相同的属性值。虽然这会在某种程度上带来一些不方便,但还不是原型的大问题。
2.原型模式的大问题是由其共享的本性所导致的。 原型中所有属性是被很多实例共享的,这种共享对于函数非常合适。对于那些包含基本值的属性倒 也说得过去,毕竟(如前面的例子所示),通过在实例上添加一个同名属性,可以隐藏原型中的对应属 性。然而,对于包含引用类型值的属性来说,问题就比较突出了。
且看下面例子:
Person.prototype = { constructor: Person, name : "Nicholas", age : 29, job : "Software Engineer", friends : ["Shelby", "Court"], sayName : function () { alert(this.name); } };

var person1 = new Person(); var person2 = new Person();

person1.friends.push("Van");

alert(person1.friends); //"Shelby,Court,Van"
alert(person2.friends); //"Shelby,Court,Van"
alert(person1.friends === person2.friends);
真可怕,所有的属性person1 person2都互通了
因此我们使用原型与构造函数混合的模式
所使用的方法是互通共享的,但数据储存的数组不会共享
套路如下:
function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.friends = ["Shelby", "Court"]; }

Person.prototype = { constructor : Person, sayName : function(){ alert(this.name); } }

var person1 = new Person("Nicholas", 29, "Software Engineer"); var person2 = new Person("Greg", 27, "Doctor");

person1.friends.push("Van"); alert(person1.friends); //"Shelby,Count,Van" alert(person2.friends); //"Shelby,Count" alert(person1.friends === person2.friends); //false alert(person1.sayName === person2.sayName); //true

原型模式

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中

console.log(this.name)

this.name=name

function Person() {}
Person.prototype.name ='Nicholas',
Person.prototype.job ='Engineer'

动态原型模式

动态原型模式将所有信息都封装在了构造函数中,初始化的时候,通过检测某个应该存在的方法时候有效,来决定是否需要初始化原型

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语句检查每一个属性和方法,只要检查一个就行

}

varperson1=newPerson('Jiang','Student')

JavaScript 创建对象的七种方式

2017/06/20 · JavaScript · 对象

原文出处: Xuthus Blog   

JavaScript创建对象的方式有很多,通过Object构造函数或对象字面量的方式也可以创建单个对象,显然这两种方式会产生大量的重复代码,并不适合量产。接下来介绍七种非常经典的创建对象的方式,他们也各有优缺点。

图片 1

o.job = job

}

组合使用构造函数模式和原型模式

这是使用最为广泛、认同度最高的一种创建自定义类型的方法。它可以解决上面那些模式的缺点

使用此模式可以让每个实例都会有自己的一份实例属性副本,但同时又共享着对方法的引用

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

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

o.name = name

}

稳妥构造函数模式

首先明白稳妥对象指的是没有公共属性,而且其方法也不引用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 收藏 评论

图片 2

function Person(name, job) {

sayName:function(){

原型中所有属性实例是被很多实例共享的,这种共享对于函数非常合适。对于那些包含基本值的属性也勉强可以,毕竟实例属性可以屏蔽原型属性。但是引用类型值,就会出现问题了

returno

console.log

functionPerson(){

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

}

图片 3

o.name=name

}

首先明白稳妥对象指的是没有公共属性,而且其方法也不引用this。

}

})

var person1 = Person('Jiang', 'student')

varperson1=Person('Jiang','student')

缺点

}

Person.prototype = {

friends:['Shelby','Court']

friends存在与原型中,实例person1和person2指向同一个原型,person1修改了引用的数组,也会反应到实例person2中

}

value: Person

varperson1=newPerson()

var person1 = createPerson('Jiang', 'student')

functionPerson(){

o.name = name

console.log(this.name)

return o

创建一个新对象

return o

console.log(person1.friends===person2.friends)//false

var person2 = createPerson('X', 'Doctor')

varo=newObject()

}

Person.prototype.sayName=function(){

this.job = job

functionPerson(name,job){

原型是一个非常重要的概念,在一篇文章看懂proto和prototype的关系及区别中讲的非常详细

this.friends=['Shelby','Court']

var person1 = new Person('Jiang', 'Student')

functionPerson(name,job){

其次,if语句检查的可以是初始化之后应该存在的任何属性或方法,所以不必用一大堆的if语句检查每一个属性和方法,只要检查一个就行

if(typeofthis.sayName!=='function'){

Person.prototype.job = 'student'

缺点

0、构造函数模式

console.log(this.name)

console.log(person1.friends) //["Shelby", "Court", "Van"]

console.log(person1.friends===person2.friends)// true

person1.sayName()

只有在sayName方法不存在的时候,才会将它添加到原型中。这段代码只会初次调用构造函数的时候才会执行。

这个新对象会绑定到函数调用的this

如果需要这个属性的话,可以手动添加

如果需要这个属性的话,可以手动添加

这个模式,除了使用new操作符并把使用的包装函数叫做构造函数之外,和工厂模式几乎一样

person1.sayName()

console.log(person2.friends)//["Shelby", "Court", "Van"]

o.name = name

person1instanceofObject// true

}

sayName:function(){

o.sayName = function() {

不过这种方式还是不够好,应为constructor属性默认是不可枚举的,这样直接设置,它将是可枚举的。所以可以时候,Object.defineProperty方法

使用原型,所有的属性都将被共享,这是个很大的优点,同样会带来一些缺点

varperson1=newPerson('Jiang','student')

首先明白稳妥对象指的是没有公共属性,而且其方法也不引用this。

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

本文由胜博发-前端发布,转载请注明来源:工厂模式虽然解决了创建多个相似对象的问题,