面向对象
- 动态语言: Javascript 是动态语言,即编译时不会对变量类型进行检查只有到了运行时才动态生成变量 。
- 接口: 实例 - 鸭子类型。两个类型之间有相同的接口即认为是相同的
- 多态:
- 原则“不变的隔离,变化的封装” 鸭子实例中 sound()接口是相同的,但是不同的动物有不同的sound实现,因此发声是变化的需隔离、不同动物的实现是变化的需封装在不同的对象中。 不同的对象就是多态。多态对外的表现就是把不变的暴露给其它对象。
- Javascript类型检查:
- 静态语言严格的类型检查,因此只能通过对象之间的继承来实现类型的一致性。实例 - 鸭子、鸡都能发生它们共同继承动物类。调用发声时传递的是动物这个超类 因此保证了类型的一致。
- 动态语言天然多态,不对类型进行检查,所以只要类型之间有相同的接口就可
-
封装。 静态语言依靠private, protected等方式实现封装;javascript没有这些机制。靠变量作用域来实现封装。实例: 使用闭包实现变量的私有化、访问的公有化
define(function (require, exports, module) {
var classObj = (
function () {
var _env;
var setEnv = function (name) {
_env = name;
};
var getEnv = function () {
return _env;
};
return {
setEnv: setEnv,
getEnv: getEnv
}
}
)();
module.exports = classObj;
});
单例模式:
简单单例 -
var div = function (name) {
this.instance =null;
this.name = name;
};
div.prototype.getName= function () {
alert(this.name);
}
div.getSingle = function () {
if(!this.instance) {
this.instance = new div();
}
return this.instance;
};
// Main方法
$scope.testMethod = function () {
var c = div.getSingle();
var d = div.getSingle();
alert(c==d);
};
以上单例用户使用时需要知道getSingle方法是为了单例而设计的方法。现在实现一种透明单例
透明代理
var div = (function () {
var instance = null;
var createDiv = function (html) {
if(instance) return instance;
this.html = html;
this.init();
instance = this;
return instance;
};
createDiv.prototype.init = function () {
var div = document.createElement('div');
div.innerHTML=this.html;
document.body.appendChild(div);
};
return createDiv;
})();
$scope.testMethod = function () {
// 使用 New的方式 使用 单例
var c = new div('ab c');
var d = new div('12 3');
alert(c == d);
};
改进版的透明代理, 构造函数即负责init有负责实例。 职责非单一 而且复用性差,使用代理的方式改进
var div = (function () {
var createDiv = function (html) {
this.html = html;
this.init();
};
createDiv.prototype.init = function () {
var div = document.createElement('div');
div.innerHTML = this.html;
document.body.appendChild(div);
};
return createDiv;
})();
var divProxy = (function () {
var instance=null;
return function (html) {
if(instance) return instance;
instance = new div(html);
return instance;
}
})();
$scope.testMethod = function () {
var c = new divProxy('ab c');
var d = new divProxy('12 3');
alert(c == d);
};
策略模式
策略模式指的是 定义一系列的算法,把他们封装起来。 算法使用是在一个统一的Context中。
var stratogyA= function () {
};
stratogyA.prototype.getSalary = function (salary) {
return salary*2;
};
var stratogyB= function () {
};
stratogyA.prototype.getSalary = function (salary) {
return salary*3;
};
var context = function (stratogy) {
this.strategy=stratogy;
};
context.prototype.calculateSalary= function (orgin) {
return this.strategy.getSalary(orgin);
};
$scope.testMethod = function () {
var str = new stratogyA();
var c = new context(str);
var l = c.calculateSalary(1000);
alert(l);
};