javascript的面向對象 函數 閉包 構造函數 繼承

<script>
        //------------函數的建立方式------------
        function f1() {
            alert('我是一個兵');
        }

        var a = function () {
            alert("我是兩個兵");
        }

        f1();
        a();           //其實也可以這樣寫(a)();

        (function () {                 //這個其實就是有a演變過來的   後面括号表示立即執行  可以存放參數  為了後面閉包
            alert("我是三個兵");
        })();

        (function (p) {
            alert(p);
        })(123);

        //-------------arguments對象-----------------
        function arg(a,b,c) {
            //在函數執行時有個arguments對象，儲存所有的參數
            //arguments對象，類似數組，可以用下标通路，并且有length屬性
//            alert(arguments);
            alert(arguments[3]);
            alert(arguments.length);
            alert(a+"\n"+b+"\n"+c);
        }
        arg(1,2,3,4);


        //--------------閉包------------------------------------------
        //閉包，指的是詞法表示包括不被計算的變量的函數，也就是說，函數可以使用函數之外定義的變量
        var g = "全局變量！！！";                   //這裡講的還是函數的嵌套使用
        function fnA() {
            var a = "A";
            //alert(g);
            fnB();        //注意這裡還是要執行的
            function  fnB() {
                var b = "B";
                alert(g);    //全局變量，在任何函數的任何位置都可以通路得到
                alert(a);    //可以通路到a
                alert(c);    //但不可以通路c
                function fnC() {
                    var c = "C";
                    alert(a+"\n"+b);     //隻要遵循從裡向外看的原則  看到的變量都可以通路到最終值
                }                         //在函數聲明處向函數外部看到的聲明的所有變量，在 函數内部都能通路到他們的最終值
                fnC();
            }
        }

        //fnB()        在這裡是不能通路到的  因為函數換種方式寫就是變量了  這個函數就相當于局部變量 外面是通路不到的  上面提示也有把鎖  表示通路不到

        //-----------閉包詳解-----------------
        function outer() {
            var a = 1212,b = 1234;
            function inner() {
                return a;
            }
            inner.function_closure= {a:1212,b:1234};          //這邊是自定義的  其實是不存在的
            return inner;              //這裡的傳回值為函數類型   要想使用就必須調用（）
        }
        var inner = outer();
        alert(inner());


        function each() {
            var i = 0,innner,a = [];
            for(; i<10;i++){
                cache(i);            //如果直接把函數cache放在這裡面的話 就隻能通路到i的最終值10
                                     // 這樣寫的話就可以通路到全部的變量了  閉包的一部分
            }

            function cache(i) {
                a.push(function () {
                    alert(i);
                })
            }
        }

        //--------------構造函數------------------
        function Demo(name,age) {
            this.name = name;       //這裡的this很關鍵
            this.age  = age;
//            return [123,456];         //這是錯誤的   因為構造函數不能有傳回值 他
        }
        var  d = new Demo("cj",18);
        alert(d.name);
        alert(d.age);

        var c = Demo("VJ",19);            //不用new的時候 this指向的是window對象
        alert(widows.name+"\n"+window.age);



        //-------------繼承------------------
        //------------這裡是無參數繼承--------------
        function DemoA() {
            this.name = "CJ";
        }
        function DemoB() {  //要讓DemoB繼承DemoA
                                                //構造函數A的prototype屬性是一個對象
                                            //這個對象具有的所有屬性，A的執行個體也具有

        }
        DemoB.prototype = new DemoA;     //new DemoA  就相當于傳回 {name:CJ}對象
                                           // 這句代碼一定要在下句代碼的前面 不然就會出錯  變成undefined
                                         //這裡千萬不能寫為new DemoA（），更加不能傳參數 在特殊情況下可以  但是隻能執行一次 也就是說隻會執行個體一次
                                            //就是隻會傳遞參數給第一個DemoB   後面如果建立新的DemoB對象是不傳遞參數的
        var d = new DemoB();
        alert(d.name);

        //---------------這裡是有參數繼承---------------
        function DemoA(name,age) {
            this.name = name;
            this.age = age;
        }
        function DemoB(name,age) {  //要讓DemoB繼承DemoA
            /*this.DemoA = DemoA;
            this.DeemoA(name,age);*/
            DemoA.call(this,name,age);     //簡寫的方式   就是為了可以參數繼承
        }
        DemoB.prototype = new DemoA;
        var d = new DemoB("cj",18);
        alert(d.name);

        var d2 = new DemoB("dghk",19);
        alert(d2.name);

        //------這裡是為引出call的例子------
        function fn(a,b) {
            this.ver = 123;
        }
        var o = {};
        fn.apply(o,[12,"b"])    //功能一樣  隻不過這裡的參數是以數組傳遞的
        fn.call(o,12,"b");        //call函數的一個方法，call（第一個參數為this指向的對象，。。。函數的參數）
                                    //其實call的作用就是改變函數内this的指針
        alert(o.ver);
    </script>