javaScripr学习总结1

<!DOCTYPE html>
<html>
<head>
 <meta charset="UTF-8">
 <script>
    //闭包：能够读取其他函数内部变量的属性的函数。
    //1 闭包会似的函数中的变量都被保存在内存中，内存消耗很大，不能滥用闭包，
    //否则会造成网页性能的问题。解决方法，在退出函数之前将不适用的局部变量全部删除。
    //2 闭包会在父函数外部，改变父函数内部变量的值。所以你把父函数当做对象(object)使用时，
    //把闭包当做它的公用的方法（public Method）,把内部变量当做它的私有属性（private value）,这时要小心，不要随便改变
    //父函数内部变量的值。

    /**
     * 官方”的解释是：
     * 闭包是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。
     * 通俗的来说就是：
     * JavaScript中所有的function都是一个闭包。
     * 不过一般来说，嵌套的function所产生的闭包更为强大，也是大部分时候我们所谓的“闭包”
     * 当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。
     */
    /**
     * 闭包的应用场景：
     * 1 保护函数内的变量安全 :不与外部变量冲突，不能在外部访问
     * 2 在内存中维持一个变量
     * 3 通过保护变量的安全实现JS私有属性和私有方法（不能被外部访问
     */


    function f1(){ //当f1作为对象使用时。
                   //当f1作为方法使用时。
        //局部变量
        var n=0;
        //公共方法(全局域的方法可以看做全局域的属性)
        f3=function(){ //闭包
            n++;
            alert(n);
        };
        //局部方法（局部变量）
        function f2(){
            alert(n);
        }

        this.show=function(){
           n++;
           alert(n);
        };

        //return f2;  //闭包
    }
    //----当f1作为方法使用时
    //var f=f1();
    //f(); //0
    //f3();//1
    //f();//1
    //f3();//2
    //alert(n);//undefined 外部的方法无法访问内部的属性
    //----当f1作为对象（构造函数使用时）
   /*
    var t=new f1();
    alert(t.n);//undefiend 无法访问，如果把方法看做类的话，此时的局部变量，相当于全局的属性？？
    //alert(t.f3());//t3 is not a function
    alert(t.f3);//undefined 由于作用域链的存在，外部的变量时无法访问内部的定义的变量的。
                //此时f3虽然是全局作用域上的方法，但是并不是f1的属性，f1并没有f3这个属性，所以为undefined
    alert(t.f2);//undefined
    */
    var ff=new f1();
    /**
     * 对象定义的步骤：
     * function Obj(params){
     *  //do something
     * }
     * var obj=new Obj(params);
     * 1 var obj={};
     * 2 Obj.call(obj,[params]); //如果这个方法有返回值的话，obj包含this.的属性
     *                           //复制属性
     * 3 obj.prototype=Obj.prototype; //保持原型链
     */
    //alert(ff.show); //(有返回值时)undefined
    ff.show(); //1   局部变量给每一个实例复制了一份，但在ff无法直接访问它。
                    //属性直接访问。
                    //-------是不是可以这样理解?局部变量看成对象的private属性,需要提供公共的set方法赋值,get获取方法。
                    //--------------------------而this.的属性看成public属性，可以通过构造函数赋值。
                    //作用域？
                    /*
                     作用域       方法域     全局域

                     public         √         √           //this.属性 (全局域，obj.value)

                     private        √         ×           //局部变量 (函数内部直接使用)
                     function Person(){
                     var t=10;
                     this.showt=function(){
                     alert(t);
                     };
                     this.showtt=function(){
                     this.tt++;
                     alert(this.tt);
                     }
                     }

                     Person.prototype.tt=100;

                     var p=new Person();
                     //alert(p.tt);//undefined

                     p.showtt();//101

                     var p1=new Person();

                     p1.showtt();//101

                     function Student(){
                     Person.call(this);
                     }

                     var s=new Student();

                     // s.showt();//

                     //s.showtt();//

                     */
   // var ff1=new f1();
   // ff1.show();//1   局部变量给每个实例复制了一份，

    //js中核心概念：
   //作用域链
   //原型链
   //闭包

    //立即执行的匿名函数：
    //闭包
    //模块化


    (function(outParams){ //
       var _privateProperty="private Property";//定义自己的私有变量 ，设置默认值
       //
       //this.set();
       //this.get();
       function _privateMethod(){//适合于写工具方法
           //do Somethings
           alert("private method!!");
       }
       publicProperty="public Property";//public 可以被外部修改的，这样做不好！

       //可以封装一个内部的闭包，被外部引用，引用一些可以被调用的方法

       //$("").popup(function(){},{
       //   options;
       // });
       var out=function(){
           //callBack的回调函数
           var version="1.5.0Version";
           //options参数
           this.sum=function(callBack,options){
                 callBack(version,options);//执行回调函数
           };
           this.sum1=function(callBack,options){
               //必填参数，可选参数
           };
           //set
           this.setProperty=function(_private){
                _privateProperty=_private;
            };
           //get
            this.getProperty=function(){
                return _privateProperty;
            };
       };
     window.out=out;//可以再外部直接调用了
    })(outParams);

   var jquery=new out();
   alert(jquery.getProperty()); //private property
   jquery.setProperty("private2");
   alert(jquery.getProperty()); //private2
   jquery.sum(function(version,opt){
           //执行求和的回调
           alert(version+":"+(opt.p1+opt.p2)); //110
     },{
        p1:10,
        p2:100
   });
    var outParams=10;//外部变量被闭包引用时，会存在内存中。
                    //即使把外部变量删除掉，仍然会被保存
 </script>
<body>

</body>
</html>