函数表达式产生一个值——一个函数对象。例如：

var add = function (x, y) { return x + y };
console.log(add(2, 3)); // 5

前面的代码将函数表达式的结果赋给变量 add，并通过该变量调用它。函数表达式生成的值可以赋给变量（如上例所示），作为参数传递给另一个函数，等等。因为普通函数表达式没有名称，所以它们也被称为 匿名函数表达式。

var fac = function me(n) {
    if (n > 0) {
        return n * me(n-1);
    } else {
        return 1;
    }
};
console.log(fac(3)); // 6

var repeat = function me(n, str) {
    return n > 0 ? str + me(n-1, str) : '';
};
console.log(repeat(3, 'Yeah')); // YeahYeahYeah
console.log(me); // ReferenceError: me is not defined

以下是一个函数声明：

function add(x, y) {
    return x + y;
}

前面的代码看起来像一个函数表达式，但它是一个语句（请参阅 表达式与语句）。它大致等效于以下代码

var add = function (x, y) {
    return x + y;
};

换句话说，函数声明声明一个新变量，创建一个函数对象，并将其赋给该变量。

构造函数 Function() 计算存储在字符串中的 JavaScript 代码。 例如，以下代码等效于前面的示例：

var add = new Function('x', 'y', 'return x + y');

但是，这种定义函数的方法速度很慢，并且将代码保存在字符串中（工具无法访问）。因此，如果可能的话，最好使用函数表达式或函数声明。 使用 new Function() 计算代码 更详细地解释了 Function()；它的工作原理类似于 eval()。

此方法在调用函数 func 时使用 argArray 的元素作为参数；也就是说，以下两个表达式是等效的：

func(arg1, arg2, arg3)
func.apply(null, [arg1, arg2, arg3])

thisValue 是 this 在执行 func 时拥有的值。在非面向对象的设置中不需要它，因此这里它是 null。

每当函数以类似数组的方式接受多个参数（但不是数组）时，apply() 就会很有用。

多亏了 apply()，我们可以使用 Math.max()（请参阅 其他函数）来确定数组的最大元素

> Math.max(17, 33, 2)
33
> Math.max.apply(null, [17, 33, 2])
33

这将执行 部分函数应用——创建一个新函数，该函数调用 func，并将 this 设置为 thisValue，并将以下参数：首先是 arg1 到 argN，然后是新函数的实际参数。在以下非面向对象的设置中不需要 thisValue，这就是为什么它是 null。

在这里，我们使用 bind() 创建一个新函数 plus1()，它类似于 add()，但只需要参数 y，因为 x 始终为 1

function add(x, y) {
    return x + y;
}
var plus1 = add.bind(null, 1);
console.log(plus1(5));  // 6

换句话说，我们创建了一个新函数，它等效于以下代码

function plus1(y) {
    return add(1, y);
}

特殊变量 arguments 仅存在于函数内部（包括方法）。 它是一个类数组对象，保存当前函数调用的所有实际参数。以下代码使用它：

function logArgs() {
    for (var i=0; i<arguments.length; i++) {
        console.log(i+'. '+arguments[i]);
    }
}

以下是交互

> logArgs('hello', 'world')
0. hello
1. world

arguments 具有以下特点

有三种方法可以确定是否缺少参数。 首先，您可以检查它是否为 undefined：

function foo(mandatory, optional) {
    if (mandatory === undefined) {
        throw new Error('Missing parameter: mandatory');
    }
}

其次，您可以将参数解释为布尔值。然后 undefined 被视为 false。但是，需要注意的是：其他几个值也被视为 false（请参阅真值和假值），因此该检查无法区分，例如，0 和缺少的参数

if (!mandatory) {
    throw new Error('Missing parameter: mandatory');
}

第三，您还可以检查 arguments 的长度以强制执行最小参数数量：

if (arguments.length < 1) {
    throw new Error('You need to provide at least 1 argument');
}

最后一种方法与其他方法不同

如果参数是可选的，则表示如果缺少该参数，则为其指定默认值。 与强制参数类似，有四种选择。

首先，检查 undefined

function bar(arg1, arg2, optional) {
    if (optional === undefined) {
        optional = 'default value';
    }
}

其次，将 optional 解释为布尔值

if (!optional) {
    optional = 'default value';
}

第三，您可以使用 或运算符 ||（请参阅 逻辑或 (||)），如果左操作数不是假值，则返回左操作数。否则，它返回右操作数

// Or operator: use left operand if it isn't falsy
optional = optional || 'default value';

第四，您可以通过 arguments.length 检查函数的参数数量

if (arguments.length < 3) {
    optional = 'default value';
}

同样，最后一种方法与其他方法不同

另一种可能性是将可选参数作为命名参数传入，作为 对象字面量的属性（请参阅 命名参数）。

在 JavaScript 中，您不能通过引用传递参数；也就是说，如果您将一个变量传递给一个函数，则会复制该变量的值并将其传递给该函数（按值传递）。因此，该函数无法更改该变量。如果需要这样做，则必须包装该变量的值（例如，包装在数组中）。

此示例演示了一个递增变量的函数

function incRef(numberRef) {
    numberRef[0]++;
}
var n = [7];
incRef(n);
console.log(n[0]);  // 8

如果您将函数 c 作为参数传递给另一个函数 f，则您必须注意两个签名：

如果两者不同，则可能会得到意外的结果：c 可能具有您不知道的可选参数，并且这些参数会错误地解释 f 提供的其他参数。

例如，考虑数组方法 map()（请参阅转换方法），其参数通常是一个具有单个参数的函数

> [ 1, 2, 3 ].map(function (x) { return x * x })
[ 1, 4, 9 ]

您可以作为 参数传递的一个函数是 parseInt()（请参阅 通过 parseInt() 获取整数）

> parseInt('1024')
1024

您可能（错误地）认为 map() 仅提供一个参数，而 parseInt() 仅接受一个参数。 那么您会对以下结果感到惊讶：

> [ '1', '2', '3' ].map(parseInt)
[ 1, NaN, NaN ]

map() 期望具有以下签名的函数

function (element, index, array)

但 parseInt() 具有以下签名

parseInt(string, radix?)

因此，map() 不仅会填充 string（通过 element），还会填充 radix（通过 index）。这意味着前面数组的值的生成方式如下

> parseInt('1', 0)
1
> parseInt('2', 1)
NaN
> parseInt('3', 2)
NaN

总而言之，请谨慎使用您不确定其签名的函数和方法。如果您使用它们，则明确说明接收哪些参数以及传递哪些参数通常是有意义的。这是通过回调函数实现的

> ['1', '2', '3'].map(function (x) { return parseInt(x, 10) })
[ 1, 2, 3 ]

一旦函数具有多个参数，您可能会混淆每个参数的用途。例如，假设您有一个函数 selectEntries()，它从数据库中返回条目。给定以下函数调用：

selectEntries(3, 20, 2);

这三个数字是什么意思？Python 支持命名参数，它们可以很容易地弄清楚发生了什么

selectEntries(start=3, end=20, step=2)  # Python syntax

可选位置参数只有在末尾省略时才有效。在其他任何地方，您都必须插入占位符，例如 null，以便其余参数具有正确的位置。使用可选命名参数，这不是问题。您可以轻松省略其中任何一个。以下是一些示例：

# Python syntax
selectEntries(step=2)
selectEntries(end=20, start=3)
selectEntries()

JavaScript 本身不支持像 Python 和许多其他语言那样的命名参数。 但是有一种相当优雅的模拟方法：通过对象字面量命名参数，并将其作为单个实际参数传递。当您使用此技术时，selectEntries() 的调用如下所示：

selectEntries({ start: 3, end: 20, step: 2 });

该函数接收一个具有属性 start、end 和 step 的对象。您可以省略其中任何一个

selectEntries({ step: 2 });
selectEntries({ end: 20, start: 3 });
selectEntries();

您可以按如下方式实现 selectEntries()

function selectEntries(options) {
    options = options || {};
    var start = options.start || 0;
    var end = options.end || getDbLength();
    var step = options.step || 1;
    ...
}

您还可以将位置参数与命名参数结合使用。 通常后者排在最后：

someFunc(posArg1, posArg2, { namedArg1: 7, namedArg2: true });