Js小知识2

js 构造函数

目前最流行的自定义

先说一下构造函数执行过程
new 的作用
创建一个对象，将函数作用域赋予这个的对象，执行构造函数代码，返回新对象

function Createfun(a,b){
    this.a=a;
    this.b=b;
    this.m=[1,2,3]  
}
Createfun.prototype={ //重写原型对象
    constructor:Createfun,
    geta:function(){
        alert(this.a);
    }
}
//增加原型方法
Createfun.prototype.geta=function(){alert(this.a)}

//通过检查某个方法是否存在检查是否需初始化原型

function Createfun(){
    this.a=a;
    this.b=b;
    if(typeof this.geta !="function"){
        Createfun.prototype.geta=function(){alert(this.a)};
    }
}

js 继承

实现继承主要是通过js的原型链来实现的

原型和原型链

用例子来说明

function f1(){
    .....
}
var f=new f1();

<br> 每个函数都包含一个prototype属性<br> 原型对象都包含一个constructor属性 值为指针</p> <p><strong>函数与原型对象之间的关系</strong><br> prototype 指向原型对象 f1 Prototype</p> <p>f1 Prototype中的constructor指向 f1</p> <p><strong>实例与原型对象之间的关系</strong><br> 实例对象上都包含一个[[Prototype]]//<em>proto</em><br> 指向原型对象</p> <p>f 存在一个<em>proto</em>指向 f1 Prototype<br>

这时如果来一个

function f2(){
.....
}
f2.prototype=new f1();

将f1的实例复制给f2 prototype//此处实际是重写f2的原型对象
//增加的话 是f2.prototype.xx=function(){};

此时 f2Prototype变成了f1的一个实例
那么f2Prototype中也有了proto 指向 创建它的构造函数的原型对象 也就是f1.Prototype

这时

var instance_f2=new f2();
instance_f2既可以访问f2的原型对象的属性方法 也可以访问f1的原型对象的属性方法

另外 所有函数的原型都是Object的实例
可以称Object为顶层原型对象

Js 闭包
闭包就是函数中包含函数，被包含的函数能够访问包含函数的作用域。

function Cover(){
        var cover_a="111";

        var bibao_fun=function(){
            alert(cover_a);
        }
    }

闭包常用语创建私有作用域

function Cover(){
//私有变量 
        var cover_a=1；

        var bibao_fun=function(){
            alert(cover_a);
        }
//公有函数访问私有变量
        this.publicfun=function(){
            cover_a++;
            bibao_fun();
            alert(cover_a);
        }
    }
var test1=new Cover();
console.log(test1.cover_a)//error
test1.publicfun();//right,2
var test2=new Cover();
test2.publicfun();//right,2
//私有变量非静态

创建静态私有变量

创建块级作用域

(function(){
        var private1=1;
        function privatefun(){
            return private1;
        }
        Private=function(){ //创建了全局变量 ,私有变量在调用后会立即销毁，除非其赋予全局变量或在函数中使用

        };
        Private.prototype.publicfun=function(){
            private1++; //被使用
            return privatefun();
        }
    })()
    var p1=new Private();
    var result1=p1.publicfun();
    var p2=new Private();
    var result2=p2.publicfun();
    console.log(result1);//2
    console.log(result2);//3

单实例对象模块模式

var singleobj=function(){
        var private1=1;
        function privatefun(){
            return private1;
        }
        var newobj=new Object();
        newobj.newpro=11;
        newobj.newfun=function(){
            private1++;
            return privatefun();
        }
        return newobj;
    }();
    console.log(singleobj.newfun());//2