一、函数的重要性

函数是一段可重复使用的代码块，用于执行特定任务。

在 Node.js 中，函数是 JavaScript 的核心组成部分之一，是构建应用程序的基本单元。

Node.js 继承了 JavaScript 的所有函数特性，并在其异步编程模型中发挥了重要作用。

在 JavaScript 中，一个函数可以作为另一个函数的参数。我们可以先定义一个函数，然后传递，也可以在传递参数的地方直接定义函数。

函数的重要性

二、函数定义方式

函数声明

使用function关键字声明一个函数：

function greet(name) { console.log(`Hello, ${name}!`); }

函数表达式

将函数赋值给一个变量：

const greet = function(name) { console.log(`Hello, ${name}!`); };

箭头函数

ES6 引入的简洁函数表达式：

const greet = (name) => { console.log(`Hello, ${name}!`); }; // 单行箭头函数（可省略 return） const greet = name => console.log(`Hello, ${name}!`); // 返回对象的箭头函数需要加括号 const getUser = () => ({ name: 'Alice', age: 30 });

三、函数的类型

1. 普通函数

最常见的函数形式，可以有参数和返回值：

function add(a, b) { return a + b; }

2. 匿名函数

没有名字的函数，通常作为参数传递给其他函数：

setTimeout(function() { console.log('This is an anonymous function.'); }, 1000);

3. 回调函数

作为参数传递给另一个函数，并在某个操作完成后被调用：

function fetchData(callback) { setTimeout(() => { const data = 'Some data'; callback(data); }, 1000); } fetchData((data) => { console.log(data); });

四、异步函数

从回调到 Promise

const fs = require('fs'); function readFilePromise(path) { return new Promise((resolve, reject) => { fs.readFile(path, 'utf8', (err, data) => { if (err) reject(err); else resolve(data); }); }); }

async/await

使用async和await关键字处理异步操作：

async function fetchUser(id) { try { const response = await fetch(`https://api.example.com/users/${id}`); const user = await response.json(); return user; } catch (error) { console.error('Error fetching user:', error); } } fetchUser(1).then(user => console.log(user));

五、调用方式对比

六、高级用法

1. 闭包

闭包是指一个函数能够记住并访问其词法作用域，即使这个函数在其词法作用域之外执行：

function createCounter() { let count = 0; return function() { count++; return count; }; } const counter = createCounter(); console.log(counter()); // 1 console.log(counter()); // 2

2. 高阶函数

接受函数作为参数或返回函数的函数：

function applyOperation(a, b, operation) { return operation(a, b); } const sum = applyOperation(5, 3, (x, y) => x + y); const product = applyOperation(5, 3, (x, y) => x * y); console.log(sum); // 8 console.log(product); // 15

七、函数参数处理

默认参数

在函数声明时为参数提供默认值：

function greet(name = 'Guest') { console.log(`Hello, ${name}!`); } greet(); // Hello, Guest! greet('Alice'); // Hello, Alice!

剩余参数

允许将不定数量的参数表示为一个数组：

function sum(...numbers) { return numbers.reduce((acc, num) => acc + num, 0); } console.log(sum(1, 2, 3, 4)); // 10

解构参数

从对象或数组中提取数据并将其赋值给变量：

function getUserInfo({ name, age }) { console.log(`Name: ${name}, Age: ${age}`); } const user = { name: 'Alice', age: 30 }; getUserInfo(user); // Name: Alice, Age: 30

八、函数作为参数传递

在 Node.js 中，函数可以作为参数传递给其他函数：

function say(word) { console.log(word); } function execute(someFunction, value) { someFunction(value); } execute(say, "Hello");

以上代码中，我们把say函数作为execute函数的第一个变量进行了传递。这里传递的不是say的返回值，而是say本身！

这样一来，say就变成了execute中的本地变量someFunction，execute可以通过调用someFunction()（带括号的形式）来使用say函数。

匿名函数

我们可以把一个函数作为变量传递，但不一定要"先定义，再传递"，可以直接在另一个函数的括号中定义和传递：

function execute(someFunction, value) { someFunction(value); } execute(function(word) { console.log(word); }, "Hello");

我们在execute接受第一个参数的地方直接定义了我们准备传递给execute的函数。用这种方式，我们甚至不用给这个函数起名字，这也是为什么它被叫做匿名函数。

九、函数是如何让 HTTP 服务器工作的

带着这些知识，再来看看简约而不简单的 HTTP 服务器：

var http = require("http"); http.createServer(function(request, response) { response.writeHead(200, {"Content-Type": "text/plain"}); response.write("Hello World"); response.end(); }).listen(8888);

现在它看上去应该清晰了很多：我们向createServer函数传递了一个匿名函数。

用这样的代码也可以达到同样的目的：

var http = require("http"); function onRequest(request, response) { response.writeHead(200, {"Content-Type": "text/plain"}); response.write("Hello World"); response.end(); } http.createServer(onRequest).listen(8888);

十、函数最佳实践

函数设计原则

示例：单一职责

function calculateArea(width, height) { return width * height; }

示例：避免全局变量

function calculateTotal(items) { let total = 0; for (const item of items) { total += item.price * item.quantity; } return total; }

使用箭头函数

箭头函数简洁明了，特别是在处理回调函数时：

const users = [ { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' } ]; const names = users.map(user => user.name); console.log(names); // ['Alice', 'Bob']

错误处理

使用try...catch语句处理可能抛出的错误：

async function fetchUser(id) { try { const response = await fetch(`https://api.example.com/users/${id}`); if (!response.ok) { throw new Error('Network response was not ok'); } const user = await response.json(); return user; } catch (error) { console.error('Error fetching user:', error); } }

十一、性能优化技巧

使用闭包缓存结果（记忆化）

function memoize(fn) { const cache = new Map(); return (...args) => { const key = JSON.stringify(args); if (cache.has(key)) return cache.get(key); const result = fn(...args); cache.set(key, result); return result; }; } // 使用 const slowFibonacci = memoize(function(n) { if (n < 2) return n; return slowFibonacci(n - 1) + slowFibonacci(n - 2); });

十二、实战练习

练习 1：温度转换函数

/** * 实现摄氏度和华氏度互相转换 * @param {number} temp - 温度值 * @param {string} unit - 原始单位 ('C' 或 'F') * @returns {number} 转换后的温度 */ function convertTemperature(temp, unit) { if (unit === 'C') { return temp * 9 / 5 + 32; // 摄氏转华氏 } else if (unit === 'F') { return (temp - 32) * 5 / 9; // 华氏转摄氏 } throw new Error('Invalid unit. Use "C" or "F".'); } console.log(convertTemperature(0, 'C')); // 32 console.log(convertTemperature(32, 'F')); // 0

练习 2：简单的事件发射器

class EventEmitter { constructor() { this.events = {}; } // 注册事件监听 on(event, listener) { if (!this.events[event]) { this.events[event] = []; } this.events[event].push(listener); return this; } // 触发事件 emit(event, ...args) { if (!this.events[event]) return false; this.events[event].forEach(listener => { listener(...args); }); return true; } // 移除事件监听 off(event, listener) { if (!this.events[event]) return this; this.events[event] = this.events[event].filter( l => l !== listener ); return this; } // 一次性监听 once(event, listener) { const wrapper = (...args) => { listener(...args); this.off(event, wrapper); }; return this.on(event, wrapper); } } // 使用示例 const emitter = new EventEmitter(); emitter.on('greet', (name) => { console.log(`Hello, ${name}!`); }); emitter.emit('greet', 'Alice'); // Hello, Alice!

十三、本章小结

提示：函数是 JavaScript/Node.js 的核心构建块。理解函数的不同形式、调用方式和高级用法，是编写高质量 Node.js 应用的基础。在实际开发中，建议优先使用箭头函数处理简单的回调逻辑，使用async/await处理异步操作，并始终遵循单一职责原则编写函数。