Javascript 面向对象中的创建对象整合

对象字面量

new 构造函数

// new 构造函数
const obj = new Object()
obj.name = '雄安'

对象字面量

// 对象字面量
const person={
    name:'kk'
}

Object.create

//从一个实例对象生成另一个实例对象
// create() 中的参数a作为返回实例对象b的原型对象，在a中定义的属性方法，都能被b实例对象继承下来
const a = {
    getX:function(){
        console.log('X')
    }
}

const b = Object.create(a)

工厂模式

// 能创建多个类似的对象
// 缺点：没有解决对象识别的问题
function Person(name,age){
	const person = new Object()
    person.name = name
    person.age = age
    person.sayName=function(){
		console.log(this.name)
    }
    return person
}

const p1 = reson('zs',12)

构造函数模式

传统

// 缺点：浪费了内存空间
function Person(name,age){
    this.name = name
    this.age = age
    this.sayName=function(){
		console.log(this.name)
    }
}
const p1 = new Person('zs',12)

扩展模式

// 构造函数扩展模式
function Person(name,age){
	const o = new Object()
    this.name = name
    this.age = age
    this.sayName=sayName
}

// 定义多个全局函数，严重污染全局空间
function sayName(){
	console.log(this.name)
}

const p1 = new Person('zs',12)

寄生

// 寄生构造函数模式    结合工厂模式和构造函数
// 创建一个函数，函数内部实例化一个对象，并且将对象返回，在外部的使用new来实现实例化对象

// 缺点：1、定义了相同的方法，浪费内存空间  2、instanceof 和 prototype 没有意义
function Person(name,age){
	const person = new Object()
    person.name = name
    person.age = age
    person.sayName=function(){
		console.log(this.name)
    }
    return person
}

const p1 =new Person('mjj',18)

稳妥

// 稳妥构造函数模式 ：没有公共属性，并且它的方法也不引用 this 对象
function Person(name){
	const a = 10
    const person =new Object()
    // name就是属于私有属性
    person.sayName = function(){
		console.log(person)
        console.log(name)
    }
}

// p1 对象也叫稳妥对象
const p1 =Person('zs')

原型模式

// 缺点：在于引用类型值属性会被所有的实例对象共享并且修改

function Person(){}

/*	
	Person.prototype.name='zs'
	Person.prototype.age=28
	Person.prototype.sayName=function(){
		console.log(this.name)
	}
*/
Person.prototype={
	// 改变原型对象的同时要改变该原型的对象的 constructor 指向Person
    constructor:Person,
    name:'zs',
    age:28,
    sayName:function(){
		console.log(this.name)
	}
}

const p1 =new Person()

组合模式

// 原型模式 + 构造函数
function Person(name,age){
    // 定制当前对象自己的属性
    this.name = name
    this.age = age
    this.friends = ['lisi','wanwu']
}

// 定制各个实例对象的共享属性
Person.prototype={
	// 改变原型对象的同时要改变该原型的对象的 constructor 指向Person
    constructor : Person,
    sayName : function(){
			console.log(this.name)
    }
}

const p1 = new Person('wo',18)

动态原型模式

function Person(name,age){
    // 定制当前对象自己的属性
    this.name = name
    this.age = age
    this.friends = ['lisi','wanwu']
    if(typeof this.sayName !== 'function'){
        // 促使话原型对象上的属性
			Perons.prototype.sayName = function(){
				console.log(this.name)
    	}
    }
}

总结

• 字面量方式
  • 缺点：创建多个对象会造成沉余代码
• 工厂模式
  • 解决对象字面量方式创建对象的问题
  • 缺点：对象识别问题
• 构造函数模式
  • 解决工厂模式创建对象的问题
  • 缺点：方法重复被创建
• 原型模式
  • 解决构造函数模式创建对象的问题
  • 缺点：给当前实例定制的引用类型的属性会被所有的实例所共享
  • 特点：在于方法可以被共享
• 组合模式（构造函数和原型模式）
  • 构造函数模式：定义实例属性
  • 原型模式：用于定义方法和共享的属性，还支持向构造函数传递参数，该模式是使用最广泛，应用都最高的一种模式