day6(12.21)函数表达式

函数表达式的特征

使用函数表达式递归

使用闭包定义私有变量


定义函数的方式有两种:函数声明,类似变量声明用var,函数声明用function,如 function fun1(arg0,arg1){ }

同样类似于变量声明提升,函数也会有函数声明提升。具体是:可以先执行函数,如fun1(),然后在定义函数function fun1(){ }. 有name属性,返回函数名。

第二种函数定义的方式是函数表达式,var fun1 = function(arg0,arg1){},这个就是看起来的常规的变量表达式赋值,因此就是函数表达式。function后面没有名字,所以也叫匿名函数或者拉姆达函数。把函数当一个值来使用的时候,都可以使用匿名函数。

表达式没有声明提前,所以先执行后定义会有错误的。匿名函数是没有name属性的。

if语句中可以有函数表达式,但是不能有函数声明,因为声明会提前,if-else中两个声明,都提前了,用哪一个呢?不同浏览器会有不同操作。大部分用else中的声明。如果是函数表达式就没有问题了。

函数可以赋值给变量,同样也可以作为另外一个函数的返回值。

递归

递归函数就是在于一个函数中,通过名字调用自身的情况下构成。如递归阶乘函数中return num*fun(num-1)

但是有一个问题,如果fun1是一个递归函数,var fun2=fun1 ; fun1=null ; 这时候执行fun2是导致错误。引用类型,fun1指向的对象已经是空了,fun2指向相同的地址,同样也是空,所以不能执行。

有两个方法解决这个问题:

arguments.callee: 定义函数中,比如递归,返回的是  return num*arguments.callee(num-1);  callee是指被调用的函数。将通过使用arguments.callee代替函数名,这种方式能保证比使用函数名保险。但是严格模式下不支持这个属性。因此还可以使用命名函数表达式达成相同的结果。如下

var fun = (function f(num){return num*f(num-1)})   ,就是通过创建了一个名为f()的命名函数表达式形式,然后将其赋值给fun。即使吧函数赋值给另一个变量,函数的名字f仍然有效,所以递归调用照样能完成。这样改变fun 为null也不会出错,严格模式下同样支持。

闭包:

有权访问另一个函数作用域中的变量的函数。创建闭包常见就是在一个函数中,创建另一个函数。比如函数fun1中有一个变量 var a,在函数fun1中定义另外一个函数fun2,因为内部函数fun2的作用域链包含了外部函数fun1()的作用域链,所以fun2可以访问fun1中的a。无论内部函数是匿名函数还是命名函数。 

一般情况下,全局执行环境始终存在,执行函数fun1的时候,作用域链有两个变量对象,本地和全局变量对象,放在scope中,scope是一个指针列表,只引用,但不包含变量对象。指向这两个变量对象,这两个变量对象又分别包含对应环境中的变量和函数。如果函数执行完了之后,局部活动对象会被销毁,只保留全局的变量对象。但是fun1中加入了访问fun1中变量a的函数fun2,成了闭包,就有所不同了。内部函数会将外部函数的变量对象添加到自己的作用域链中,如果在fun1中返回fun2,那么fun2中初始化为包含fun1函数的活动对象和全局变量对象。那么fun2就可以访问fun1中的变量了,另外由于fun2作用域链仍然在引用这个活动对象,所以fun1的活动对象不会被销毁。也就是fun2返回后,执行环境的作用域链被销毁了,但是活动对象仍然留在内存中,一直到fun2函数被销毁之后,fun1的活动对象才会被销毁。

自己的理解:闭包是为了访问外部函数的变量,所以一般要返回,比如在fun1中返回fun2,如果var fun = fun1,这时候返回的fun2的作用域链中包含fun1中的变量a,所以执行fun的时候,fun1活动对象仍在内存中,一直到fun2被销毁,fun1的活动对象才会被销毁。

由于闭包会携带包含它的函数的作用域,因此比其他函数占用更多内存。



 this对象 

 this对象时在运行时基于函数的执行环境绑定:1、在全局函数中,this指的是window;2、函数当某个对象方法使用的时候,等于这个对象;3、new一个对象的时候,this指的是新建的那个对象;4、匿名函数的执行环境具有全局性,this对象通常指向window。5、衍生:注意在外部函数中,返回一个匿名函数,这个匿名函数访问了外部函数的某变量,这时候就是闭包了。闭包里面的this指的也是window,可能不是那么容易认出。比如

 var name = “The Window”; 

var Object = {

         name:“my object”; 

         getNameFunction:function(){ 

                 return function(){ 

                         return this.name ; } } };

 alert(object.getNameFunc()()); // The Window 

返回的匿名函数中的this并不是Object,而是window,根据“this对象时在运行时基于函数的执行环境绑定”更容易理解,函数getNameFunction返回的是一个匿名函数,这个匿名函数执行的时候tihs执行执行环境,当然是window了。 

 var name = “The Window”; 

var Object = {

         name:“my object”;

         getNameFunction:function(){ 

                 var that = this; 

                 return function(){ 

                         return that.name ; } } }; 

alert(object.getNameFunc()()); // my object 

在函数返回之后,that仍然引用着object,所以调用alert(object.getNameFunc()());返回的是my object。 对象Object中的tihs指的是Object啊,但是Object函数中的this要等到执行时候才能确定。

 var name = “The Window”; 

var Object = { 

name:“my object”;

getNameFunction:function(){ return this.name ; } }; 

object.getName()返回的是my object,这里的函数没有返回,所以执行环境是object啦。 闭包可能会有内存泄漏的问题,

 function fun1(){ 

     var a = document.getElementById(“someElement”); 

     a.onclick = function(){ alert(a.id)     

 } } 

创建了一个a事件处理程序的闭包,这个闭包又创建了一个循环引用。所以a的内存无法回收,如下修改: 

 function fun1(){ 

        var a = document.getElementById(“someElement”); 

        var id = element.id;

        a.onclick = function(){ 

            alert(id) //这里的闭包就不直接引用a了。消除了循环引用 

a = null; // 包含函数中活动对象中仍然有一个对a的引用,所以设置为null。消除对DOM对象的引用。

 } 

 模仿块级作用域

没有块级作用域,所以块语句中定义的变量,实际上就是在包含函数中创建。比如


i虽然在块语句中,但是实际上是在函数中定义的。

匿名函数可以模仿块级作用域, 称作私有作用域: (function(){ //这里是块级作用域 })();

第一个括号是表达一个函数表达式,第二个是立刻执行。

推导:var someFunction = function(){ //这里是块级作用域 }; someFunction(); JavaScript 将 function 关键字当作一个函数声明的开始,而函数声明后面不能跟圆括号。然而,函数表达式的后面可以跟圆括号。因此有   (function(){ //这里是块级作用域 })();

无论在什么地方,只要临时需要一些变量,就可以使用私有作用域,例如:

function outputNumbers(count){

    (function () {

        for (var i=0; i < count; i++){ alert(i); }

})(); // 这时候i就是私有作用域里了,结束后会销毁。

alert(i); //导致一个错误! }

这种技术经常在全局作用域中被用在函数外部,从而限制向全局作用域中添加过多的变量和函数。


私有变量

任何在函数中定义的变量,都可以认为是私有变量,因为不能在函数的外部访问这些变量。 私有变量包括函数的参数、局部变量和在函数内部定义的其他函数

通过闭包,有权访问私有变量和私有函数的公有方法称为特权方法。

模块模式和增强模块模式看不懂啊。


小结

使用函数表达式可以无须对函数命名, 从而实现动态编程。匿名函数,也称为拉姆达函数。函数表达式的特点。

  函数表达式不同于函数声明。函数声明要求有名字,但函数表达式不需要。没有名字的函数表 达式也叫做匿名函数。

  在无法确定如何引用函数的情况下,递归函数就会变得比较复杂;

  递归函数应该始终使用 arguments.callee 来递归地调用自身,不要使用函数名——函数名可能会发生变化。

当在函数内部定义了其他函数时,就创建了闭包。闭包有权访问包含函数内部的所有变量,原理 如下。

  在后台执行环境中,闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域。

  通常,函数的作用域及其所有变量都会在函数执行结束后被销毁。

  但是,当函数返回了一个闭包时,这个函数的作用域将会一直在内存中保存到闭包不存在为止。

使用闭包可以在 JavaScript 中模仿块级作用域(JavaScript 本身没有块级作用域的概念),要点如下。

  创建并立即调用一个函数,这样既可以执行其中的代码,又不会在内存中留下对该函数的引用。

  结果就是函数内部的所有变量都会被立即销毁——除非将某些变量赋值给了包含作用域(即外部作用域)中的变量。

闭包还可以用于在对象中创建私有变量,相关概念和要点如下。

  即使 JavaScript 中没有正式的私有对象属性的概念,但可以使用闭包来实现公有方法,而通过公有方法可以访问在包含作用域中定义的变量。

  有权访问私有变量的公有方法叫做特权方法。

  可以使用构造函数模式、原型模式来实现自定义类型的特权方法,也可以使用模块模式、增强的模块模式来实现单例的特权方法。

JavaScript 中的函数表达式和闭包都是极其有用的特性,利用它们可以实现很多功能。不过,因为创建闭包必须维护额外的作用域,所以过度使用它们可能会占用大量内存。


推荐阅读更多精彩内容