JavaScript 设计模式系列：基础知识

 　　基础知识

　　约定：在JavaScript业界，如果变量和方法是使用下划线，则表示该变量和方法是私有方法，只允许内部调用，第三方不应该去调用。

　　1>>双重“非”操作返回的是布尔型的数据：

　　　　var bool = !!num;

　　2>>函数是一等对象：

　　1：匿名函数

　　　　

 function(){...}

　　2：立即调用的匿名函数：

(function(){//立即调用的匿名函数
     var foo = 10;
     var bar = 2;
     alert(foo * bar);
})();

　　3：从外部传值的立即调用的匿名函数：

(function(foo,bar){
     alret(foo * bar);
}(10,2);

　　4:将立即调用的匿名函数的返回值赋给一个变量：

var baz = (function(foo,bar){
    return foo * bar;
})(10,2)

 　　5:创建闭包：

var baz;
(function(){
     var foo = 10;
     var bar = 2;
     baz = function(){
           return foo * bar;
     };
})();
baz();

闭包：

　　1. 最常用的方法是在函数内部返回一个函数，这个返回的函数可以访问内部变量。

      2. 主要就是上一点提到的读取函数内部变量，还有一个作用就是可以使这些变量一直保存在内存中。

如：变量n一直保存在内存中，每执行一次函数，就继续+1。

function  f(){
     var n =100;
     function f1(){
      alert(n+=1);
　　}
return f1;
}
var result = f();
result();//101
result();//102
result();//103

3>>封装：

继承：有两种继承方式

原型继承:通过将对象赋给函数的原型，然后将这个函数返回给一个对象。这样这个初始的对象就获得了开始时的那个对象的属性和方法，实现了继承。

//clone用来创建新的类Person对象
var clone = function(obj){
　　var f = function(){};
　　//**函数的原型对象是对象字面量,即函数的原型里有obj对象的属性和方法
　　f.prototype = obj;
　　return f;
}
//定义的对象字面量
var Person = {
　　name:'free',
　　getName:function(){
　　　　return this.name;
　　}
}
//创建子类 ,创建的继承对象可以调用父类的方法
var Programmer = clone(Person);
//继续继承
var Someone = clone(Programer);

类式继承：　　1.构建子类构造函数，同时将需要处理的参数传给父类构造函数。

　　　　　　　2.将父类的实例赋给子类的原型。

　　　　　　　3.修正子类的constructor属性。constructor属性指向构造函数属性，这里是　Person，修正为Programmer。

//构造函数，相当于超类
function Person(name){
      this.name = name;
}
//原型上加方法
Person.prototype.getName = function(){
      return this.name;
}
//实例化这个超类
var a = new Person('free');
alert(a.getName());//free

//再声明类，子类  
function Programmer(name,sex){
    //这个类要调用Person的构造函数，并将参数传进去
    Person.call(this,name);
    this.sex = sex;
}
//子类的原型对象等于超类的实例
Programmer.prototype = new Person();
//修正constructor属性,最终需要指向Programmer。
Programmer.prototype.constructor = Programmer;

Programmer.prototype.getSex = function(){
     return this.sex;
}

var test = new Programmer('free','male');
alert(m.getSex());//male
alert(m.getName());//free

 4>>接口：提供了一种用以说明一个对象应该具有哪些方法的手段。但并不规定这些方法应该如何实现。

　　既定的一批接口具有自我描述性，并能促进代码重用。接口可以告诉我们一个类实现了哪些方法，从而帮助其使用这个类。有利于测试和调试！可以很快发现类型错误。

　　实现一：用注释描述接口：在实现接口的方法时加入注释，没有验证！

interface Composite{//接口一
　　function add(child);
　　function remove(child);
　　function getChild(index);
}

interface FormItem{//接口二
　　function svae();
}
//创建类
var CompositeForm = function(id,method,action){
　　...
};
//实现接口中的方法
CompositeForm .prototype.add = function(child){
　　...
};

CompositeForm .prototype.remove= function(child){
　　...
};

CompositeForm .prototype.getChild= function(index){
    ...
};

CompositeForm .prototype.save= function(){
　　...
};

　　实现二：用属性检查模仿接口：所有的类都明确声明自己实现了那些接口，通过检查一个属性的值某个类自称实现了的接口。

 interface Composite{//接口一
 　　function add(child);
 　　function remove(child);
 　　function getChild(index);
 }
 
 interface FormItem{//接口二
 　　function svae();
 }

//声明类 实现了的接口
var CompositeForm = function(id,method,action){
       this.implementsInterfaces = ['Composite','FormItem'];
};

function addForm(formInstance){
       if(!implements(formInstance,'Composite','FormItem'){
               throw new Error("wrong!!");
        }
}

function implements(object){
       for(var i =1,i<arguments.length;i++){
              var interfaceName = arguments[i];
              var interfaceFound = false;
              for(var j=0;j<object.implementsInterfaces.length;j++ ){
　　　　　　　　　　if(object.implementsInterfaces[j] == interfaceName){
　　　　　　　　　　　　interfaceFound = true;
                     break;
　　　　　　　　　　}                      

  　　　　　　　}
　　　　　　　　if(!interfaceFound){
　　　　　　　　　　return false;
　　　　　　　　}
       }
　　　　return true;
}

　　通过调用addForm传入需要检查的对象，然后调用implements方法检查对象是否实现接口，只检查名称，没有检查对应的方法。

 　　

　　实现三：鸭式辩型模仿接口:类是否声明支持那些接口并不重要，只要它具有这些接口中的方法就行。

//接口一
var Composite = new Interface('Composite',['add','remove','getChild']);
//接口二
var FormItem = new Interface('FormItem',['svae']);

//实现接口的类
var CompositeForm = function(id,method,action){
      ...
};
//检验接口的方法
function addForm(formInstance){
       ensureImplements(formInstance,Composite,FormItem);
       ...
}

首先定义一个Interface类，然后在Interface类中定义ensureImplements方法！

Interface()类用于生成接口

//定义接口
var Interface = function(name,methods){
　　if(arguments.length != 2){//参数个数必须要大于两个
　　　　throw new Error("wrong1!!");
　　}
　　this.name = name;
　　this.methods = [];
　　for(var i = 0,len = methods.length;i<len;i++){
　　　　if(typeof methods[i] !== 'string'){//方法不是字符串，报错
　　　　　　throw new Error("wrong2!!");
　　　　　　}
　　　　this.methods.push(methods[i]);//将方法压入到this.methods数组中
　　}
};

　　ensureImplements方法用于确认方法被实现！

Interface.ensureImplements = function(object){
　　if(arguments.length <2){//检查参数个数
　　　　throw new Error("wrong3");
　　}
　　//检查参数个数
　　for(var i =1,len = arguments.length;i<len;i++){
　　　　var interface = arguments[i];
　　　　if(interface.constructor !== Interface){
　　　　　　throw new Error("wrong4");
　　　　}
　　　　for(var j = 0,methodsLen = interface.methods.length;j<methodsLen){
　　　　　　var method = interface.methods[j];
　　　　　　//检查方法类型和方法是否存在
　　　　　　if(!object[method] || typeof object[method] !== 'function'){
　　　　　　　　throw new Error("wrong5");
　　　　　　}
　　　　}
　　}
}