javascript 模拟函数指针（2）

然而这种代码对runtime的上下文过于依赖，也就是说程序员必须给定当时fun1和fun2所在的命名空间，这样增大了程序的耦合度，也不利于维护。如果我们将changefun一同抽象进类定义中呢？即，我们希望在类定义之初就能交换fun1和fun2，对于一个还没有实例化的类中，情况将更加复杂，这时即便是fun1和fun2和changefun在同一个命名空间中，程序也无法按正确执行，比如：

var changefun = function(s1,s2){
    eval('var _o = '+s1+';'+s1+' = '+s2+';'+s2+' = _o;');   
};
var myClass1 = function(){
    var fun1 = function(str){
        alert('执行函数1，参数：'+str);
    };

    var fun2 = function(str){
        alert('执行函数2，参数'+str);
    };
    changefun('fun2','fun1');
    return {
        init:function(){
            changefun('fun2','fun1');       
        },
        fun1:fun1,
        fun2:fun2
    };
};
var a = new myClass1();
a.fun1('1');
a.fun2('2');
我们可以换个思路来看，与其让交换操作在changefun中执行，不如在类的命名空间中执行，我们重写changefun成：

var changefun = function(s1,s2){
    return 'var _o = '+s1+';'+s1+' = '+s2+';'+s2+' = _o;';   
};
让changefun返回一段可执行的代码，在命名空间中被执行，如此可以完成函数交换：

var changefun = function(s1,s2){
    return 'var _o = '+s1+';'+s1+' = '+s2+';'+s2+' = _o;';   
};
var myClass2 = function(){
    var fun1 = function(str){
        alert('执行函数1，参数：'+str);
    };
    var fun2 = function(str){
        alert('执行函数2，参数'+str);
    };
    eval(changefun('fun1','fun2'));   
    return {
        fun1:fun1,
        fun2:fun2
    };
};
var a = new myClass2();
a.fun1('1');
a.fun2('2');
这样changefun操作被包含在类的逻辑中,在类构造实例的时候即可执行,那我想适时调用闭包中changefun,可以使用

var changefun = function(s1,s2){
    return 'var _o = '+s1+';'+s1+' = '+s2+';'+s2+' = _o;';   
};
var myClass2 = function(){
    var fun1 = function(str){
        alert('执行函数1，参数：'+str);
    };

    var fun2 = function(str){
        alert('执行函数2，参数'+str);
    };
    return {
        init:function(){
            eval(changefun('this.fun1','this.fun2'));
        },
        fun1:fun1,
        fun2:fun2
    };
};
var a = new myClass2();
a.init();
a.fun1('1');
a.fun2('2');
这样的js代码就成功的剥离出三层来,基础代码,类代码和实例运行时代码,可以完成类似函数指针的功能而不受命名空间的影响.