callee和caller

1
2
3
4
5
6
7
    var a=function(){
        console.log(arguments.callee);
    }
    var b=function(){
        a()
    }
    b();

1
2
3
ƒ (){
        console.log(arguments.callee);
    }

1
callee返回正在执行的函数本身的引用。callee是arguments的一个属性，这个属性是一个指针，指向这个拥有arguments对象的函数，（arguments是调用函数，那么这个callee就是调用函数的啦）

1
首先我们来说一个用callee解决的例子，阶乘的计算：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
复制代码  function factorial(num){
        if(num<=1){

        }else{
            return num*factorial(num-1);
        }
    }
  function factorial(num){
        if(num<=1){

        }else{
            return num*factorial(num-1);
        }
    }
上面的代码是用的是函数名。上述方法会增强耦合性，为了降低耦合性我们就用callee，而且无论引用函数的时候是什么名字都可以完成递归调用。看看callee：

复制代码   function factorial(num){
        if(num<=1){
            return 1;
        }else{
            return num*arguments.callee(num-1);
        }
    }
   function factorial(num){
        if(num<=1){
            return 1;
        }else{
            return num*arguments.callee(num-1);
        }
    }

复制代码caller：和他相似的我们还有一个caller，es5中规范化了另外一个函数对象属性caller；这个属性中保存着调用当前的函数的函数引用，如果是全局作用于中调用当前的函数就返回null
    function outer(){
        inner();
    }
    function inner(){
1.      alert(arguments.callee.caller);
  2.      alert(inner.caller)
        //上面的这两行是一样的1比2 的耦合性更松散
     3.   alert(arguments.caller);//undefined
//        3.这行代码在严格模式下会报错，但是非严格模式下就是undefined
    }
    outer();
//    说是定义argumnets.callee属性是为了分清qrguments.caller和caller
//    属性严格模式下不能为caller属性赋值，不然报错
caller：和他相似的我们还有一个caller，es5中规范化了另外一个函数对象属性caller；这个属性中保存着调用当前的函数的函数引用，如果是全局作用于中调用当前的函数就返回null
    
复制代码function outer(){
        inner();
    }
    function inner(){
1.      alert(arguments.callee.caller);
  2.      alert(inner.caller)
        //上面的这两行是一样的1比2 的耦合性更松散
     3.   alert(arguments.caller);//undefined
//        3.这行代码在严格模式下会报错，但是非严格模式下就是undefined
    }
    outer();
//    说是定义argumnets.callee属性是为了分清qrguments.caller和caller
//    属性严格模式下不能为caller属性赋值，不然报错
function outer(){
        inner();
    }
    function inner(){
1.      alert(arguments.callee.caller);
  2.      alert(inner.caller)
        //上面的这两行是一样的1比2 的耦合性更松散
     3.   alert(arguments.caller);//undefined
//        3.这行代码在严格模式下会报错，但是非严格模式下就是undefined
    }
    outer();
//    说是定义argumnets.callee属性是为了分清qrguments.caller和caller
//    属性严格模式下不能为caller属性赋值，不然报错
复制代码    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // b();//输出b函数。上面的例子中，是调用的b根据caller的特性就知道了答案。    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // a();//null(a在任何函数中被调用，即为顶层函数，输出的就是null)，上面的例子一中，a函数是在b中调用的所以不是顶层不反悔null，返回当前的调用就是b函数啦，而这个例子是在全局中调用的自然是null最后一个例子帮助深刻地理解顶层：要是a中也有了一个函数var c=function(){
    alert(c.caller);
}
var a=function(){
    c()
    alert(a.caller);
}
var b=function(){
    a();
}
a();这个例子在c中的alert出来的是a函数，原因是在a中调用。a中alert出来的是null，毕竟你是在全局中调用的a的函数。b函数相当于没有用。好了，这么多例子都不懂的话，可能是我写的太差吧。
复制代码    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // b();//输出b函数。上面的例子中，是调用的b根据caller的特性就知道了答案。    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // a();//null(a在任何函数中被调用，即为顶层函数，输出的就是null)，上面的例子一中，a函数是在b中调用的所以不是顶层不反悔null，返回当前的调用就是b函数啦，而这个例子是在全局中调用的自然是null最后一个例子帮助深刻地理解顶层：要是a中也有了一个函数var c=function(){
    alert(c.caller);
}
var a=function(){
    c()
    alert(a.caller);
}
var b=function(){
    a();
}
a();这个例子在c中的alert出来的是a函数，原因是在a中调用。
复制代码    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // b();//输出b函数。
    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // b();//输出b函数。
复制代码上面的例子中，是调用的b根据caller的特性就知道了答案。
上面的例子中，是调用的b根据caller的特性就知道了答案。
复制代码    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // a();//null(a在任何函数中被调用，即为顶层函数，输出的就是null)，上面的例子一中，a函数是在b中调用的所以不是顶层不反悔null，返回当前的调用就是b函数啦，而这个例子是在全局中调用的自然是null
    // var a=function(){
    //     alert(a.caller);
    // }//定义一个函数。里面输出a.caller
    // var b=function(){
    //     a();
    // }//定义一个函数调用那个a函数；
    // a();//null(a在任何函数中被调用，即为顶层函数，输出的就是null)，上面的例子一中，a函数是在b中调用的所以不是顶层不反悔null，返回当前的调用就是b函数啦，而这个例子是在全局中调用的自然是null

最后一个例子帮助深刻地理解顶层：要是a中也有了一个函数
复制代码var c=function(){
    alert(c.caller);
}
var a=function(){
    c()
    alert(a.caller);
}
var b=function(){
    a();
}
a();
var c=function(){
    alert(c.caller);
}
var a=function(){
    c()
    alert(a.caller);
}
var b=function(){
    a();
}
a();
这个例子在c中的alert出来的是a函数，原因是在a中调用。
复制代码a中alert出来的是null，毕竟你是在全局中调用的a的函数。b函数相当于没有用。
a中alert出来的是null，毕竟你是在全局中调用的a的函数。b函数相当于没有用。
复制代码好了，这么多例子都不懂的话，可能是我写的太差吧。
好了，这么多例子都不懂的话，可能是我写的太差吧。

1
2