以下为《JavaScript.info》教程的部分译文。
函数参数
1.访问未命名参数
2.arguments的核心
3.像数组一样使用参数对象arguments
4.构造一个真正的数组
5.默认值
6.关键字参数
7.arguments的特殊属性
1.arguments.callee
2.arguments.callee.caller
在JavaScript中，不论函数定义时列出几个参数，在被调用时都可以传任何数量的参数。
例如：
function go(a,b) {
alert("a="+a+", b="+b)
}
go(1) // a=1, b=undefined
go(1,2) // a=1, b=2
go(1,2,3) // a=1, b=2, extra argument is not listed
函数调用时没提供的参数被认为是未定义的；所以我们看以下函数是否是无参数的情况下被调用：
function check(x) {
alert(x === undefined) // ok now I know there is no x
}
check()
没有语法上的多态性
在一些语言中，程序员可以写2个名字相同而参数列表不同的函数，而解释器/编译器会自动匹配正确的函数：
function log(a) {
...
}
function log(a,b,c) {
...
}
log(a) // first function is called
log(a,b,c) // second function is called
这个称为函数的多态性。在JavaScript中，并没有这回事。
只会有一个名字为log的函数，不论调用时传入任何参数，都只会调用那一个。
访问未命名参数
那我们如何获得比参数中所列参数个数更多的参数呢？
在每个函数里面有一个特殊的伪数组，叫做arguments。可用数字标识到arguments中包含的所有参数，比如arguments[0], arguments[1]等。
这里是一个例子，不论函数有多少参数，都可以列出来：
function sayHi() {
for(var i=0; i<arguments.length; i++) {
alert("Hi, " + arguments[i])
}
}
sayHi("Cat", "Alice") // 'Hi, Cat', then 'Hi,
Alice'
所有的参数都包含在arguments对象中，尽管其中的一些函数名称形如：sayHi(a,b,c)。
arguments的核心
一个初学者经常犯的错误就是在arguments上使用数组对象的方法，简单的说，你不能如下使用：
function sayHi() {
var a = arguments.shift() // error! arguments is
not Array
alert(a)
}
sayHi()
arguments并不是数组，那它是什么呢？让我们使用[[Class]]属性来看一下：
(function() {
alert( {}.toString.call(arguments) ) // [object
Arguments]
})()
类型几乎和对象一样，它只是看起来是数组，因为它的键（keys）是数字而且有length，然而没有其他相似处了。
像数组一样使用arguments
依然有一个方法可以在arguments对象上调用数组的方法：
function sayHi() {
var args = [].join.call(arguments, ':')
alert(args) // 1:2:3
}
sayHi(1,2,3)
这里我们在arguments上执行数组的join方法，“：”作为第一个参数。方法可以运行，因为内置的大多数数组方法（包含join）都支持数字索引和length。如果格式正确，join方法也可以使用在一个自定义对象上：
var obj = { 0: "A", 1: "B", length: 2 }
alert( [].join.call(obj) ) // "A,B"
构造一个真正的数组
arr.slice(start,end)可以把arr从start到end的部分复制到一个新的数组。
这个方法也可以在arguments的上下文中被调用，把其中所有元素复制到一个真实的数组中去：
function sayHi() {
var args = [].slice.call(arguments) // slice without parameters copies all
alert( args.join(':') ) // now .join works
}
sayHi(1,2)
明白了！'arguments'是参数
arguments和命名参数引用同样的值。
更新arguments[..]引发对应参数的改变，反之亦然。
举例：
f(1)
function f(x) {
arguments[0] = 5
alert(x) // 5, updating arguments changed x
}
相反的过程：
f(1)
function f(x) {
x = 5
alert(arguments[0]) // 5, update of x reflected in arguments
}
Arry方法修改arguments的同时也修改局部参数：
sayHi(1)
function sayHi(x) {
alert(x) // 1
[].shift.call(arguments)
alert(x) // undefined, no x any more :/
}
实际上，在现代的ECMA-262 5 规范中，arguments是从局部变量中分离出来的。
到目前为止，浏览器仍然按照上述过程执行。可以尝试一下例子看看。
一般来说，不去修改arguments是一个良好的习惯。
默认值
如果你想函数的参数可选，有以下两种方法：
1.第一，检查是否为undefined并重新分配：
function sayHi(who) {
if (who === undefined) who = 'me'
alert(who)
}
2.或者，使用或||运算符：
function sayHi(who) {
who = who || 'me' // if who is falsy, returns 'me'
alert(who)
}
sayHi("John")
sayHi() // 'me'
这种方式适用于没有提供参数和提供参数两种情况，在实际应用中，通常为这种情况。
众所周知，Math.max是一个包含可变数量参数的函数，它返回最大值或者参数：
alert( Math.max(1, -2, 7, 3) )
利用func.apply(context, args)和Math.max寻找数组中的最大元素：
var arr = [1, -2, 7, 3]
/* your code to output the greatest value of arr */
解决途径
解决途径：
var arr = [1, -2, 7, 3]
alert( Math.max.apply(Math, arr) ) // (*)
这里，我们调用Math.max方法，传递参数的数组args。
在“自然”调用Math.max(...)过程中，上下文this设定为Math,即"."前面的对象。在我们的代码中我们通过显示传递参数到apply来保持一致。
实际上，Math.max这个方法根本没有用上下文。我们可以进一步简化我们的代码：
var arr = [1, -2, 7, 3]
alert( Math.max.apply(0, arr) ) // dummy '0' context
关键字参数
想象一下，如果你获得了一个含有许多参数的函数，而且大多数参数有默认值。如下所示：
function showWarning(width, height, title, contents, showYesNo) {
width = width || 200; // default values
height = height || 100;
var title = title || "Warning";
...
}
这里我们获得了一个用于显示警告窗口的函数，它可以设置宽度、高度、标题、文本内容，显示按钮(如果设置了showYesNo)。
大多数参数具有默认值。
下面是我们怎么使用的：
showWarning(null, null, null, "Warning text", true)
// or
showWarning(200, 300, null, "Warning text")
问题是：人们容易忘记参数的顺序和含义。
想象一下你有10个参数，而且大多数为可选参数。函数调用过程会变得十分可怕。
关键字参数技术存在于Python, Ruby 和其它语言当中。
在JavaScript中，这种技术通过一个参数对象实现：
function showWarning(options) {
var width = options.width || 200 // defaults
var height = options.height || 100
var title = options.title || "Warning"
// ...
}
调用这只能函数变得简单。你只要像这样传递一个参数的对象：
showWarning({
contents: "Text",
showYesNo: true
})
另外一个好处就是这个参数对象能够重新配置和重新使用：
var opts = {
width: 400,
height: 200,
contents: "Text",
showYesNo: true
}
showWarning(opts)
opts.contents = "Another text"
showWarning(opts) // another text with same options
关键字参数应用于大多数框架。
arguments的特殊属性
arguments.callee
arguments有一个有趣的属性arguments.callee，它引用正在运行的函数。
为了支持命名函数表达式和更好的性能，这个属性已经被ECMA-262弃用。
如果他们知道arguments.callee不是必须的，JavaScript 的实现可以进一步优化代码。
一般情况下这个属性不会出现问题，但在“严格模式”下，启用这个属性会报错。
通常，这个属性应用于匿名函数的递归。
举例如下，setTimeout(func, ms)是一个在ms毫秒后调用func的内置函数。
setTimeout(
function() { alert(1) }, // alerts 1 after 1000 ms (=1 second)
1000
)
这个函数没有名称，让我们使用arguments.callee递归调用3次：
var i = 1
setTimeout(
function() {
alert(i)
if (i++<3) setTimeout(arguments.callee, 1000)
},
1000
)
另外一个例子是阶乘的：
// factorial(n) = n*factorial(n-1)
var func = function(n) {
return n==1 ? 1 : n*arguments.callee(n-1)
}
上述的阶乘函数在func重新分配的情况下仍然会运行，这是由于它使用arguments.callee引用了自身。
arguments.callee.caller
arguments.callee.caller属性保持对调用函数的引用。
出于和arguments.caller同样的原因，这个属性已经被ECMA-262弃用。arguments.caller属性的意义与其相同，但兼容性更差。不要使用arguments.caller，尽量使用 arguments.callee.calle，所有浏览器都有这个属性。
在下面的例子中，arguments.callee.caller引用了g的调用函数，调用函数为f。
f()
function f() {
alert(arguments.callee.caller) // undefined
g()
}
function g() {
alert(arguments.callee.caller) // f
}
