JS OOP -02 深刻認識JS中的函數

深刻認識JS中的函數：

1.概述,認識函數對象

2.函數對象和其餘內部對象的關係

3.將函數做爲參數傳遞

4.傳遞給函數的隱含參數：arguments

5.函數的apply,call方法和length屬性

6.深刻認識JS中的this指針

 

1.概述,認識函數對象

　　JS中的函數不一樣於其餘的語言，每一個函數都是做爲一個對象被維護和運行的。經過函數對象的性質，能夠將一個函數賦值給一個變量或者將函數做爲參數傳遞。

用法：

　　function Func1(...){......};

　　var Func2 = function(...){......};

　　var Func3 = function Func4(...){......};

　　var Func5 = new Function();

 

**函數對象！！

　　能夠用function關鍵字定義一個函數，併爲每一個函數指定一個函數名，經過函數名來進行調用。在JS解釋執行時，函數都是被維護爲一個對象，這就是函數對象（function object）。

　　函數對象與其餘用戶所定義的對象有着本質的區別，這一類對象稱之爲內部對象，例如Date，Array，String 都屬於內部對象。這些內置對象的構造器是由JS自己所定位的：經過執行 new Array() 這樣的語句返回一個對象，JS內部有一套機制來初始化返回的對象，而不是由用戶來指定對象的構造方式。

　　在JS中，函數對象對應的類型是Function，（數組對應Array，日期對應Date），能夠經過 new Function() 來建立一個函數對象，也能夠經過 function 關鍵字來建立一個對象。 

            var myArray = [];
            var myArray = new Array();
            
            function myFunction1(a,b){
                return a+b;
            };
            var myFunction = new Function('a','b','return a+b');

　　以上代碼，經過和構造數組對象語句的比較，能夠清楚的看到函數對象本質。第一種方式，在解釋器內部，當遇到這種語法時，就會自動構造一個Function對象，將函數做爲一個內部的對象來存儲和運行。（一個函數對象名稱（函數變量）和一個普通變量名稱具備一樣的規範，均可以經過變量名來引用這個變量，可是函數變量名後面能夠跟上括號和參數列表來進行函數的調用。var myFunction = new Function("a,b","return a+b")，這個方式可讀性較差）。

　　** var funcName = new Function(P1,P2,P3...Pn,body)  參數的類型都是字符串，P1到Pn表示所建立函數的參數名稱列表，body表示所建立函數的函數體語句。

　　**注意，P1到Pn是參數名稱的列表，即P1不只能表明一個參數，它也能夠是一個逗號隔開的參數列表。

　　**JS導入Function類型並提供 new Function() 這樣的語法是由於函數對象添加屬性和方法就必須藉助於Function這個類型。

　　**函數的本質是一個內部對象！由JS解釋器決定其運行方式。**

 

　　**注意：直接在函數聲明後面加上括號就表示建立完成後當即進行函數調用。返回一個number類型

            var myfunc2= function(a,b){
                return a+b;
            }(100,200);//優先級決定的，‘(’優先級大於‘=’,因此myfunc2是一個變量，而不是一個函數 
            
            alert(typeof(myfunc2));//number
            alert(myfunc2);
            alert(myfunc2(10,20));//報錯，myfunc2不是一個函數！

　　**可是不直接調用，返回的是一個function類型

　　　　　　　var Myfunc2=function(a,b){
                return a+b;
            }
            alert(typeof(Myfunc2));//function
            alert(Myfunc2(1,2));
            

 

　　　**注意有名函數和無名函數！

　　　**區別：對於有名函數，它能夠出如今調用以後再定義；而對於無名函數，必須在調用以前定義。

　　　**由於JS是一門解釋型語言，但它會在函數調用時，檢查整個代碼中是否存在相應的函數定義。只有經過function FuncName(...){...} 纔有效，而不是無名函數。

　　　　　　　function Myfunc1(a,b){//有名函數
                return a+b;
            }
            
            alert(Myfunc2(1,2));//報錯
            var Myfunc2=function(a,b){//無名函數
                return a+b;
            }
            alert(typeof(Myfunc2));//function
            

 

2.函數對象和其餘內部對象的聯繫

　　除了函數對象，還有不少內部對象，好比：Object，Array，Date.....這些都表示一個類型，能夠經過 new 操做符返回一個對象，然而函數對象和其餘對象不一樣，當用typeof獲得一個函數對象的類型時，它仍然會返回字符串「function」,而typeof一個數組對象或其餘的對象時，它會返回字符串「Object」。

 

　　　　　　　//function
            alert(typeof(Function));
            alert(typeof(new Function()));
            alert(typeof(Array));
            alert(typeof(Object));
            
            //object
            alert(typeof(new Array()));
            alert(typeof(new Date()));
            alert(typeof(new Object()));
            
            if(typeof(tt)=="function"){//判斷是function類型在運行，一般的作法
                arg();
            }

　　**new 一個Function，其實是返回一個函數。這於其餘的對象有很大的不一樣。其餘的類型Array，Object等都會經過 new 操做符返回一個普通對象（Object）。

　　**儘管函數自己也是一個對象，但它與普通的對象仍是有區別的，由於它同時也是對象構造器，也就是說，能夠new 一個函數來返回一個對象，全部typeof返回‘function’的對象都是函數對象，也叫構造器（constructor）。全部的構造器都是對象，但不是全部的對象都是構造器。

　　**Function類型的做用，就是能夠給函數對象自己定義一些方法和屬性，藉助於函數的prototype對象，能夠方便地修改和擴充Function類型的定義。

　　**Function是全部函數對象的基礎，而Object則是全部對象（包括函數對象）的基礎。在JS中，任何一個對象都是Object的實例。所以，能夠修改Object這個類型來讓全部的對象具備一些通用的屬性和方法，修改Object類型是經過prototype來完成的。

　　　　　　　Function.prototype.Methods=function(){
                alert('function');
            }
            
            function tt(){
                alert('tt');
            }
            tt.Methods();
            tt.Methods.Methods();//遞歸的定義。Methods自己也是一個函數，因此它一樣具備函數對象的屬性和方法，
　　　　　　　　　　　　　　　　　　　 //全部對Function類型的方法擴充都具備這樣的遞歸性質。
            
            
            Object.prototype.getType=function(){
                return typeof(this);
            }
            
            var array1=new Array();
            function func1(a,b){
                return a+b;
            }
            alert(array1.getType());
            alert(func1.getType());

 

3.將函數做爲參數傳遞

　　函數對象的本質：就是一個內部對象！Function類型的對象，類型仍是Function。

　　**每一個函數都被表示爲一個特殊的對象，能夠方便地將其賦值一個變量，再經過這個變量名進行函數調用。做爲一個變量，它能夠以參數的形式傳遞給另外一個函數。

            function func1(thefunc){
                
                if(typeof(thefunc)=='function'){//
                    thefunc();
                }else{
                    alert(typeof(thefunc));
                }
            }
            
            function func2(){
                return '123';
            }
            
            function func3(a,b){
                var result =a+b;
                alert(result);
            }
            
            function func4(a,b,c){
                var result =a+b+c;
                alert(a+b+c);
            }
            
            
            func1(func2());//執行結果傳遞過去
            func1(func2);//func2做爲一個對象傳遞給func1的形參thefunc，再由func1內部進行thefunc的調用。
                        //事實上，將函數做爲參數傳遞，或者是將函數賦值給其餘變量是全部事件機制的基礎。
                        
            //將func3傳遞給func1;
            //var t=new func3(1,2);
            //func1(func3);
            
            var t1 = new func3(1,2);
            alert(typeof(t1));
            

 

4.傳遞給參數的隱含參數 arguments

　　當進行函數調用時，除了指定的參數外，還建立了一個隱含的對象--arguments，arguments是一個相似數組但不是數組的對象，說它相似是由於它具備數組同樣的訪問性質，能夠用arguments[index]這樣的語法取值，擁有數組長度屬性length。arguments對象存儲的是實際傳遞給函數的參數，而不侷限於函數聲明所定義的參數列表，例如：

　　　　　　　function Myfunc(a,b){
                alert(a);
                alert(b);
            
                for (var i=0;i<arguments.length;i++) {
                    alert(arguments[i]);
                }
            }
            
            Myfunc(1,2)//顯示：1,2,1,2
            Myfunc(1,2,3)//顯示：1,2,1,2,3

　　**所以，在定義函數的時候，即便不指定參數列表，仍然能夠經過arguments引用到所得到的參數，這給編程帶來了很大的靈活性。

 　　

　　**arguments對象的另外一個屬性callee，它表示對函數對象自己的引用，這有利於實現無名函數的遞歸或者保證函數的封裝性。

　　　　　　　var sum =function(n){
                if(1==n){
                    return 1;
                }else{
                    return n+sum(n-1);//遞歸的調用
                }
            }
            alert(sum(100));
            
            //arguments.callee 表示對函數對象自己的引用，有利於實現無名參數的遞歸或者保證函數的封裝性
            var sum2 =function(n){
                if(1==n){
                    return 1;
                }else{
                    return n+arguments.callee(n-1);//arguments.callee，遞歸的調用
                }
            }
            alert(sum2(100));

　　**callee屬性並非arguments不一樣於數組對象的惟一特徵，如下代碼：

　　　　　　　Array.prototype.p1 = 1;//給因此數組對象添加屬性p1，初始化值爲1.
            alert(new Array().p1);//1
            
            function func(){
                alert(arguments.p1);
            }
            func();//undefined 說明p1不是arguments的屬性

 

　　**arguments的length的模擬實現方法的重載

　　　　　//arguments能夠實現方法的重載!
        function myFunc(){
            var result=0;
            if(arguments.length==2){
                result =arguments[0]+arguments[1];
            }else if(arguments.length==3){
                result=arguments[0]+arguments[1]+arguments[2];
            }

            /*
            for(var i=0;i<arguments.length;i++){
                result+=arguments[i];
            }
            */

            return result;
        }

        alert(myFunc(1,2,3));//6
        alert(myFunc(1,2));//3

 

5.函數的apply,call方法和length屬性

　　JS對函數對象定義了兩個方法:apply和call,它們的做用都是將函數綁定到另一個對象上去運行,二者僅在定義參數的方式有所區別:

　　　　 Function.prototype.apply(thisArg,argArray);
        Function.prototype.call(thisArg,"arg1","arg2"...)

　　從函數原型能夠看到,第一個參數都被取名爲thisArg,即全部函數內部的this指針都會被賦值爲thisArg,這就實現了將函數做爲另一個對象的方法運行的目的.

　　　　　//apply call
        function func1(){
            this.p="func1-";
            this.A=function(arg){
                alert(this.p+arg+'<func1>');
            };
        };

        function func2(){
            this.p="func2-";
            this.B=function(arg){
                alert(this.p+arg+"<func2>");
            }
        }

        var obj1=new func1();
        var obj2=new func2();

        //obj1.A("byA");//正常調用
        //obj2.B("byB");//正常調用
        obj1.A.apply(obj2,["byA"]);
        obj2.B.apply(obj1,["byB"]);
        obj1.A.call(obj2,"byA");
        obj2.B.call(obj1,"byB");
        //能夠看出,obj1的方法A被綁定到obj2運行後,整個函數A的運行環境就轉移到了obj2,即this指針指向了obj2.
        //一樣,obj2的函數B也能夠綁定obj1運行,整個函數B的運行環境就轉移到了obj1,即this指針指向了obj1.

　　函數對象的屬性length,它表示函數定義時所指定參數的個數,而非調用時實際傳遞的參數個數

　　　　 //函數對象的屬性length,它表示函數定義時所指定參數的個數,而非調用時實際傳遞的參數個數
        function sum(a,b,c) {
            return a + b+c;
        }
        alert(sum.length);//3
        var t1=sum;
        alert(t1);

 

6.深刻認識JS中的this指正

 　　this指針是面向對象程序設計中的一項重要概念,塔表示當前運行的對象.在實現對象的方法時,可使用this指針來得到該對象的自身的引用.

　　和其餘語言不一樣,JS中的this指針是一個動態的變量,一個方法內的this指針並非始終指向定義該方法的對象的,它能夠是動態的!

  　　　 var obj1=new Object();
        var obj2=new Object();

        obj1.p=1;
        obj2.p=2;

        obj1.getP=function(){
            alert(this.p);
        }
        obj1.getP();//1

        obj2.getP=obj1.getP;//函數對象賦值給函數對象
        obj2.getP();//2
        //因而可知,getP函數僅定義了一次,在不一樣的場合運行,顯示了不一樣的運行結果.這是由this指針的變化所決定的.
        //在obj1的getP方法中,this就指向了obj1對象,而在obj2的getP方法中,this就指向了obj2對象,並經過this指針引用到了兩個對象都具備的屬性p

 

　　**JS中的this指針是一個動態變化的變量,它表面了當前運行該函數的對象.由this指針的性質,也能夠更好的理解JS中對象的本質:一個對象就是由一個或多個屬性(方法)組成的集合.每一個集合元素不是僅能屬於一個集合,而是能夠動態的屬於多個集合.這樣,一個方法(集合元素)由誰調用,this指針就指向誰!

　　**實際上,apply方法和call方法都是經過強制改變this指針的值來實現的,使this指針指向參數所指定的對象,從而達到將一個對象的方法做爲另外一個對象的方法運行.

 

　　命名空間的概念(重要)

        /*
        * 每一個對象集合的元素(即屬性或方法)也是一個獨立的部分,全局函數和做爲一個對象方法定義的函數之間沒有任何區別.
        * 由於能夠把全局函數和變量看做爲window對象的方法和屬性.也可使用new操做符來操做一個對象的方法來返回一個對象,
        * 這樣一個對象的方法也就能夠定義爲類的形式,其中的this指針則會指向新建立的對象.這時對象名能夠起到一個命名空間的
        * 做用,這是使用js進行面向對象程序設計的一個技巧.
        * */
        var namespace1 = new Object();//這裏就能夠把namespace1當作一個命名空間
        namespace1.class1 = function() {//namespace1命名空間下面的類class1
            //初始化對象代碼
        }
        var obj1=new namespace1.class1();//