常见设计模式
构造函数模式、混合模式、模块模式、工厂模式、单例模式、发布订阅模式的范例。
工厂模式 factory
// 抽象了创建具体对象的过程
function createPerson(name){
var person = {
name : name
};
person.sayName : function(){
console.log(this.name) // this指向调用的方法
}
return person
}
createPerson("yym") // 创建一个新的引用
createPerson("yangyu")
// 工厂模式
function createPerson(name, age, job){
var o = new Object()
o.name = name
o.age = age
o.job = job
o.sayName = function(){
console.log(this.name)
}
return o
}
var person1 = createPerson("yym", 15, "work")
var person2 = createPerson("yym三国杀", 15, "wo是rk")
console.log(person1)
// 根据接受的参数构建一个包含所有必要信息的对象,无数次调用这个函数
构造函数模式 constructor
与工厂模式的区别
- 没有显式的创建对象
- 直接将属性和方法赋给了this对象
- 没有return语句
new操作符经历的步骤
- 创建一个新对象
- 将构造函数的作用域赋给新对象(this只想这个新对象)
- 执行构造函数中的代码
- 返回新对象
function Person(name, age){ //创建对象
this.name = name
this.age = age
this.sayname = function(){ // 问题: 每个方法在实例时都要重新一遍
return this.name
}
// this.sayName = new Function("alert(this.name)")
}
var student = new Person('yym', 24) // new 一个新对象
console.log(students)
alert(student.constructor === Person) // true
alert(student instanceof Object) // true
-
原型模式
无论何时,只要创建了一个新函数,会根据一组特定的规则为该函数创建一个prototype属性,属性指向函数的原型对象,默认情况下,所有原型对象会自动获得一个constructor(构造函数)属性,是一个指向prototype属性所在函数的指针
function Person(){
}
Person.prototype.name = "yym"
Person.prototype.age = 24
Person.prototype.job = "work"
Person.prototype.sayName = function(){
console.log(this.name)
}
var person1 = new Person()
console.log(person1.sayName())
var person2 = new Person()
console.log(person2.sayName())
console.log(person1.sayName == person2.sayName) // true
//isPrototypeOf() 确定是否__proto__指向调用对象(Person.prototype)
alert(Person.prototype.isPrototypeOf(person1)) // true
// ES5新方法: Object.getPrototypeOf()
alert(Object.getPrototypeOf(person1) == Person.prototype) // true
// hasOwnProperty() 检查一个属性是存在于实例中,还是原型中
alert(person1.hasOwnProperty("name")) // false
// in操作符会在通过对象能够访问给定属性时返回true,无论实例
// 还是原型中
console.log("name" in person1) // true
person1.name = "yangyu"
console.log("name" in person1) // true
//使用for-in循环,返回的所有能够通过对象访问的,可枚举的属性
//既包括实例中的属性,也包括原型中的属性
// 要取得对象上所有的可枚举实例属性,可用ES5中的 Object.keys()
// 接受一个对象作为参数,返回一个字符串数组
var a = Object.keys(Person.prototype)
console.log(a) // ["name", "age", "job", "sayName"]
//想要得到所有实例属性,无论是否可枚举. Object.getOwnPropertyNames()
var key = Object.getOwnPropertyNames(Person.prototype)
console.log(key) //["constructor", "name", "age", "job", "sayName"]
混合模式 mixin
// 混合它的原型
//Person 构造函数
var Person = function(name, age){
this.name = name;
this.age = age;
}
Person.prototype.sayName = function(){
console.log(this.name)
}
// Student 构造函数
var Student = function(name, age, score){
Person.call(this, name, age) // 继承
this.score = score
}
// 原型式继承
// Student.prototype = Object.create(Person.prototype)
Student.prototype = create(Person.prototype)
function create(parentObj){
function F(){} // 空对象 构造函数
F.prototype = parentObj // 原型链上是传进来的对象
return new F() // 实例化构造函数
}
Student.prototype.sayScore = function(){
console.log(this.score);
}
var student = new Student("yym", 22, 100)
console.log(student)
// 原型式继承
// 函数内部创造一个临时构造函数,传入对象作为构造函数原型,返回实例
function object(o){
function F(){}
F.prototype = o
return new F()
}
单例模式 singleton
// 匿名函数
var People = (function(){ // 闭包
var instance;
function init(name){
return {
name: name
};
};
return {
createPeople : function(name){
if(!instance){
instance = init(name)
}
return instance;
}
};
}())
console.log(People.createPeople("yym")) // { name: "yym"}
console.log(People.createPeople("hello")) // { name: "yym"}
模块模式 module
// 通过闭包实现一个模块
var Person = (function(){
var name = "yym"
function sayName(){
console.log(name)
}; // 词法作用域
return {
name: name,
sayName: sayName
}
}())
发布订阅模式 publish / subscibe
var EventCenter = (function(){
var events = {}; // 存储所有的key/value 事件映射表
// 事件 回调函数
// 1. on做了什么 ('hello',function(){})
function on(evt,handler){
// events['hello'] = []
events[evt] = events[evt] || [];
/* events['hello'] = [{
handler: handler
}]
*/
events[evt].push({
handler: handler
});
}
//事件 所有的参数
// 2. fire怎么做 ('hello')
function fire(evt,args){
// hello 有的 不执行
if(!events[evt]){
return;
}
// 触发 handler
for(var i=0; i<events[evt].length; i++){
events[evt][i].handler(args);
}
}
function off(evt){
delete events[evt]
}
return {
on: on,
fire: fire,
off : off // 取消订阅
}
})()
EventCenter.on('hello', function(data){
console.log('Hello World');
});
EventCenter.fire('hello');
使用发布订阅模式写一个事件管理器，可以实现如下方式调用
Event.on('change', function(val){
console.log('change... now val is ' + val);
});
Event.fire('change', '饥人谷');
Event.off('changer');
var Event = (function (){
var events = {};
function on(evt, handle){
events[evt] = events[evt] || [];
events[evt].push({
handle:handle
});
};
function fire(evt,args){
if(!events[evt]){
return
}
for(var i=0; i<events[evt].length; i++){
events[evt][i].handle(args);
}
};
function off(evt){
delete events[evt]
};
return {
on: on,
fire: fire,
off: off
}
})()
Event.on('change', function(val){
console.log('change…… now val is' + val);
});
Event.fire('change', '饥人谷');
}
