在 JavaScript 的世界里，函数是一等公民，这意味着函数可以像变量一样被传递、赋值、作为参数传递给其他函数，甚至可以作为函数的返回值。而函数表达式正是这种灵活性的体现之一。今天，我们就来深入探讨一下《JavaScript 高级程序设计》第七章中关于函数表达式的那些优雅写法。
前言
函数表达式是 JavaScript 中定义函数的两种主要方式之一（另一种是函数声明）。与函数声明不同，函数表达式是在代码执行阶段创建的，而不是在解析阶段。这种特性使得函数表达式在某些场景下具有独特的优势。
在本文中，我们将通过丰富的示例，详细介绍函数表达式的定义方式、递归、闭包、模仿块级作用域以及私有变量等概念。希望通过本文的阐述，能让大家对函数表达式有更深入的理解和应用。
什么是函数表达式
函数表达式是 JavaScript 中创建函数的另一种方式。与函数声明不同，函数表达式是在代码执行阶段创建的。函数表达式的语法如下：
var functionName = function(arg0, arg1, arg2) {
// 函数体
};这种语法创建了一个匿名函数（也称为拉姆达函数），并将其赋值给变量 functionName。由于函数表达式创建的是匿名函数，因此 function 关键字后面没有函数名。如果在 function 关键字后面加上函数名，这个函数名只在函数内部有效，在函数外部无效。
var functionName = function fnName() {
// 函数体
};
// 这里调用 fnName() 会报错函数表达式 vs 函数声明
在 JavaScript 中，函数可以通过函数声明或函数表达式来定义。虽然它们看起来相似，但在行为上有一些重要的区别。
函数声明
函数声明会在代码执行前被解析，这意味着你可以在函数声明之前调用它。这种行为被称为函数声明提升（function declaration hoisting）。
sayHi(); // 正常执行
function sayHi() {
console.log("Hi!");
}函数表达式
函数表达式是在代码执行阶段创建的，因此在函数表达式赋值之前调用它会导致错误。
sayHi(); // 错误！
var sayHi = function() {
console.log("Hi!");
};在上面的例子中，由于函数提升，变量 sayHi 会被提升到作用域顶部，但其值 undefined 不会被提升，因此在赋值之前调用 sayHi 会导致 TypeError。
递归
递归是一种常见的编程技术，它指的是函数调用自身。在函数表达式中实现递归需要特别注意，因为函数表达式创建的是匿名函数。
递归示例
function factorial(num) {
if (num <= 1) {
return 1;
} else {
return num * factorial(num - 1);
}
}上面的代码定义了一个计算阶乘的递归函数。但是，如果我们将这个函数赋值给另一个变量，然后将原变量设置为 null，就会出现问题。
var anotherFactorial = factorial;
factorial = null;
console.log(anotherFactorial(4)); // 出错！当调用 anotherFactorial(4) 时，由于 factorial 已经被设置为 null，因此在函数内部调用 factorial 会导致错误。
使用 arguments.callee
为了解决这个问题，可以使用 arguments.callee 来引用当前正在执行的函数。
function factorial(num) {
if (num <= 1) {
return 1;
} else {
return num * arguments.callee(num - 1);
}
}通过使用 arguments.callee，无论函数如何被调用，都可以正确地实现递归。
严格模式下的替代方案
在严格模式下，arguments.callee 是不可用的。因此，我们需要使用命名函数表达式来实现递归。
var factorial = (function f(num) {
if (num <= 1) {
return 1;
} else {
return num * f(num - 1);
}
});通过命名函数表达式，我们可以确保函数内部可以正确地调用自身，而不会受到外部变量变化的影响。
闭包
闭包是指有权访问另一个函数作用域中变量的函数。在 JavaScript 中，闭包是函数表达式的一个重要特性。
闭包示例
function createComparisonFunction(propertyName) {
return function(object1, object2) {
var value1 = object1[propertyName];
var value2 = object2[propertyName];
if (value1 < value2) {
return -1;
} else if (value1 > value2) {
return 1;
} else {
return 0;
}
};
}在上面的代码中，createComparisonFunction 函数返回了一个匿名函数。这个匿名函数可以访问 createComparisonFunction 函数的参数 propertyName，即使 createComparisonFunction 函数已经执行完毕。
闭包的作用域链
当某个函数被调用时，会创建一个执行环境（execution context）及相应的作用域链。然后，使用 arguments 和其他命名参数的值来初始化函数的活动对象（activation object）。在作用域链中，外部函数的活动对象始终处于第二位，外部函数的外部函数的活动对象处于第三位，直至作为作用域链终点的全局执行环境。
在函数执行过程中，为读取和写入变量的值，就需要在作用域链中查找变量。
function compare(value1, value2) {
if (value1 < value2) {
return -1;
} else if (value1 > value2) {
return 1;
} else {
return 0;
}
}
var result = compare(5, 10);在上面的例子中，compare 函数的作用域链包含两个变量对象：本地活动对象（包含 arguments 和 value1、value2）和全局变量对象。
闭包的常见用法
闭包在 JavaScript 中有很多常见的用法，比如模块模式、私有变量、回调函数等。
模块模式
var Counter = (function() {
var privateCounter = 0;
function changeBy(val) {
privateCounter += val;
}
return {
increment: function() {
changeBy(1);
},
decrement: function() {
changeBy(-1);
},
value: function() {
return privateCounter;
}
};
})();
console.log(Counter.value()); // 0
Counter.increment();
Counter.increment();
console.log(Counter.value()); // 2
Counter.decrement();
console.log(Counter.value()); // 1在上面的例子中，Counter 是一个模块，它包含三个公共方法：increment、decrement 和 value。这些方法可以访问私有变量 privateCounter 和私有函数 changeBy。
私有变量
function MyObject() {
// 私有变量和私有函数
var privateVariable = 10;
function privateFunction() {
return false;
}
// 特权方法
this.publicMethod = function() {
privateVariable++;
return privateFunction();
};
}在上面的例子中，privateVariable 和 privateFunction 是私有的，只能通过特权方法 publicMethod 来访问。
模仿块级作用域
在 JavaScript 中，没有块级作用域的概念，这意味着在块语句中定义的变量实际上是在包含函数中而非语句中创建的。
块级作用域问题
function outputNumbers(count) {
for (var i = 0; i < count; i++) {
console.log(i);
}
console.log(i); // 计数
}在上面的例子中，变量 i 是在 for 循环中定义的，但它在循环外部仍然可以访问。
使用函数表达式模仿块级作用域
通过使用函数表达式，我们可以模仿块级作用域。
function outputNumbers(count) {
(function() {
for (var i = 0; i < count; i++) {
console.log(i);
}
})();
console.log(i); // 导致错误！
}在上面的例子中，我们在 for 循环外部定义了一个匿名函数，并立即调用它。这样，变量 i 就只在匿名函数内部有效，外部无法访问。
私有变量
JavaScript 中没有私有成员的概念，所有对象属性都是公有的。不过，倒是有一个私有变量的概念。任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。
私有变量示例
function Person(name) {
this.getName = function() {
return name;
};
this.setName = function(value) {
name = value;
};
}
var person = new Person("Nicholas");
console.log(person.getName()); // "Nicholas"
person.setName("Greg");
console.log(person.getName()); // "Greg"在上面的例子中，name 是一个私有变量，只能通过 getName 和 setName 方法来访问。
静态私有变量
通过在私有作用域中定义私有变量或函数，同样也可以创建特权方法。
(function() {
// 私有变量和私有函数
var privateVariable = 10;
function privateFunction() {
return false;
}
// 构造函数
MyObject = function() {
};
// 公共/特权方法
MyObject.prototype.publicMethod = function() {
privateVariable++;
return privateFunction();
};
})();在上面的例子中，私有变量 privateVariable 和私有函数 privateFunction 是由所有实例共享的。因为特权方法是在原型上定义的，所以所有实例都使用同一个函数。
总结
函数表达式是 JavaScript 中定义函数的一种重要方式，它具有许多独特的特性和用法。通过本文的介绍，我们了解了函数表达式的基本概念、与函数声明的区别、递归的实现方式、闭包的应用、模仿块级作用域以及私有变量等概念。
掌握这些知识，可以帮助我们更好地理解和使用 JavaScript 中的函数表达式，从而编写出更加优雅和高效的代码。
希望本文能够帮助大家对函数表达式有更深入的理解和应用。在实际开发中，我们可以根据具体需求选择合适的函数定义方式，充分发挥函数表达式的优势。
最后，创作不易请允许我插播一则自己开发的“数规规-排五助手”（有各种趋势分析）小程序广告，感兴趣可以微信小程序体验放松放松，程序员也要有点娱乐生活，搞不好就中个排列五了呢？
感兴趣的可以微信搜索小程序“数规规-排五助手”体验体验！
如果觉得本文有用，欢迎点个赞+收藏+关注支持我吧！
)
