在 JavaScript 中,函数不是“神奇的语言结构”,而是一种特殊的值。

我们在前面章节使用的语法称为 函数声明

  1. function sayHi() {
  2. alert( "Hello" );
  3. }

另一种创建函数的语法称为 函数表达式

通常会写成这样:

  1. let sayHi = function() {
  2. alert( "Hello" );
  3. };

在这里,函数被创建并像其他赋值一样,被明确地分配给了一个变量。不管函数是被怎样定义的,都只是一个存储在变量 sayHi 中的值。

上面这两段示例代码的意思是一样的:“创建一个函数,并把它存进变量 sayHi”。

我们还可以用 alert 打印这个变量值:

  1. function sayHi() {
  2. alert( "Hello" );
  3. }
  4. alert( sayHi ); // 显示函数代码

注意,最后一行代码并不会运行函数,因为 sayHi 后没有括号。在其他编程语言中,只要提到函数的名称都会导致函数的调用执行,但 JavaScript 可不是这样。

在 JavaScript 中,函数是一个值,所以我们可以把它当成值对待。上面代码显示了一段字符串值,即函数的源码。

的确,在某种意义上说一个函数是一个特殊值,我们可以像 sayHi() 这样调用它。

但它依然是一个值,所以我们可以像使用其他类型的值一样使用它。

我们可以复制函数到其他变量:

  1. function sayHi() { // (1) 创建
  2. alert( "Hello" );
  3. }
  4. let func = sayHi; // (2) 复制
  5. func(); // Hello // (3) 运行复制的值(正常运行)!
  6. sayHi(); // Hello // 这里也能运行(为什么不行呢)

解释一下上段代码发生的细节:

  1. (1) 行声明创建了函数,并把它放入到变量 sayHi
  2. (2) 行将 sayHi 复制到了变量 func。请注意:sayHi 后面没有括号。如果有括号,func = sayHi() 会把 sayHi() 的调用结果写进func,而不是 sayHi 函数 本身。
  3. 现在函数可以通过 sayHi()func() 两种方式进行调用。

注意,我们也可以在第一行中使用函数表达式来声明 sayHi

  1. let sayHi = function() {
  2. alert( "Hello" );
  3. };
  4. let func = sayHi;
  5. // ...

这两种声明的函数是一样的。

为什么这里末尾会有个分号?

你可能想知道,为什么函数表达式结尾有一个分号 ;,而函数声明没有:

  1. function sayHi() {
  2. // ...
  3. }
  4. let sayHi = function() {
  5. // ...
  6. };

答案很简单:

  • 在代码块的结尾不需要加分号 ;,像 if { ... }for { }function f { } 等语法结构后面都不用加。
  • 函数表达式是在语句内部的:let sayHi = ...;,作为一个值。它不是代码块而是一个赋值语句。不管值是什么,都建议在语句末尾添加分号 ;。所以这里的分号与函数表达式本身没有任何关系,它只是用于终止语句。

回调函数

让我们多举几个例子,看看如何将函数作为值来传递以及如何使用函数表达式。

我们写一个包含三个参数的函数 ask(question, yes, no)

question

关于问题的文本

yes

当回答为 “Yes” 时,要运行的脚本

no

当回答为 “No” 时,要运行的脚本

函数需要提出 question(问题),并根据用户的回答,调用 yes()no()

  1. function ask(question, yes, no) {
  2. if (confirm(question)) yes()
  3. else no();
  4. }
  5. function showOk() {
  6. alert( "You agreed." );
  7. }
  8. function showCancel() {
  9. alert( "You canceled the execution." );
  10. }
  11. // 用法:函数 showOk 和 showCancel 被作为参数传入到 ask
  12. ask("Do you agree?", showOk, showCancel);

在实际开发中,这样的的函数是非常有用的。实际开发与上述示例最大的区别是,实际开发中的函数会通过更加复杂的方式与用户进行交互,而不是通过简单的 confirm。在浏览器中,这样的函数通常会绘制一个漂亮的提问窗口。但这是另外一件事了。

ask 的两个参数值 showOkshowCancel 可以被称为 回调函数 或简称 回调

主要思想是我们传递一个函数,并期望在稍后必要时将其“回调”。在我们的例子中,showOk 是回答 “yes” 的回调,showCancel 是回答 “no” 的回调。

我们可以用函数表达式对同样的函数进行大幅简写:

  1. function ask(question, yes, no) {
  2. if (confirm(question)) yes()
  3. else no();
  4. }
  5. ask(
  6. "Do you agree?",
  7. function() { alert("You agreed."); },
  8. function() { alert("You canceled the execution."); }
  9. );

这里直接在 ask(...) 调用内进行函数声明。这两个函数没有名字,所以叫 匿名函数。这样的函数在 ask 外无法访问(因为没有对它们分配变量),不过这正是我们想要的。

这样的代码在我们的脚本中非常常见,这正符合 JavaScript 语言的思想。

一个函数是表示一个“行为”的值

字符串或数字等常规值代表 数据

函数可以被视为一个 行为(action)

我们可以在变量之间传递它们,并在需要时运行。

函数表达式 vs 函数声明

让我们来总结一下函数声明和函数表达式之间的主要区别。

首先是语法:如何通过代码对它们进行区分。

  • 函数声明:在主代码流中声明为单独的语句的函数。

    1. // 函数声明
    2. function sum(a, b) {
    3. return a + b;
    4. }
  • 函数表达式:在一个表达式中或另一个语法结构中创建的函数。下面这个函数是在赋值表达式 = 右侧创建的:

    1. // 函数表达式
    2. let sum = function(a, b) {
    3. return a + b;
    4. };

更细微的差别是,JavaScript 引擎会在 什么时候 创建函数。

函数表达式是在代码执行到达时被创建,并且仅从那一刻起可用。

一旦代码执行到赋值表达式 let sum = function… 的右侧,此时就会开始创建该函数,并且可以从现在开始使用(分配,调用等)。

函数声明则不同。

在函数声明被定义之前,它就可以被调用。

例如,一个全局函数声明对整个脚本来说都是可见的,无论它被写在这个脚本的哪个位置。

这是内部算法的原故。当 JavaScript 准备 运行脚本时,首先会在脚本中寻找全局函数声明,并创建这些函数。我们可以将其视为“初始化阶段”。

在处理完所有函数声明后,代码才被执行。所以运行时能够使用这些函数。

例如下面的代码会正常工作:

  1. sayHi("John"); // Hello, John
  2. function sayHi(name) {
  3. alert( `Hello, ${name}` );
  4. }

函数声明 sayHi 是在 JavaScript 准备运行脚本时被创建的,在这个脚本的任何位置都可见。

……如果它是一个函数表达式,它就不会工作:

  1. sayHi("John"); // error!
  2. let sayHi = function(name) { // (*) no magic any more
  3. alert( `Hello, ${name}` );
  4. };

函数表达式在代码执行到它时才会被创建。只会发生在 (*) 行。为时已晚。

函数声明的另外一个特殊的功能是它们的块级作用域。

严格模式下,当一个函数声明在一个代码块内时,它在该代码块内的任何位置都是可见的。但在代码块外不可见。

例如,想象一下我们需要依赖于在代码运行过程中获得的变量 age 声明一个函数 welcome()。并且我们计划在之后的某个时间使用它。

如果我们使用函数声明,以下则代码不能如愿工作:

  1. let age = prompt("What is your age?", 18);
  2. // 有条件地声明一个函数
  3. if (age < 18) {
  4. function welcome() {
  5. alert("Hello!");
  6. }
  7. } else {
  8. function welcome() {
  9. alert("Greetings!");
  10. }
  11. }
  12. // ……稍后使用
  13. welcome(); // Error: welcome is not defined

这是因为函数声明只在它所在的代码块中可见。

下面是另一个例子:

  1. let age = 16; // 拿 16 作为例子
  2. if (age < 18) {
  3. welcome(); // \ (运行)
  4. // |
  5. function welcome() { // |
  6. alert("Hello!"); // | 函数声明在声明它的代码块内任意位置都可用
  7. } // |
  8. // |
  9. welcome(); // / (运行)
  10. } else {
  11. function welcome() {
  12. alert("Greetings!");
  13. }
  14. }
  15. // 在这里,我们在花括号外部调用函数,我们看不到它们内部的函数声明。
  16. welcome(); // Error: welcome is not defined

我们怎么才能让 welcomeif 外可见呢?

正确的做法是使用函数表达式,并将 welcome 赋值给在 if 外声明的变量,并具有正确的可见性。

下面的代码可以如愿运行:

  1. let age = prompt("What is your age?", 18);
  2. let welcome;
  3. if (age < 18) {
  4. welcome = function() {
  5. alert("Hello!");
  6. };
  7. } else {
  8. welcome = function() {
  9. alert("Greetings!");
  10. };
  11. }
  12. welcome(); // 现在可以了

或者我们可以使用问号运算符 ? 来进一步对代码进行简化:

  1. let age = prompt("What is your age?", 18);
  2. let welcome = (age < 18) ?
  3. function() { alert("Hello!"); } :
  4. function() { alert("Greetings!"); };
  5. welcome(); // 现在可以了

什么时候选择函数声明与函数表达式?

根据经验,当我们需要声明一个函数时,首先考虑函数声明语法。它能够为组织代码提供更多的灵活性。因为我们可以在声明这些函数之前调用这些函数。

这对代码可读性也更好,因为在代码中查找 function f(…) {…}let f = function(…) {…} 更容易。函数声明更“醒目”。

……但是,如果由于某种原因而导致函数声明不适合我们(我们刚刚看过上面的例子),那么应该使用函数表达式。

总结

  • 函数是值。它们可以在代码的任何地方被分配,复制或声明。
  • 如果函数在主代码流中被声明为单独的语句,则称为“函数声明”。
  • 如果该函数是作为表达式的一部分创建的,则称其“函数表达式”。
  • 在执行代码块之前,内部算法会先处理函数声明。所以函数声明在其被声明的代码块内的任何位置都是可见的。
  • 函数表达式在执行流程到达时创建。

在大多数情况下,当我们需要声明一个函数时,最好使用函数声明,因为函数在被声明之前也是可见的。这使我们在代码组织方面更具灵活性,通常也会使得代码可读性更高。

所以,仅当函数声明不适合对应的任务时,才应使用函数表达式。在本章中,我们已经看到了几个例子,以后还会看到更多的例子。