构造函数模式
利用原型继承的方式创建对象，以实现功能
function People(name,age) {
this.name = name;
this.age = age;
this.init();
}
People.prototype = {
sayHello:function () {
console.log("I'm" + this.name + ",hello!")
},
init:function () {
this.sayHello();
}
};
var xiaoming = new People("xiaoming",18);
混合模式
本质上也是利用原型继承的方式创建对象，但更加具象了功能的分层。
function People(name) {
this.name = name;
this.init();
}
People.prototype = {
sayHello:function () {
console.log("I'm" + this.name + ",hello!")
},
init:function () {
this.sayHello();
}
};
function Student(name,grade){
People.call(this,name); //让People中的this.name变为由Student传入的name
this.grade = grade;
}
Student.prototype= Object.create(People.prototype); //继承父对象
Student.prototype.sayGrade = function () {
console.log("my grade is" + this.grade);
};
Student.prototype.init = function () {
this.sayHello();
this.sayGrade();
};
var xiaoming = new Student("xiaoming","A");
模块模式
利用闭包，将私有变量保存，是一种很常见的封装方式，但是隐私性做的不够好。
var Student = (function () {
var name = "xiaoming"
var gender = "male";
function sayHello() {
console.log("my name is " + name);
}
function sayGender(){
console.log("my gender is " + gender);
}
return {
sayHello:sayHello,
sayGender:sayGender
}
})();
Student.sayGender();
工厂模式
建立一个功能丰富的函数，将参数传入函数以实现不同的功能
function People(gender){
function Male(gender){
this.gender=gender;
this.name="Kevin";
}
function Female(gender){
this.gender=gender;
this.name="Daisy";
}
var result=undefined;
if(gender.toLowerCase() == "male"){
result = new Male(gender);
}
if(gender.toLowerCase() == "female"){
result = new Female(gender);
}
return result;
}
People("male").name;
单例模式
利用闭包的思想保存私有变量，同时为了节省空间，利用构造函数的方法仅仅在调用时才创造新对象 。最重要的是，对象只能构造一次，无法通过反复调用函数更改属性。
var SingletonTester = (function () {
//参数：传递给单例的一个参数集合
function Singleton(args) {
//设置args变量为接收的参数或者为空（如果没有提供的话）
var options = args || {};
//设置name参数
this.name = 'SingletonTester';
//设置pointX的值
this.pointX = args.pointX || 6; //从接收的参数里获取，或者设置为默认值
//设置pointY的值
this.pointY = args.pointY || 10;
}
//实例容器
var instance;
return {
//获取实例的方法
//返回Singleton的实例
getInstance: function (args) {
if (!instance) {
instance = new Singleton(args);
}
return instance;
}
};
})();
var singletonTest = SingletonTester.getInstance({ pointX: 5 });
console.log(singletonTest.pointX); // 输出 5
var singletonTest = SingletonTester.getInstance({ pointX: 10 });
console.log(singletonTest.pointX); // 输出5
发布订阅模式
该模式用一个自己写的事件模块来连接多个独立模块，实现不同模块之间的解耦。例如，轮播跳转的同时实现文字的跳转，为了保持轮播模块的独立性，不想把关联文字跳转的代码写入轮播模块中，这时我们就可以用这种方法记录“轮播跳转”，然后在文字跳转这个模块中实现功能。类似于事件监听，时间管理器代码如下：
var EventManager = (function () {
//创建一个记录事件的集合
var events = {};
return {
//添加事件
on:function (item,func) {
events[item] = events[item] || [];
events[item].push(func);
return this;
},
//触发事件
fire:function (item) {
if(!events[item])return;
for(var i = 0; i < events[item].length; i++){
events[item][i]([].slice.call(arguments,1));
}
return this;
},
//删除事件
off:function (item) {
if(events[item]){
delete events[item];
}
return this;
}
}
})();
EventManager.on('text:change', function(val){
console.log('text:change... now val is ' + val);
});
EventManager.fire('text:change', '饥人谷'); //text:change... now val is 饥人谷
EventManager.off('text:change');
写一个函数createTimer，用于创建计时器，创建的计时器可分别进行计时「新增」
function createTimer() {
var clock;
var i = 0;
function start() {
clock = setInterval(function () {
i++;
console.log(i);
},1000)
}
function get() {
return i;
}
function end() {
clearInterval(clock);
}
return {
start:start,
get:get,
end:end
}
}
