JavaScript高级程序设计（第四版）对象与类的深入解析
对象创建方法
工厂模式通过封装对象生成逻辑实现复用，但无法识别对象类型。
function generateUser(username, userAge, jobTitle) {
const obj = new Object();
obj.name = username;
obj.age = userAge;
obj.position = jobTitle;
obj.greet = function() {
console.log(this.name);
};
return obj;
}
const userA = generateUser("John", 30, "Developer");
const userB = generateUser("Alice", 25, "Designer");构造函数模式通过特定命名规范区分普通函数，实现类型化对象创建。
function User(username, userAge, jobTitle){
this.name = username;
this.age = userAge;
this.position = jobTitle;
this.greet = function() {
console.log(this.name);
};
}
const userC = new User("Michael", 35, "Manager");
userC.greet();原型模式通过共享原型对象实现属性方法复用。
function Employee() {}
Employee.prototype.employeeName = "Sarah";
Employee.prototype.age = 28;
Employee.prototype.position = "Engineer";
Employee.prototype.greet = function() {
console.log(this.employeeName);
};
const emp1 = new Employee();
emp1.greet();
const emp2 = new Employee();
console.log(emp1.greet === emp2.greet);继承实现方式
原型链继承通过修改原型链实现属性方法传递。
function ParentType() {
this.hasProperty = true;
}
ParentType.prototype.getParentValue = function() {
return this.hasProperty;
};
function ChildType() {
this.hasSubProperty = false;
}
// 继承逻辑
ChildType.prototype = new ParentType();
ChildType.prototype.getSubValue = function () {
return this.hasSubProperty;
};
const instance = new ChildType();
console.log(instance.getParentValue());原型链继承存在引用类型共享问题，导致实例间数据污染。
function Parent() {
this.colors = ["red", "blue", "green"];
}
function Child() {}
Child.prototype = new Parent();
const inst1 = new Child();
inst1.colors.push("black");
console.log(inst1.colors);
const inst2 = new Child();
console.log(inst2.colors);继承优化方案
构造函数盗用通过调用父类构造函数实现参数传递。
function Parent(name){
this.userName = name;
}
function Child() {
// 调用父类构造函数
Parent.call(this, "Emily");
this.userAge = 22;
}
const instance = new Child();
console.log(instance.userName);
console.log(instance.userAge);组合继承结合原型链和构造函数优势，实现属性方法分离。
function Parent(name){
this.userName = name;
this.colors = ["red", "blue", "green"];
}
Parent.prototype.showName = function() {
console.log(this.userName);
};
function Child(name, age){
// 继承属性
Parent.call(this, name);
this.userAge = age;
}
// 继承方法
Child.prototype = new Parent();
Child.prototype.showAge = function() {
console.log(this.userAge);
};
const inst1 = new Child("David", 28);
inst1.colors.push("black");
console.log(inst1.colors);
inst1.showName();
inst1.showAge();原型式继承通过对象克隆实现属性共享。
const base = {
name: "Tom",
friends: ["Jerry", "Spike"]
};
const clone1 = Object.create(base);
clone1.name = "Jerry";
clone1.friends.push("Tyke");
const clone2 = Object.create(base);
console.log(base.friends);寄生式组合继承通过优化原型链减少冗余调用。
function Parent(name) {
this.userName = name;
this.colors = ["red", "blue", "green"];
}
Parent.prototype.showName = function() {
console.log(this.userName);
};
function Child(name, age){
Parent.call(this, name);
this.userAge = age;
}
// 优化原型链
Child.prototype = new Parent();
Child.prototype.constructor = Child;
Child.prototype.showAge = function() {
console.log(this.userAge);
};