欢迎使用CSDN-markdown编辑器

javascript高程小结

纯手打

   function fn() {            var val = 1;        //私有基础属性            var arr = [1];      //私有引用属性            this.val = 1;       //实例基础属性            this.arr = [1];     //实例引用属性        }        fn.prototype.val = 1;     //原型基础属性        fn.prototype.arr = [1];     //原型引用属性----------        //原型链继承        function main() {            this.val = 1;            this.arr = [1];        }        main.prototype.say = function () { console.log(this.arr) };        function local(){ }      //local.prototype = main.prototype;       将父类原型直接赋值给子类原型相当于重写子类原型，      //local.prototype.constructor = local;    其构造器属性会消失，导致子类实例无法指向起构造函数        local.prototype = new main();        var person1 = new local();        var person2 = new local();        person1.say();        person2.say();        /*        缺点：无法传参数，引用类型和函数会同时被修改        */----------        //借用构造函数继承         function main(val) {            this.val = val;            this.arr = [1];            this.say = function () {                console.log("val:"+this.val +" arr:"+ this.arr);            }        }        function local(val) {            main.call(this, val);        }        var person1 = new local(1);        var person2 = new local(2);        person1.arr.push(2);        person1.say();        person2.say();        /*        优点：可以传参，同时子类拥有自己的属性和方法副本        缺点： 父类函数多的时候，子类也拥有多函数，臃肿而且无继承思想，无法实现函数复用        */----------        //组合继承（常用）         function main(val) {            this.val = val;            this.arr = [1];        }        main.prototype.say = function () {            console.log('val:' + this.val + ' arr:' + this.arr);        }        function local(val) {            main.call(this,val);        }        local.prototype = new main();        var obj = new local(1);        obj.say();        var obj2 = new local(2);        obj2.say();        /*        优点：用构造函数，阻断引用属性共享问题，             利用原型链继承，实现函数复用        缺点：子类原型上有父类多余的属性        */        //寄生组合继承（最佳）             function main() {            this.val = 1;            this.arr = [1];        }        main.prototype.say = function () {            console.log('val:' + this.val + ' arr:' + this.arr);        }        function local() {            main.call(this);          }        function construt(obj) {            var F = function () { };            F.prototype = obj;            return new F();        }        var pro = new construt(main.prototype);        pro.constructor = local;        local.prototype = pro;        var obj = new local();        obj.val = 2;        obj.say();/*个人写*/ function main() {            this.val = 1;            this.arr = [1];        }        main.prototype.say = function () {            console.log(this.val + ':' + this.arr);        }        function local() {            main.call(this);        }        local.prototype = main.prototype;        local.constructor = local;        var person = new local();        var person2 = new local();        person.val = 2;        person.arr.push(2);        person.say();        person2.say();        /**/          function createFunction(){            var result=new Array();            for (var i = 0; i <10 ; i++) {                result[i]=function(){                    return i;                }            }            return result;        }   /*闭包保存的包含函数的活动变量的最后值,引用指向同一个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;        }        /*        (function(){ 函数体})()   表示：定义了一个匿名函数并执行         匿名函数具有全局性，其this 常指向window        */        var name='the window';        var object={            name:'the object',            getName:function(){                return function(){                    return this.name;                }            }        }       alert(object.getName()); //返回the window       var object={        name:'the window',        getName:function(){             var that=this;             return function(){                return that.name;            }        }       }       alert(object.getName()); //返回 the object       function ouputNums(count){        (function(){            for (var i = 0; i < count; i++) {                     alert(i);            }        })();        alert(i); //返回错误       }        /* (function(){})() 构成了一个私有作用域，i的变量只在里面临时存在，外部无法访问*/       /*通过私有作用域，反正向全局环境加入过多变量和方法，避免造成变量冲突*/       (function(){        var date=new Date();        if(date.getMonth()==0 && date.getDate()==1){            alert('Happy Year');        }       })();       function add(value1,value2){            var sum=value1+value2;            return sum;       }  /*value1,value2,sum 均为私有变量*/       function MyObject(){        /*私有函数，私有变量*/        var privateVariable=10;        function privateFunction(){            return false;        }        /*特权方法：有权访问私有函数和私有变量的公共方法，类似c#的public访问private*/        this.publicMethod=function(){            privateVariable++;            return privateFunction();        }       }       /*隐藏数据，类型C#的private和_private*/       function Person(name){        this.getName=function(){            return name;        }        this.setName=function(value){            name=value;        }       }