闭包
在函数声明处向函数外部看到的声明的所有变量，在函数内部都能访问到它的最终值
一.
function each(){
var inner;
for(i=0;i<10;i++){
inner=function(){
alert(i);
}
}
return inner;
}
var fn=each();//1
fn();//2 值为10
1.each()执行后返回ineer,如下：
function(){
alert(i);
}
2.以上代码执行后，i的最终值是10
所以fn()的值就为10
二.
function each(){
var a=[];
for( i=0;i<10;i++){
a.push(function(){
alert(i);
})
}
return a;
}
var a=each();
for(var i in a){
a[i]();
}
1.each()执行后返回含有10个项的数组，数组中的每一项都是以下：
function(){
alert(i);
}//一共有10个
2.each()被执行了一次，每次循环都返回一个上面的函数，这个函数访问到each()函数的最终值i=10
所以输出a[i](),结果是10个10
三.（输出0-9）
function each(){
var a=[];
for( i=0;i<10;i++){
cache(i);
}
function cache(j){
//cache函数执行了10次
a.push(function(){
//这里的j是cache函数的局部变量，
//alert(j)访问的是cache（j）里的变量j
alert(j);
});
}
return a;
}
var a=each();
for(var i in a){
a[i]();
}
each(i)在for循环中，cache()被调用了10次，输出0-9
this的用法
哪的对象调用了this所在的函数，那么this就指向哪个对象，例如：
function demo(name,age){
this.name=name;
this.age=age;
}
var obj={};
obj.method=demo;
obj.method("cj",18);
alert(obj.name);//cj
alert(obj.age);//18
function demo(){
this.name="cj";//公开属性
//ES没有私有属性，但是可以通过闭包来模拟
//对象访问不到，只有对象的方法才能访问到
this.age=18;
}
var d=new demo();//构造函数
alert(d.name+"\n"+d.age);
function demo(name,age){
this.name=name;
this.age=age;
}
demo("cj",18);//执行一个全局函数，
//函数内部的this指向window，
//window调用了这个全局函数
alert(window.name+"\n"+window.age);//cj 18
实例
d是demo类的实例
公有属性
function demo(){
this.name="cj";//公有属性
this.age=18;
}
var d=new demo();//构造函数
d.name="ysz";//在外部可以修改
alert(d.name+"\n"+d.age);
私有属性（闭包模拟）
function demo(name,age){
this.getName=function(){
return name;
}
this.getAge=function(){
return age;
}
this.setName=function(n){
name=n;
}
this.setAge=function(a){
age=a;
}
}
var d=new demo("cj",20);
d.name="ysz";
alert(d.getName());//还是cj，私有属性要通过方法设置和访问
d.setName("ysz");
alert(d.getName());//ysz
继承
function DemoA(){
this.name="ysz";
}
function DemoB(){
}
DemoB.prototype=new DemoA;//B继承了A
var b=new DemoB();
alert(b.name);//ysz
Prototype对象
function demoA(){
// this.ver=1
}
demoA.prototype.ver=1;
//构造函数A的prototype属性是一个对象
//这个对象具有的所有属性，A的是实例都具有
var b=new demoA();
alert(b.ver);
instanceof和isprototypeof在继承内的运用
function ClassA(){
this.a="A";
}
function ClassB(){
this.b="B";
}
ClassB.prototype=new ClassA();
//让ClassB继承ClassA
var b=new ClassB();
//实例化一定要放在继承后
alert(b.b);//B
alert(b.a);//A
alert(b instanceof ClassB);
//b继承了ClassB
alert(b instanceof ClassA);
// 因为ClassB继承了ClassA，所以ClassB的实例b也继承了ClassA
alert(ClassB.prototype.isPrototypeOf(b));
