javascript匿名函数应用

1.给指定对象新增一些属性的写法：

 /*给一个对象增加属性*/
     var myDate=(function(obj){
         obj.addName=function(name){
             this.name=name;
         }
         return obj;
     }(myDate||{}));
     /*此用myDate||{}这种方式确保传进去的是一个对象*/

2.重载指定对象的某个方法：

     var myDate2={name:'zhangsan',
                     addAge:function(age){
                         this.age=age;
                     }
                 };

     var myDate2=(function(obj){
         var oldAddAge=obj.addAge;//保留以前的方法，以后可以调用
         obj.addAge=function(age){
             oldAddAge(age+1);//这样写能重载myDate2的addAge方法吗？当然不能，这个age被加到了window对象上了。
         }
         return obj
     }(myDate2||{}));

     myDate2.addAge(10);

上面的写法是不行的，这样不能实现重载对象的某个方法，原因是对象原来的addAge方法中this指向了window，无法绑定到myDate2上面。

     var myDate2={name:'zhangsan',
                     addAge:function(age){
                         this.age=age;
                     }
                 };

     var myDate2=(function(obj){
         //var oldAddAge=obj.addAge;
         /*
         //这个地方不能再保留以前的函数供以后使用了，原因是addAge函数中使用了this，如果再次引用
         //this就指向了window对象。故重载函数中不能再调用原来的函数。
         */
         obj.addAge=function(age){
             this.age=age+10;
         }
         return obj;
     }(myDate2||{}));

     myDate2.addAge(10);

换成这种方式，可以重载对象中的addAge方法。

3.使用原型做一个简单加减运算：

     var calc=function(numx,operx){
         this.numx=numx;
         this.operx=operx;
     }
     calc.prototype={
         add:function(a,b){
             return a+b;
         },
         sub:function(a,b){
             return a-b;
         }
     };

     var c=(new calc).add(3,4);

4.函数，对象，constructor,prototype之间的关系：

 var FOO=function(){
             this.name='zhangsan';
         }
         FOO.prototype.getName=function(){
             return this.name;
         }

         var p=new FOO();
         var d={};
         console.log(p.constructor=== FOO);// true,用函数构造的对象，其构造函数是该函数本身
         console.log(d.constructor===Function);//flase
         console.log(d.constructor===Object);//true,直接生成的对象，其构造函数是Object
         console.log(FOO.constructor===Function);//true,函数本身的构造函数，是Function
         console.log(p.constructor.constructor===Function);//true,这个是一个传递
         console.log(FOO.prototype.constructor===FOO);//true,每个函数都有一个prototype,其prototype.constructor指向该函数本身

当重写函数的prototype后，由函数够造的对象的构造函数会发生变化：

         var BOO=function(){
             this.name='zhangsan';
         }
         BOO.prototype={age:function(age){
             this.age=age;
             }
         };//注意与上面的那种写法不一样，这种是重写，上面那种只是修改
         var b=new BOO();
         console.log(b.constructor===BOO);//false，由于重写了函数BOO的prototype导致constructor变化
         console.log(BOO.constructor===Function);//true
         console.log(BOO.prototype.constructor===BOO);//false，重写了prototype导致constructor变化

         var BOO=function(){
             this.name='zhangsan';
         }
         BOO.prototype={age:function(age){
             this.age=age;
             }
         };
         /*
         BOO.prototype=new Object({age:function(age){this.age=age;}});
         上面重写prototype相当于这种方法
         */
         var b=new BOO();
         console.log(b.constructor===Object);//true
         console.log(BOO.prototype.constructor===Object);//true

如何修改BOO的构造函数呢？

         var BOO=function(){
             this.name='zhangsan';
         }
         BOO.prototype={age:function(age){
             this.age=age;
             }
         };
         BOO.prototype.constructor=BOO;//重写BOO函数的prototype.constructor以后可以修复这个问题
         var b=new BOO();
         console.log(b.constructor===BOO);//true
         console.log(BOO.prototype.constructor===BOO);//true