函数闭包,作用域,对象继承

闭包，是指词法表示包括不必计算的变量的函数，即该函数能使用函数外定义的变量
eg:简单闭包实例

var Msg='Hello world';
function myfun(){
  alert(Msg);
}

注:函数捕获Msg的值只是为以后使用,即函数程序调用函数时要检查Msg的值.
eg:在一个函数中定义另一个函数(复杂闭包)

var Num=10;
function myfun(iNum1,iNum2){
    function addfun(){
       return iNum1+iNum2+Num;
    }
    return addfun()
}
myfun(10,10) //调用函数,返回结果

注:内函数是一个闭包,因从外部函数中获取两个参数值(iNum1,iNum2)以及全局变量
最后,外部函数调用addfun(),执行加法运算并返回值
闭包函数不必定义参数,使用的值从执行环境中获取.

作用域:
window作用域,function作用域
var,this关键字

一个有趣的比喻:

var ima_celebrity = "Everyone can see me!",
the_president = "I'm the decider!";

function pleasantville() {
  var the_mayor = "I rule Pleasantville with an iron fist!",
  ima_celebrity = "All my neighbors know who I am!";

  function lonely_house() {
     var agoraphobic = "I fear the day star!",
     a_cat = "Meow.";
  }
}

ima_celebrity, 家喻户晓（所有人都认识她）。她在政治上积极活跃，敢于在一个相当频繁的基层上叫嚣总统（即the_president）。她会为碰到的每一个人

签名和回答问题。就是说，她不会跟她的粉丝有私下的联系。她相当清楚粉丝们的存在并有他们自己某种程度上的个人生活，但也可以肯定的是，她并不知道

粉丝们在干嘛，甚至连粉丝的名字都不知道。

而在欢乐市（pleasantville）内，市长（the_mayor）是众所周知的。她经常在她的城镇内散步，跟她的选民聊天、握手并亲吻小孩。因为欢乐市

（pleasantville）还算比较大且重要的邻居。她还可以看到市郊外山上的孤屋（lonely_house），但从不在意里面住着的是谁。

而孤屋（lonely_house）是一个自我的世界。旷恐患者时常在里面囔囔自语，玩纸牌和喂养一个小猫（a_cat）。他偶尔会给市长（the_mayor）打电话咨询一

些本地的噪音管制.

笔记:
1.全局变量,所有函数都可以使用,不必管function是作什么用,只提供数值.
2.函数的变量,只能在该函数作用域内使用,超出范围则不能够使.
3.闭包函数,可以使外函数的变量以及外函数的传入的参数.

作用域this关键字使用

1.对象的呼叫

<script type="text/javascript">
var Obj = {
 the_Num: 42,
 ask_question: function () {
    return this.the_Num;
  }
};
var show = Obj.ask_question();
alert(show);
</script>

2.构造函数

<script type="text/javascript">
function myfun(iNum){
  this.Num=iNum;
  this.show=function(){
     return this.Num;
  }
}
var myNum= new myfun(40);
alert(myNum.show());  //注:要带括号,不然变成引用方法.
</script>

3.客户端函数呼叫(window作用域)

function myfun(){
  return this;  //window对象
}
var myWin=myfun();

4.事件处理函数
行内调用:
<button value="button" onclick="alert(this.nodeName)"></button>
页面调用:
function myfun(){
   alert(this.nodeName);  //window对象,出错
}
对象函数:
btn.onclick=function(){
   alert(this.nodeName);
}

5.区分DOM对象与window对象

<script type="text/javascript">
//构造函数
function BigComputer(answer) {
  this.name = answer;   //注意与DOM对象name的区分
  this.show = function () {
  alert(this.name);
  }
}

function myfun() {
   var win = new BigComputer(42),
   btn = document.getElementById('btn');
   btn.onclick = win.show; //DOM对象name的属性,而不是win实例的name
//btn.onclick = win.show.call(win); //????Call(this);
}

window.onload = myfun;
</script>
<button id='btn' name="0" onclick='myfun()'>Click me!</button>

call立即执行了函数（译注：其实可以用一个匿名函数封装，例如the_button.onclick = function(){deep_thought.ask_question.call(deep_thought);}),

我们给onclcik处理函数一个函数执行后的结果而非函数的引用.

6.Call()和apply()执行函数呼叫,继承
Call()

<script type="text/javascript">
var first_object = {
  num: 42
};
var second_object = {
  num: 24
};

function multiply(mult) {
  return this.num * mult;
}

multiply.call(first_object, 5); // 返回 42 * 5
multiply.call(second_object, 5); // 返回 24 * 5
</script>

call的第一个参数定义了在已执行的函数内this的所指对象。其余的参数则传入业已执行的函数内，如同函数的自身呼叫一般。

var first_object= {
   num:42
};
function multiply(mult,iNum){
   return this.num*mult;
}

multiply.call(first_object,[5],[6]);

7.bind()
Function.prototype.bind = function(obj) {
  var method = this,
  temp = function(){   //闭包
     return method.apply(obj, arguments);
  };
  return temp;
}
bind返回的是函数引用可以备用，而不是call的立即执行而产生的最终结果

对象继承：
1.对象冒充   //this.omath=classA; this.omath(ocolor);
2.Call()、apply()方法  //调用对象方法，以另一对象替代当前对象
  第一个参数是在扫行函数this所指的对象，其余按函数参数传递.
3.原型链形式：classB.prototype=new ClassA();
4.混合方法：
   a.Call()方法不支持继承基类原型(prototype)定义的属性、方法
   b.原型方法--不支持参数的传递