函数式与面向对象重点

闭包

在函数声明处向函数外部看到的声明的所有变量，在函数内部都能访问到它的最终值

一.

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));