国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

javascript:閉包的總結

BigNerdCoding / 577人閱讀

摘要:當函數執行完畢后,局部活動對象就會被銷毀,內存中僅保存全局作用域,但是閉包情況有所不同。閉包與變量副作用閉包只能取得外層函數中任何變量的最后一個值。可以訪問變量,因為這個匿名函數時一個閉包,它能夠訪問包含作用域中的所有變量。

*前言:這次總結閉包,分別參考了《js高級程序設計》、廖雪峰老師的網站、還有《js忍著秘籍》,好了,廢話少說,黑喂狗~~~

---------------------嚴肅分割線-------------------*

1.js函數中的作用域鏈

沒錯,閉包還是要從作用域鏈說起,要理解閉包必須從函數第一次被調用時發生了什么入手,先看一個例子,代碼:

    function compare(value1,value2){
        if(value1 < value2){
            return -1;
        }else if(value1 > value2){
            return 1;
        }else{
            return 0;
        }
    }
    var result = compare(5,10);  //全局作用域中調用

首先定義了一個compare函數,然后又在全局作用域中調用了它。當調用compare()時,會創建一個包含(this,arguments,value1,value2)的活動對象,而全局執行環境的變量對象(this,result,compare)在compare()執行環境的作用域鏈中處于第二位。在這例子中,當調用compare()函數時,會為函數創建一個執行環境,其作用域鏈包含兩個變量對象:本地活動對象和全局對象,在函數中訪問一個變量時,會先從本地作用域中查找,找不到則向上查找外層函數的作用域中是否有,直到全局作用域。當函數執行完畢后,局部活動對象就會被銷毀,內存中僅保存全局作用域,但是閉包情況有所不同。

2.閉包中的作用域鏈

先看一個例子:

    function createComparisonFunction(propertyName){
        return function(object1,object2){
            var value1 = object1[propertyName];
            var value2 = object2[propertyName];
            
            if(value1 < value2){
                return -1;
            }else if(value1 > value2){
                return 1;
            }else{
                return 0;
            }
        };
    }

    var compareNames  = createComparisonFunction("name");
    var result = compareNames({name:"Jack"},{name:"Rose"});
    compareNames = null;   //銷毀匿名函數
    

上面的例子中,在createComparisonFunction函數內部定義了一個匿名函數,它的作用域鏈包含外部函數createComparisonFunction()的活動對象和全局變量對象,所以匿名函數中可以訪問createComparisonFunction()函數中的propertyName。
最重要的是:createComparisonFunction()函數在執行完畢后,它的執行環境作用域鏈會被銷毀,其活動對象仍然會留在內存中,這就是為什么上面的代碼中,執行:
var compare = createComparisonFunction("name")之后,createComparisonFunction()函數已經執行完畢,但是仍然可以在下一行代碼中執行比較大小的操作。
創建的比較函數被保存在變量compareNames中,設置它等于null,解除該函數引用,垃圾回收。

3.閉包與變量 副作用:

閉包只能取得外層函數中任何變量的最后一個值。看下面例子:

    function createFunctions(){
        var arr = new Array();
        for(var i=0; i<10;i++){
            arr[i] = function(){
                return i;
            };
        }
        return arr;
    }
    
    var result = createFunctions();
    var f1 = result[0];
    var f2 = result[1];
    var f3 = result[2];
    //執行函數
    alert(f1());    //10
    alert(f2());    //10
    alert(f3());    //10

這個例子中似乎每個函數都應該返回自己的索引值,實際上每個匿名函數返回的都是10。因為每個匿名函數中都保存著createFunctions()函數的活動對象,所以它們引用的是同一個變量i,函數createFunctions()返回后,變量i的值都是10,此時每個函數都引用著保存變量i的同一個變量對象,所以每個函數內部i的值都是10.

注意:上述函數的調用過程:執行createFunctions()函數,并且把函數執行結果賦值給變量result,現在result是一個數組,再把result[0]賦值給f1,f1實際上代表的是內部的匿名函數,現在執行這個函數:f1(),就會得到i的值。

改造

可以通過創建另一個匿名函數強制讓閉包的行為符合預期,看下面例子:

    function createFunctions(){
        var result = new Array();
        for(var i = 0; i < 10; i++){
            result[i] = (function(num){
                return function(){
                    return num;
                };
            })(i);
        }
        return result;
    }
    
    var final = createFunctions();
    var f1 = final[0];
    alert(f1());   //0

這次沒有直接把閉包賦值給數組,而是定義了一個匿名函數,并立即執行該函數的結果賦值給數組。這個匿名函數有一個參數num,也就是最終要返回的值,調用這個匿名函數時,傳入了變量i,由于函數參數是按值傳遞的,所以會把變量i的當前值傳遞給num,這個匿名函數內部,又創建并返回了一個訪問num的閉包,這樣,最里面的匿名函數會鎖住外層匿名函數傳遞進來的num值即當前i的值,并且返回num,這樣num就會等于此時的i的值并且賦值給數組。

4.閉包就是匿名函數嗎?

上述代碼中很容易讓人誤解:閉包就是一個匿名函數,其實不然,看下面例子:

    var outName = "外面的名字";
    var later;
    function outerFunction(){
        var innerName = "里面的名字";
        
        function innerFunction(){
            alert("I can see the "+outName);
            alert("I can see the "+innerName);
        }
        later = innerFunction;
    }
    outerFunction();
    later();

上述代碼中,在outerFunction()函數中,將內部函數innerFunction()賦值給全局變量later,執行完倒數第二步:outerFunction();之后,執行later();依然可以可以訪問到內部變量innerName。
因為在外部函數outerFunction中聲明innerFunction()函數時,不僅聲明了函數,還創建了一個閉包,該閉包不僅包含函數聲明,還包含了函數聲明的那一時刻該作用域中的所有變量。

5.閉包的用處 私有變量

上述例子可以看出,閉包可以用來封裝私有變量,就像java中的在對象內部封裝一個private私有變量一樣。
看下面例子:

    function createCounter(){
        var num = 0;
        this.getNum = function(){
            return num;
        };
        this.num = function(){
            num++;
        };
    }
    
    var counter = new createCounter();
    counter.num()  //調用計數器一次,使num值加1
    //測試代碼
    alert(counter.getNum());  //1
    alert(counter.num());    //undefined
    

上面例子中用構造函數模式創建了一個計數器函數,然后對函數進行實例化,在構造函數內部,我們定義了一個變量num,它的可訪問性只能在構造器內部,定義了一個getNum()方法,該方法只能對內部變量進行讀取,但不能寫入。然后又定義了方法num(),通過最后兩行測試代碼可以看出,可以通過存取方法getNum獲取私有變量,但是不能直接訪問私有變量。

總結:私有變量的意思是,我們如果想對num進行加減乘除的操作,只能在createCounter內部,外部只能訪問內部進行邏輯操作后的值,而不能訪問帶有對num值進行操作的方法,這樣,我們就可以把自己的業務邏輯封裝在函數內部的閉包中,只需要暴露出接口讓外部獲取想要得到的值就可以了,也就是說主動權完全在你定義函數時,外部只能看和獲取,而不能進行對變量值的改變的操作。

上述的目的就是創建一個用于訪問私有變量的公有方法。看下面代碼:

    function Person(name){
        this.getName = function(){
            return name;
        };
        this.setName = function(){
            name = value;
        };
    }
    
    //測試
    var person = new Person("Jack");
    alert(person.getName());     //Jack
    person.setName("Rose");
    alert(person.getName());     //Rose

上面的代碼在構造函數內部定義了兩個方法:setName和getName,這兩個方法都可以在構造函數外部訪問和實用,而且都有權訪問私有變量name,但在Person構造函數外部,沒有任何辦法訪問name,由于這兩個方法是在構造函數內部定義的,所以做為閉包能夠通過作用域鏈訪問name。上述在構造函數中定義特權方法有一個缺點,就是必須要使用構造函數模式來達到這個目的,這樣針對每個實例都會創建同樣一組新方法。

解決辦法:靜態私有變量
看下面代碼:

    (function(){
        var name = "";
        Person = function(value){
            name = value;
        };
        Person.prototype.getName = function(){
            return name;
        };
        Person.prototype.setName = function(value){
            name = value;
        };
    })();
    
    //測試函數
    var person1 = new Person("Jack");
    alert(person1.getName());         //Jack
    person1.setName("Rose");
    alert(person1.getName());         //Rose
    
    var person2 = new Person("Will");
    alert(person1.getName());          //Will
    alert(person2.getName());          //Will
   

上述代碼中,Person構造函數與getName()和setName()方法一樣,都有權訪問私有變量name,name變成了一個靜態的、由所有實例共享的屬性。在一個實例上調用setName會影響所有的實例。或者新建一個Person實例都會賦予name屬性一個新值。

上述兩個方法:第二種創建靜態私有變量會因為使用原型而增進代碼復用,但每個實例都沒有自己的私有變量。

模仿塊級作用域

上面舉過例子,js沒有塊級作用域,可以通過匿名函數立即執行把塊級作用域包裹起來,這樣就有了塊級作用域。看下面代碼:

    function outputNumbers(count){
        (function(){
            for(var i = 0; i

上述函數中,在for循環外部插入了一個私有作用域,在匿名函數中定義的任何變量,都會在匿名函數執行結束時被銷毀。因此變量i只能在for循環中使用,使用后即被銷毀,因此上面的代碼執行會這樣:
1.執行測試函數后,會彈出5個彈窗,會顯示0,1,2,3,4
2.執行完匿名函數后,i即被銷毀,所以執行alert(i);會報錯。
3.可以訪問變量count,因為這個匿名函數時一個閉包,它能夠訪問包含作用域中的所有變量。

這種技術經常在全局作用域中被用在函數外部,從而限制向全局作用域中添加過多的變量和函數,看下面代碼:

    (function(){
        var now = new Date();
        if(now.getMonth() == 0 && now.getDate() == 1){
            alert("元旦快樂");
        }
    })();

上述代碼放在全局作用域中,可以用來確定哪一天時1月1日元旦,now是匿名函數中的局部變量,不用在全局作用域中創建它。

先寫這么多吧,以后再添加~~~~~

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/79707.html

相關文章

  • 還擔心面試官問閉包

    摘要:一言以蔽之,閉包,你就得掌握。當函數記住并訪問所在的詞法作用域,閉包就產生了。所以閉包才會得以實現。從技術上講,這就是閉包。執行后,他的內部作用域并不會消失,函數依然保持有作用域的閉包。 網上總結閉包的文章已經爛大街了,不敢說筆者這篇文章多么多么xxx,只是個人理解總結。各位看官瞅瞅就好,大神還希望多多指正。此篇文章總結與《JavaScript忍者秘籍》 《你不知道的JavaScri...

    tinyq 評論0 收藏0
  • JavaScript閉包

    摘要:閉包引起的內存泄漏總結從理論的角度將由于作用域鏈的特性中所有函數都是閉包但是從應用的角度來說只有當函數以返回值返回或者當函數以參數形式使用或者當函數中自由變量在函數外被引用時才能成為明確意義上的閉包。 文章同步到github js的閉包概念幾乎是任何面試官都會問的問題,最近把閉包這塊的概念梳理了一下,記錄成以下文章。 什么是閉包 我先列出一些官方及經典書籍等書中給出的概念,這些概念雖然...

    HmyBmny 評論0 收藏0
  • JavaScript - 收藏集 - 掘金

    摘要:插件開發前端掘金作者原文地址譯者插件是為應用添加全局功能的一種強大而且簡單的方式。提供了與使用掌控異步前端掘金教你使用在行代碼內優雅的實現文件分片斷點續傳。 Vue.js 插件開發 - 前端 - 掘金作者:Joshua Bemenderfer原文地址: creating-custom-plugins譯者:jeneser Vue.js插件是為應用添加全局功能的一種強大而且簡單的方式。插....

    izhuhaodev 評論0 收藏0
  • 通過示例學習JavaScript閉包

    摘要:譯者按在上一篇博客,我們通過實現一個計數器,了解了如何使用閉包,這篇博客將提供一些代碼示例,幫助大家理解閉包。然而,如果通過代碼示例去理解閉包,則簡單很多。不過,將閉包簡單地看做局部變量,理解起來會更加簡單。 - 譯者按: 在上一篇博客,我們通過實現一個計數器,了解了如何使用閉包(Closure),這篇博客將提供一些代碼示例,幫助大家理解閉包。 原文: JavaScript Clos...

    xingpingz 評論0 收藏0
  • Js學習筆記:閉包

    摘要:一前言這個周末,注意力都在學習基礎知識上面,剛好看到了閉包這個神圣的東西,所以打算把這兩天學到的總結下來,算是鞏固自己所學。因此要注意閉包的使用,否則會導致性能問題。五總結閉包的作用能夠讀取其他函數內部變量。 # 一、前言 這個周末,注意力都在學習基礎Js知識上面,剛好看到了閉包這個神圣的東西,所以打算把這兩天學到的總結下來,算是鞏固自己所學。也可能有些不正確的地方,也請大家看到了,麻...

    Crazy_Coder 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<