第五章 JavaScript函数

JS中使用方法需要注意的几个地方:
任何方法都有返回值,如果没有明确return一个值的,它的返回值是undefined
.

方法在定义时,参数列表可以直接写变量名就OK,例如: diff(iNum1, iNum2)
不需要像这样:diff(var iNum1, var iNum2)

任何用户自定义方法里面,都会有一个隐藏对象(arguments[])存在, JavaScript中提供了一个Arguments对象，该对象可以获取从JavaScript代码中传递过来的参数，并将这些参数存放在arguments[]数组中，

JS中方法的参数列表, JS不会去检测它的个数在调用时是否是匹配的.

arguments[]数组的使用,以及它的意义,一定要重点理解.

目标
什么是函数
函数的定义
函数的调用
函数的参数
递归函数
函数的闭包

[size=large]什么是函数[/size]

函数是一组可以随时随地运行的语句。函数是 ECMAScript 的核心。
函数是代码利用和模块化开发的一种思想，可以把具有相关的代码封装在一起，构造成一个代码片段（也就是JAVA类中的方法），达到特定的功能与目的，可以把函数想像成一种工具，他具有特定的功能与作用。

函数是独立于主程序而存在的，拥有特定功能的程序代码块，并且这个代码块可以在主程序或其他函数中根据需要而被调用，如果将代码块独立为函数，可以让日后的维护变得方便和简洁。
JavaScript中函数分为：内置函数和用户自定义函数。

[size=large]定义函数[/size]

在JavaScript中，可以使用function语句来定义一个函数，其语法如下：
function 函数名（参数1，参数2…）{
语句块…
return 返回值
}
function 关键字：用户定义一个函数
函数名：函数名通常是一个合法的标识符，不能是保留字或表达式。
参数：在一个函数里，可以为0个或多个参数，如果有多个参数，参数与参数之间要用逗号隔开，无论函数是否有参数，小括号都是必须的。
函数体：用大括号括起来的代码块，也是一个函数的主体，一个函数要实现什么功能，由函数体来决定。
返回值：函数返回的值由关键字return完成，但并不是每个函数都需要有返回值，如果没有返回值，则return 语句可以省略。

[size=large]函数的调用[/size]

函数可以通过其名字加上括号中的参数进行调用，如果有多个参数。
请看示例：
function sayHello(sName, sMessage) {
alert("Hello " + sName + sMessage);
}
sayHi(“David”, “ Nice to meet you!”); //无返回值函数的调用
************************************************************
function sum(iNum1, iNum2) {
return iNum1 + iNum2;
}
var iResult = sum(1,1); //有返回值函数的调用
alert(iResult); //输出 "2"

[size=large]函数返回值[/size]

另一个重要概念是，与在 Java 中一样，函数在执行过 return 语句后立即停止代码。因此，return 语句后的代码都不会被执行。
例如，在下面的代码中，alert 窗口就不会显示出来：
function sum(iNum1, iNum2) {
return iNum1 + iNum2;
alert(iNum1 + iNum2);
}
一个函数中可以有多个 return 语句，如下所示：
function diff(iNum1, iNum2) {
if (iNum1 > iNum2) {
return iNum1 - iNum2;
} else {
return iNum2 - iNum1;
}
}上面的函数用于返回两个数的差。要实现这一点，必须用较大的数减去较小的数，因此用 if 语句决定执行哪个 return 语句。
如果函数无返回值，那么可以调用没有参数的 return 运算符，随时退出函数。
例如：
function sayHi(sMessage) {
if (sMessage == "bye") {
return;
}
alert(sMessage);
}
这段代码中，如果 sMessage 等于 "bye"，就永远不显示警告框。
注释：如果函数无明确的返回值，或调用了没有参数的 return 语句，那么它真正返回的值是 undefined。

[size=large]定义函数的注意事项[/size]

1.函数名要通俗易懂：一个好的函数名，应该可以看出该函数能实现什么样的功能。

2.一个函数只实现一种功能：每个函数都是一个程序代码块，但不要在同一个函数中实现太多的功能，最好可以让每个函数只实现一种功能，这样更利于程序的编写和维护。

3.函数最好放在JavaScript代码的开头：将函数放在JavaScript代码的开头，可以增加代码的可读性，也便于其他对象的定义和对函数的引用。

4.合理安排函数的次序：应该将常用的或先调用的函数放在JavaScript的前面，不常用的或后调用的放在后面。这样可以增加程序的可读性，也能让程序的逻辑性更完整。

5.JavaScript是一种无类型的语言，因此，不能指定函数的参数的类型，事实上，JavaScript也不会检测传过来的参数是否符合函数要求的类型。

6.函数的返回可以是任何类型的数据，JavaScript不会检测返回的值是否符合函数的类型。

[size=large]函数的嵌套定义[/size]

所谓函数的嵌套指的是在定义一个函数时，同时在这个函数的代码中定义另一个函数，这种操作是JavaScript特有的，有点像Java的内部类的概念。示例:
function myWrite(str){
alert(str);
}

function myFun(){
function mySum(x,y){
var z = x + y;
return z;
}

var x = mySum(1,2);
myWrite(x);
}
myFun();

[size=large]函数的参数[/size]

在调用函数时，如果传递的参数个数与函数定义的参数个数不同，则往往会产生一些意想不到的错误，虽然传递的参数大于函数定义的参数个数时，函数也能正常执行，但是有可能会产生逻辑错误，为了避免产生错误，程序员应该让传递的函数参数个数与函数定义的参数个数相同。

在JavaScript中提供了一个Arguments对象，该对象可以获取从JavaScript代码中传递过来的参数，并将这些参数存放在arguments[]数组中，因此也可以通过Arguments对象来判断传递过来的参数的个数。请看示例：
function howManyArgs() {
alert(arguments.length);
}

howManyArgs("string", 45);
howManyArgs();
howManyArgs(12);
上面这段代码将依次显示 "2"、"0" 和 "1"。
注释：与其他程序设计语言不同，ECMAScript 不会验证传递给函数的参数个数是否等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数（根据 Netscape 的文档，最多可接受 25 个），而不会引发任何错误。任何遗漏的参数都会以 undefined 传递给函数，多余的函数将忽略。
在函数代码中，使用特殊对象 arguments，开发者无需明确指出参数名，就能访问它们。
例如，在函数 sayHi() 中，第一个参数是 message。用 arguments[0] 也可以访问这个值，即第一个参数的值（第一个参数位于位置 0，第二个参数位于位置 1，依此类推）。
因此，无需明确命名参数，就可以重写函数：
原函数：
function sayHi(sMessage) {
if (sMessage == "bye") {
return;
}
alert(sMessage);
}
第一个参数是 message。用 arguments[0] 也可以访问这个值，即第一个参数的值（第一个参数位于位置 0，第二个参数位于位置 1，依此类推）。
因此，无需明确命名参数，就可以重写函数：
改写后的函数：
function sayHi() {
if (arguments[0] == "bye") {
return;
}
alert(arguments[0]);
}
模拟函数重载
用 arguments 对象判断传递给函数的参数个数，即可模拟函数重载：
function doAdd() {
if(arguments.length == 1) {
alert(arguments[0] + 5);
} else if(arguments.length == 2) {
alert(arguments[0] + arguments[1]);
}
}
doAdd(10); //输出 "15"
doAdd(40, 20); //输出 "60"
当只有一个参数时，doAdd() 函数给参数加 5。如果有两个参数，则会把两个参数相加，返回它们的和。所以，doAdd(10) 输出的是 "15"，而 doAdd(40, 20) 输出的是 "60"。
虽然不如重载那么好，不过已足以避开 ECMAScript 的这种限制。
arguments对象的应用
提示：虽然arguments可以作为数组来使用。
数组排序：
function myFun(){
var arrlength = arguments.length;
for (var i = 0; i < arrlength; i++) {
for (var j = i + 1; j < arrlength; j++) {
if (arguments[i] < arguments[j]) {
var temp = arguments[i];
arguments[i] = arguments[j];
arguments[j] = temp;
}
}
}
for(var i=0; i<arrlength; i++){
document.write(arguments[i] + " ");
}
}
myFun(28,93,74,20,987,51,9,38,5);

[size=large]函数的递归[/size]

递归：函数自己调用自己称为递归。
function myFun(x){
var sum = 1;
if(x > 1){
sum = x*myFun(x-1);
}
return sum;
}
alert(myFun(5));

[size=large]函数的闭包[/size]

闭包:函数可以使用函数之外定义的变量。
简单的闭包实例
在 ECMAScript 中使用全局变量是一个简单的闭包实例。请思考下面这段代码：
var sMessage = "hello world";
function sayHelloWorld() {
alert(sMessage);
}
sayHelloWorld();
在上面这段代码中，脚本被载入内存后，并没有为函数 sayHelloWorld() 计算变量 sMessage 的值。该函数捕获 sMessage 的值只是为了以后的使用，也就是说，解释程序知道在调用该函数时要检查 sMessage 的值。sMessage 将在函数调用 sayHelloWorld() 时（最后一行）被赋值，显示消息 "hello world"。
复杂的闭包实例
在一个函数中定义另一个会使闭包变得更加复杂。例如：
var iBaseNum = 10;
function addNum(iNum1, iNum2) {
function doAdd() {
return iNum1 + iNum2 + iBaseNum;
}
return doAdd();
}
这里，函数 addNum() 包括函数 doAdd() （闭包）。内部函数是一个闭包，因为它将获取外部函数的参数 iNum1 和 iNum2 以及全局变量 iBaseNum 的值。 addNum() 的最后一步调用了 doAdd()，把两个参数和全局变量相加，并返回它们的和。

这里要掌握的重要概念是，doAdd() 函数根本不接受参数，它使用的值是从执行环境中获取的。
可以看到，闭包是 ECMAScript 中非常强大多用的一部分，可用于执行复杂的计算。
提示：就像使用任何高级函数一样，使用闭包要小心，因为它们可能会变得非常复杂。

[size=large]使用函数要注意的地方[/size]

JavaScript是一种无类型的语言，所以你不能给函数的参数指定一个数据类型，而且JavaScript也不会检测传递的数据是不是那个函数所要求的类型，如果参数的数据类型很重要，那么可以用运算符typeof对它进行检测，JavaScript也不会检测传递给它的参数个数是否正确，如果传递的参数比函数需要的个数多，那么多余的值会被忽略掉．如果传递的参数比函数需要的个数少，那么多余的几个参数就会被赋予undefined，在大多数情况下，这会使函数产生运行错误．函数如果没有返回值，实际上它返回的总是undefined．