javascript高级程序设计笔记6

from:javascript高级程序设计笔记（六）

day 06


作为值的函数
从一个函数返回另一个函数，是一种极为有用的技术。可用于数组对象进行排序。如下函数：

  1. function createComparisonFunction(propertyName)  
  2. {  
  3.     return function(object1,object2){  
  4.          var value1 = object1[propertyName];  
  5.          var value2 = object2[propertyName];  
  6.          if(value1<value2){  
  7.         return -1;  
  8.           
  9.          }else if(value1>value2)  
  10.          {  
  11.         return 1;  
  12.         }else{  
  13.            return 0;  
  14.         }  
  15.     };  
  16. }  
  17.   
  18. var data = [{name:"nick",age:28},{name:"zack",age:25}];  
  19. data.sort(createComparisonFunction("name"));  
  20. alert(data[0].name);//nick,以名字name排序n<z  
  21. data.sort(createComparisonFunction("age"));  
  22. alert(data[0].name);//zack,以年龄age排序 25<28  

函数内部属性

在函数内部，有两个特殊的对象：arguments和this。arguments是一个类数组对象，包含着传入函数中的所有参数。该对象还有个名叫callee的属性，该属性是一个指针，指向拥有这个arguments对象的函数。如下非常经典的阶乘函数：


  1. function factorial(num)  
  2. {  
  3.     if(num<=1)  
  4.     {  
  5.        return 1;  
  6.     }else{  
  7.        return num*factorial(num-1);  
  8.     }  
  9. }  
     定义阶乘一般要用到递归算法，如上所示。在函数有名字并且不改变的情况下，这样定义没有问题。但这样就将函数的执行与函数名factorial紧紧的联系到了一起，为了消除这种紧密的耦合现象，可以采用arguments.callee。

  1. function factorial(num){  
  2.     if(num<=1)  
  3.     {  
  4.        return 1;  
  5.     }else{  
  6.        return num*arguments.callee(num-1);  
  7.     }  
  8. }  
  9.   
  10.   
  11. function factorial(num)  
  12. {  
  13.     if(num<=1)  
  14.     {  
  15.        return 1;  
  16.     }else{  
  17.        return num*arguments.callee(num-1);  
  18.     }  
  19. }  
  20. var truefactorial = factorial;  
  21.   
  22.   
  23. factorial = function(){  
  24.    return 0;  
  25. }  
  26. var x = truefactorial(3);//6而非0  
     函数内部的另一个特殊对象就是this.this引用的是函数据以执行的环境对象，当在网页的全局作用域中调用函数时，this对象引用的是window。如下所示：

  1. window.color = "red";  
  2. var o = {color:"blue"};  
  3. function printColor(){  
  4.    alert(this.color);  
  5. }  
  6. printColor;//red  
  7. o.printColor = printColor;  
  8. o.printColor();//blue  

     以上函数中sayColor()是在全局作用域中定义的，引用了this对象，由于在调用之前并不确定this的值，因此this可能会在执行过程中引用不同的对象，当在全局中被调用时，this引用的是全局对象window，即this.color 会转换成window.color，于是返回“red”；当把这个函数赋给对象o并调用o.printColor()时，this引用的是对象o，因此对his.color求值会转换成对o.color求值，结果就返回“blue”。

注：函数名仅仅只是一个包含指针的变量而已，即使在不同的执行环境中，全局的printColor与o.printColor指向的仍然是同一个函数。

函数属性和方法
      ECMAScript中函数就是对象，因此也就有属性和方法。每个函数都包含两个属性：length和prototype,其中，length表示函数希望接收的命名参数的个数，如下：

  1. function sayName(name){  
  2.     alert(name);  
  3. }  
  4. function sum(num1,num2){  
  5.     return num1 + num2;  
  6. }  
  7. function sayHi(){  
  8.     alert("hi");  
  9. }  
  10. alert(sayName.length);//1  
  11. alert(sum.length);//2  
  12. alert(sayHi.length);//0  

prototype属性非常重要，以后详讲。
     每个函数都包含两个非继承而来的方法：apply()和call()。这两个方法的用途都是在特定的作用域中调用函数。apply()方法接收两个参数：一个是在其中运行函数的作用域，另一个是参数数组。第二个参数可以是Array的实例，也可以是arguments对象。如下：

  1. function sum(num1,num2){  
  2.     return num1　+num2;  
  3. }  
  4. function callSum1(num1,num2){  
  5.     return sum.apply(this,arguments);//传入arguments对象  
  6. }  
  7.   
  8.   
  9. function callSum2(num1,num2){  
  10.     return sum.apply(this,[num1,num2]);//传入数组  
  11. }  
  12. alert(callSum1(10,10));//20  
  13. alert(callSum2(10,10));//20  

       严格模式下，未指定环境变量而调用函数，则this值不会转型为window，除非明确把函数添加到某个对象或者调用apply()或者call()，否则this 值将是undefined。
      call()方法与apply()方法的作用相同，区别在于接收参数的方式不同。call()，第一个参数是this值，其余的参数都直接传递给函数，即，使用call()方法时，传递给函数的参数必须逐个列举出来。apply()和call()真正的用处在于能够扩充函数赖以运行的作用域，如下：

  1. window.color = "red";  
  2. var o = {color:"blue"};  
  3. function sayColor(){  
  4.     alert(this.color);  
  5. }  
  6. sayColor();  
  7. sayColor.call(this);//red  
  8. sayColor.call(window);//red  
  9. sayColor.call(o);//blue  


时间：