# 函数

## 定义函数

• 函数的名称。
• 包围在括号()中，并由逗号区隔的一个函数引数（译注：实际参数）列表。
• 包围在花括号{}中，用于定义函数功能的一些JavaScript语句。

```function square(number) {
return number * number;
}
```

```return number * number;
```

```function myFunc(theObject) {
theObject.make = "Toyota";
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
x,
y;

x = mycar.make;     // x gets the value "Honda"

myFunc(mycar);
y = mycar.make;     // y gets the value "Toyota"
// (the make property was changed by the function)
```

```function myFunc(theObject) {
theObject = {make: "Ford", model: "Focus", year: 2006};
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
x,
y;

x = mycar.make;     // x gets the value "Honda"

myFunc(mycar);
y = mycar.make;     // y still gets the value "Honda"
```

```if (num == 0){
function myFunc(theObject) {
theObject.make = "Toyota"
}
}
```

```var square = function(number) {return number * number};
```

```var factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};

print(factorial(3));
```

```function map(f,a) {
var result = [], // Create a new Array
i;
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
```

```map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
```

## 调用函数

```square(5);
```

```print(square(5));
/* ... */
function square(n){return n*n}
```

```print(square(5));
square = function (n) {
return n * n;
}
```

```function factorial(n){
if ((n == 0) || (n == 1))
return 1;
else
return (n * factorial(n - 1));
}
```

```var a, b, c, d, e;
a = factorial(1); // a gets the value 1
b = factorial(2); // b gets the value 2
c = factorial(3); // c gets the value 6
d = factorial(4); // d gets the value 24
e = factorial(5); // e gets the value 120
```

## 函数的域

```// The following variables are defined in the global scope
var num1 = 20,
num2 = 3,
name = "Chamahk";

// This function is defined in the global scope
function multiply() {
return num1 * num2;
}

multiply(); // Returns 60

// A nested function example
function getScore () {
var num1 = 2,
num2 = 3;

return name + " scored " + (num1 + num2);
}

}

getScore(); // Returns "Chamahk scored 5"
```

## 闭包

（译注：请参考JavaScript指南的闭包一文）

（译者：此处不甚明！？很多计算机术语翻译的太失败了，如此处的闭包-当然也有很多好的译文-字面和实质有如云泥，或者当代的汉语教育已死，我们快要不会说“好的中文”了；希望是iwo自己的局限所致）

```var pet = function(name) {          // The outer function defines a variable called "name"
var getName = function() {
return name;                // The inner function has access to the "name" variable of the outer function
}

return getName;               // Return the inner function, thereby exposing it to outer scopes
},
myPet = pet("Vivie");

myPet();                            // Returns "Vivie"
```

```var createPet = function(name) {
var sex;

return {
setName: function(newName) {
name = newName;
},

getName: function() {
return name;
},

getSex: function() {
return sex;
},

setSex: function(newSex) {
if(typeof newSex == "string" && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) {
sex = newSex;
}
}
}
}

var pet = createPet("Vivie");
pet.getName();                  // Vivie

pet.setName("Oliver");
pet.setSex("male");
pet.getSex();                   // male
pet.getName();                  // Oliver
```

```var getCode = (function(){
var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...

return function () {
return secureCode;
};
})();

getCode();    // Returns the secret code
```

```var createPet = function(name) {  // Outer function defines a variable called "name"
return {
setName: function(name) {    // Enclosed function also defines a variable called "name"
name = name;               // ??? How do we access the "name" defined by the outer function ???
}
}
}
```

## 使用引数对象

```arguments[i]
```

```function myConcat(separator) {
var result = "", // initialize list
i;
// iterate through arguments
for (i = 1; i < arguments.length; i++) {
result += arguments[i] + separator;
}
return result;
}
```

```// returns "red, orange, blue, "
myConcat(", ", "red", "orange", "blue");

// returns "elephant; giraffe; lion; cheetah; "
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

// returns "sage. basil. oregano. pepper. parsley. "
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
```

## 预定义的函数

JavaScript语言有好些个顶级的预定义函数：

### eval函数

`eval`函数对一串JavaScript代码字符求值，并且不限于特定的对象。`eval`的语法是这样的：

```eval(expr);
```

### isFinite函数

`isFinite`函数对引数求值，判断其是否为有限的数。`isFinite的`语法是：

```isFinite(number);
```

```if(isFinite(ClientInput)){
/* take specific steps */
}
```

### isNaN函数

`isNaN函数对引数求值，判断其是否为“NaN”（即“不是一个数字”的缩写）。``isNaN的语法是：`

```isNaN(testValue);
```

```var floatValue = parseFloat(toFloat);

if (isNaN(floatValue)) {
notFloat();
} else {
isFloat();
}
```

### parseInt和parseFloat函数

`parseInt``parseFloat`这两个“解析”函数，当引数为一个给定字符串时，将返回一个数字值。

`parseFloat`的语法是：

```parseFloat(str);
```

`parseInt的语法是：`

```parseInt(str [, radix]);
```

`parseInt将解析它的第一个引数，字符串``str，并尝试返回一个指定基数``radix（即进位制）表示的整数，此处的基数``radix``（即进位制）由第二个可选的引数指定。例如，基数为十时会转换为十进制数，八时为八进制，十六则为十六进制，以此类推。若基数大于十，字母将用来表示大于十的数目位。例如，对十六进制数（基数为16），字母A到F会被用作数目字。`

`parseInt`遇到了一个不能以给定基数表示的字符，将忽略它和其后的所有字符，并返回一个解析到当前位置为止的整数值。`若第一个字符就无法被转换为``以给定基数表示的数字，它将返回“NaN”。即``parseInt函数会将字符串截取为整数值。`

### Number和String函数

`Number``String`函数让你能够将一个对象转化为数字或字符串。此类函数的语法如下：（译者：此处隐含的意思即函数可对“对象”进行操作。此亦为行文精采之处，不明言之而潜移默化地使用“对象可以用作函数的引数”的概念，而汉译的“对象”一词似略不达意，且将此处深意破坏殆尽。）

```var objRef;
objRef = Number(objRef);
objRef = String(objRef);
```

```var D = new Date(430054663215),
x;
x = String(D); // x equals "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"
```

```var str = "12",
num;
num = Number(str);
```

```var str = "12",
num;
document.write(typeof str);
document.write("<br/>");
num = Number(str);
document.write(typeof num);
```

### escape和unescape函数（译注：JavaScript 1.5以上已废止）

`escape``unescape`函数在非ASCII编码字符下工作不正常，已经被废弃。在JavaScript 1.5和之后的版本中，请使用`encodeURI``decodeURI``encodeURIComponent``decodeURIComponent`

`escape``unescape`函数让你能编码和解码字符串。`escape`函数返回引数的ISO拉丁字符集的十六进制编码。`而unescape`函数返回该十六进制编码值相应的ASCII编码字符串值。

```escape(string);
unescape(string);
```