JavaScript引用类型——Function类型

Function类型

函数实际上是对象,每个函数都是Function类型的实例,而且都与其他引用类型一样具有属性和方法。由于函数是对象,因此函数名实际上也是一个指向函数对象的指针,不会与某个函数绑定。函数通常是使用函数声明语法来定义的。

function sum(sum1, sum2) {
    return sum1 + sum2;
}

这与使用函数表达式定义函数的方式几乎相差无几。

var sum = function (num1, num2) {
    return num1 + num2;
};

用Function构造函数定义函数,Function构造函数可以接收任意数量的参数,但最后一个参数始终都被看成是函数提,而前面的参数则枚举出了新函数的参数。

var sum = new Function("num1", "num2", "return num1 + num2"); //不推荐

函数名仅仅是指向函数的指针,一个函数可能会有多个名字。

function sum(num1, num2) {
    return num1 + num2;
}
alert(sum(10,10)); //20

var anotherSum = sum;
alert(anotherSum(10,10)); //20

sum = null;
alert(anotherSum(10,10)); //20
  • 1. 没有重载(深入理解)
 function addSomeNumber(num) {
    return num + 100;
}
function addSomeNumber(num){
    return num + 200;
}
var result = addSomeNumber(100); //300

与下面代码没什么区别

var addSomeNumber = function(num) {
  return num + 100;
};
addSomeNumber = function(num) {
  return num + 200;
};
var result = addSomeNumber(100); //300

在创建第二个函数时,实际上覆盖了引用第一个函数的变量addSomeNumber。

  • 2. 函数声明与函数表达式
    解析器在向执行环境中加载数据时,对函数声明和函数表达式并非一视同仁。解析器会率先读取函数声明,并使其在执行任何代码之前可用(可以访问);至于函数表达式,则必需等到解析器执行到它所在的代码行,才会真正被解释执行。
alert(sum(10,10)); 
function sum(num1, num2) {
    return num1 + num2;
}

以上代码完全可以正常运行,因为在代码开始执行之前,解析器就已经通过一个名为函数声明提升的过程,读取并将函数声明添加到执行环境中。

alert(sum(10,10)); //unexpected identifier错误
var sum = function(num1, num2) {
    return num1 + num2;
};

以上代码会在函数运行期间参数错误。

  • 3. 作为值的函数
    因为ECMAScriopt中的函数名本身就是变量,所以函数也可以作为值来使用。也就是说,不久可以像传递参数一样把一个函数传递个另一个函数,而且可以将一个函数作为另一个函数的结果返回。
function callSomeFunction(someFunction, someArgument) {
    return someFunction(someArgument);
}
function ad10(num) {
    return num + 10;
}
var result1 =callSomeFunction(add10,10);
alert(result1); //20

function getGreeting(name) {
    return "Hello, " + name;
}
var result2 = callSomeFunction(getGreeting, "Icey");
alert(result2); //"Hello Icey"

要访问函数的指针而不执行函数的话,必须去掉函数名后面的那对圆括号。

function createComparisonFunction(propertyName) {
    return function(object1, object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];

        if (value1 < value2) {
            return -1;
        } else if (value1 > value2) {
            return 1;
        } else {
            return 0;
        }
    };
}

var data = [{name:"Icey", age:25}, {name:"Root", age:24}];
data.sort(createComparisonFunction("name"));
alert(data[0].name); //"Icey"

data.sort(createComparisonFunction("age"));
alert(data[0].name); //"Root"
  • 4. 函数内部属性

在函数内部,有两个特殊的对象:argumentsthis
arguments是一个类数组对象,包含着传入函数中的所有参数。虽然arguments的主要用途是保存函数参数,但这个对象还有一个名叫callee的属性,该属性是一个指针,指向拥有这个arguments对象的函数。

function factorial(num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * factorial(num - 1);
    }
}

使用arguments.callee可以消除向上面函数的执行与函数名紧密耦合一起的现象。

function factorial(num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * arguments.callee(num - 1);
    }
}

无论引用函数时使用的是什么名字,都可以保证完成递归的调用。

var trueFactorial = factorial;
factorial = function () {
    return 0;
};
alert(trueFactorial(5)); //120
alert(factorial(5)); //0

函数内部另一个特殊的对象是this,this引用的是函数执行的环境对象——或者也可以说是this值(当在网页的全局作用域中调用函数时,this对象引用的就是window)。

window.color = "red";
var o = {color: "blue"};

function sayColor() {
    alert(this.color);
}

sayColor(); //"red"

o.sayColor = sayColor;
o.sayColor(); //blue

函数的名字仅仅是一个包含指针的变量而已。

ECMAScript5也规范化了另一个函数对象的属性:caller。这个属性中保存着调用当前函数的函数的引用,如果在全局作用域中调用当前函数,它的值为null。

function outer() {
    inner();
}

function inner() {
    alert(inner.caller);
}

outer();

以上代码会导致警告框中显示outer()函数的源代码。因为outer()调用了inner(),所以inner.caller就指向了outer()。

function outer() {
    inner();
}

function inner() {
    alert(arguments.callee.caller); //松散耦合
}

outer();

当函数在严格模式下运行时,访问arguments.callee会导致错误。ECMAScriopt5还定义了arguments.caller属性,但在严格模式下会导致错误,在非严格模式下始终是undefined。定义arguments.callee属性是为了分清arguments.caller和函数的caller属性。
严格模式下还有一个限制,不能为函数的caller属性赋值,否则会导致错误。

  • 5. 函数属性和方法

ECMAScript中的函数是对象,因此函数也有属性和方法,每个函数都包含两个属性:lengthprototype
length属性表示函数希望接收的命名参数的个数,如:

function sayName(name) {
    alert(name);
}
function sum(num1, num2) {
    return num1 + num2;
}
function sayHi() {
    alert('Hi!');
}
alert(sayName.length); //1
alert(sum.length); //2
alert(sayHi); //0

对于ECMAScript中的引用类型而言,prototype是保存它们所有实例方法的真正所在。换句话说,诸如toString()和valueOf()等方法实际上都保存在prototype名下,只不过是通过各自对象的实例访问罢了。在创建自定义引用类型以及实现继承时,prototype属性的作用是极为重要的。在ECMAScript5中,prototype属性是不可枚举的,因此使用for-in无法发现。
每个函数都包含两个非继承而来的方法:applay()call()。这两个方法的用途都是在特定的作用域中调用函数,实际上等于设置函数体内this对象的值。
apply()方法接收两个参数:一个是在其中运行函数的作用域,另一个是参数数组。其中,第二个参数可以说Array的实例,也可以是arguments对象。如:

function sum(num1, num2) {
    return num1 + num2;
}
function callSum1(num1, num2) {
    return sum.apply(this, arguments); //传入arguments对象
}
function callSum2(num1, num2) {
    return sum.apply(this,[num1, num2]); //传入数组
}
alert(callSum1(10,10)); //20
alert(callSum2(10,10)); //20

在上面这个例子中,callSum1()在执行sum()函数时传入了this作为this值(因为是在全局作用域中调用的,所以传入的就是window对象)和arguments对象。而callSum2同样也调用了sum()函数,但它传入的则是this和一个参数数组。
在严格模式下,未指定环境对象而调用函数,则this值不会转型为window。除非明确把函数添加到某个对象或者调用apply()或call(),否则this值将是undefined。
call()方法

function sum(num1, num2) {
    return num1 + num2;
}
function callSum(num1, num2) {
    return sum.call(this,num1,num2);
}
alert(callSum(10,10)); //20

apply()和call()它们强大的地方是能扩充函数赖以运行的作用域。

window.color = "red";
var o = {color:"blue"};
function sayColor() {
    alert(this.color);
}
sayColor(); //red
sayColor.call(this); //red
sayColor.call(window); //red
sayColor.call(o); //blue 函数体内的this指向了o

使用call()(或apply())来扩充作用域的最大好处,就是对象不需要与 方法有任何耦合关系。
bind()方法会创建一个函数的实例,其this值会被绑定到传给bind()函数的值。

window.color = "red";
var o = {color:"blue"};
function sayColor() {
    alert(this.color);
}
var objectSayColor = sayColor.bind(o); // objectSayColor的this值等于o
objectSayColor(); //blue

每个函数继承的toLocaleString(),toString(),valueOf()方法都返回函数的代码。

推荐阅读更多精彩内容