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