在现代 web 开发中，开发者会使用多种框架和库来构建高效的应用程序。Express.js 是一个非常流行的 web 应用框架，它是基于 Node.js 的，专注于提供一个简洁而灵活的框架来构建网络应用。接下来，我们将详细探讨什么是 Express.js，以及它在构建 web 应用程序中的重要性。

1.1 什么是 Express.js

Express.js 是一个为 Node.js 提供的极简且灵活的 web 应用框架，帮助开发者构建 web 应用和 API。它由 TJ Holowaychuk 于 2010 年创建，并迅速成为 Node.js 生态系统中最受欢迎的框架之一。Express.js 的设计宗旨是高效和简单，因此它为开发者提供了一套强大的功能集。

特点

Express.js 提供了一些非常有用的功能，包括：

• 中间件：Express 支持使用中间件函数，这是使应用程序变得灵活且可扩展的重要因素。中间件可以用于处理请求、响应、错误处理等。
• 路由：Express 提供了一个强大的路由管理系统，可以轻松定义不同的路由和其对应的 HTTP 请求方法。
• 模板引擎支持：Express 支持多种模板引擎，如 EJS、Pug 和 Handlebars，使得动态生成 HTML 文档变得简单。
• 静态文件服务：Express 可以轻松地服务于静态文件，如 CSS、JavaScript 和图片。

何时使用 Express.js

当你需要构建一个轻量级的 web 应用、RESTful API 或者单页面应用时，Express.js 是一个非常好的选择。例如：

• 构建一个简单的博客平台
• 创建一个 RESTful API，供前端应用调用
• 开发一个小型电商网站

示例代码

下面是一个简单的示例，演示如何创建一个基本的 Express 应用程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 导入 express 模块
const express = require('express');

// 创建一个应用实例
const app = express();

// 定义一个简单的路由
app.get('/', (req, res) => {
  res.send('Hello World!');
});

// 启动服务器
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

在这段代码中，我们首先导入了 express 模块，并创建了一个 Express 应用实例。然后，我们设置了一个简单的路由，以响应根路径的请求，最后启动了一个监听在指定端口的服务器。

总结

Express.js 是一个强大的工具，使得 Node.js 开发变得更加简单和高效。通过方便的路由、中间件和模板功能，开发者可以快速构建出功能强大的 web 应用程序。接下来，我们将继续探讨 Express.js 的一些显著特点以及它相对于其他框架所具备的优势。

在学习 Express.js 之前，我们先来了解一下它的优势和特点，这将帮助我们更好地理解它为何成为了构建 Web 应用程序的流行选择。

1. 轻量级与灵活性

Express.js 是一个“最小化”的 Web 框架，意味着它提供了基本的功能，但不强制过多的约定。开发者可以根据实际需求自由地扩展和修改。这样的设计使得 Express.js 非常灵活，适合不同规模和复杂度的项目。

案例：假设我们需要创建一个简单的 API 服务来管理用户信息。使用 Express，我们能够快速设置基本的路由和中间件，而不需要在框架中配置一大堆默认行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

const express = require('express');
const app = express();

// 定义用户数据
const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];

// 用户列表接口
app.get('/users', (req, res) => {
    res.json(users);
});

// 启动服务
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

这个简单的示例展示了 Express.js 易于上手的特点。

2. 中间件支持

Express.js 的一个核心特点是其强大的中间件支持。中间件是处理请求与响应之间的代码，可以对请求进行处理或在响应发送之前执行其他操作。这使得开发者能够灵活地添加功能，比如身份验证、日志记录等。

案例：我们可以添加一个简单的日志中间件来记录每次请求的信息。

1
2
3
4

app.use((req, res, next) => {
    console.log(`${req.method} ${req.url}`);
    next(); // 调用下一个中间件
});

在这个示例中，我们定义了一个日志中间件，它会打印每一个进入的请求的 HTTP 方法和 URL，调用 next() 后，控制权会交给下一个中间件或路由。

3. 路由功能

Express.js 提供了一种简单且强大的路由机制，可以根据请求的 HTTP 方法和 URL 来定义不同的路径。这使得组织代码和管理 RESTful API 变得容易。

案例：假设我们要添加一个获取特定用户信息的路由。

1
2
3
4
5
6
7
8
9
10
11

// 获取特定用户信息
app.get('/users/:id', (req, res) => {
    const userId = Number(req.params.id);
    const user = users.find(u => u.id === userId);
    
    if(user) {
        res.json(user);
    } else {
        res.status(404).send('User not found');
    }
});

在这个代码片段中，我们使用动态路由参数 :id 来获取用户的 ID 并返回对应的用户信息。

4. 强大的社区与生态系统

Express.js 拥有一个活跃的社区和丰富的生态系统，提供了许多插件和中间件，可以方便地集成到项目中。这让开发者可以利用现成的解决方案，而不用从零开始。

案例：我们可以利用 body-parser 中间件处理请求体数据。

1
2
3
4
5
6
7
8
9
10
11
12

const bodyParser = require('body-parser');

// 使用 body-parser 中间件
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

// 创建新用户的接口
app.post('/users', (req, res) => {
    const newUser = req.body;
    users.push(newUser);
    res.status(201).json(newUser);
});

在这里，我们使用了 body-parser 中间件来解析请求中的 JSON 数据，实现了创建新用户的功能。

5. 易于测试

Express.js 的设计使得对应用程序进行测试变得简单。由于其模块化的结构，开发者可以轻松地编写单元测试和集成测试。

利用现代工具如 Mocha、Chai 等，可以快速为 Express 应用编写测试案例，确保你的 API 持续正常运转。

总结

通过了解以上特点，我们可以看到 Express.js 不仅是一个轻量级的框架，更是一个功能强大且灵活的工具，适用于各种类型的 Web 开发项目。无论是构建快速的单页应用，还是复杂的 RESTful 服务，Express.js 都能够为开发者提供帮助。

接下来，我们将细分学习目标，明确我们在学习 Express.js 时的方向和目的。

1.3 学习目标

在本系列教程中，我们将深入学习 Express.js，这是一款基于 Node.js 的现代 Web 应用框架。通过本章的学习，您将获得以下学习目标：

1. 理解 Express.js 的基本概念
   作为一款轻量级、灵活且强大的 Web 应用框架，Express.js 提供了一系列强大且灵活的功能。我们将了解其背后的理念，以及它如何帮助我们快速构建 Web 应用。

2. 掌握 Express.js 的基本语法和用法
   通过学习最基本的路由设置、请求及响应对象、以及中间件的使用，您将能掌握 Express.js 的基本语法，构建简单的应用程序。

   1 2 3 4 5 6 7 8 9 10 11

   const express = require('express'); const app = express(); // 创建路由 app.get('/', (req, res) => { res.send('Hello, Express!'); }); app.listen(3000, () => { console.log('Server is running on http://localhost:3000'); });

3. 探索中间件的概念和应用
   中间件是 Express.js 的核心概念之一，它们是处理请求的函数，通过它们我们可以对请求和响应进行处理。我们将学习如何编写和使用自定义中间件，并探索内置的中间件。

   1 2 3 4 5

   // 自定义中间件 app.use((req, res, next) => { console.log('Request URL:', req.url); next(); // 调用下一个中间件 });

4. 学习如何处理不同类型的请求
   Express.js 可以处理多种 HTTP 请求，例如 GET、POST、PUT、DELETE 等。我们将学习如何根据不同请求方法编写相应的路由，并处理请求数据。

   1 2 3

   app.post('/submit', (req, res) => { res.send('Form submitted!'); });

5. 构建实用的 Express.js 应用
   在教程的后期部分，我们将用 Express.js 构建一个简单的 RESTful API，涵盖 CRUD（创建、读取、更新和删除）操作。通过这样一个项目，您将能将所学知识应用于实际场景，并理解 Express.js 在 Web 开发中的作用。

6. 解决常见问题和调试技巧
   学习如何调试 Express.js 应用以及常见问题的解决方案。我们会针对一些常见的错误和挑战，提供实用的调试措施和预防方案，以帮助您在开发中更加从容。

在接下来的学习中，我们希望您能积极尝试实践，通过代码和案例的结合，不断提高自己在 Express.js 开发上的技能。感谢您选择参与本系列教程，让我们一起开始这段旅程！

在学习 Express.js 之前，我们首先需要在本地环境中安装 Node.js。Node.js 是一个开源的、跨平台的 JavaScript 运行时，它允许我们在服务器端运行 JavaScript 代码。Express.js 是基于 Node.js 的一个轻量级 web 应用框架，因而了解并安装 Node.js 是迈入 Express.js 世界的第一步。

1. 下载 Node.js

a. 访问官方网站

首先，我们需要访问 Node.js 的官方网站，下载合适的安装程序。打开浏览器，输入以下网址：

1

https://nodejs.org/

在首页上，你会看到两个版本的下载链接：

• LTS（长期支持版）：推荐用于生产环境，稳定性高。
• Current（当前版）：包含最新的功能，适用于希望尝试最新特性的开发者。

推荐选择 LTS 版本，点击相应的下载链接。

b. 安装 Node.js

下载完成后，双击安装程序。安装过程通常包括以下步骤：

1. 接受许可协议：在安装向导中，阅读并接受许可协议。
2. 选择安装路径：可以选择默认安装路径，或者自定义一个路径。
3. 选择组件：通常可以保留默认设置，点击“下一步”继续。
4. 安装：点击“安装”按钮，在系统上安装 Node.js。

安装完成后，确保选择了“安装 npm”选项，npm（Node Package Manager）是随 Node.js 一起安装的包管理工具，用于方便地管理 JavaScript 库、框架和工具。

2. 验证安装

完成安装后，我们需要验证 Node.js 是否安装成功。在命令行中输入以下命令：

1

node -v

这会返回已安装的 Node.js 版本号，例如：

1

v16.13.0

接下来，我们可以检查 npm 的版本，确认它也已成功安装：

1

npm -v

同样，这会返回已安装的 npm 版本号，例如：

1

8.1.0

如果这两条命令都能返回版本号，说明 Node.js 和 npm 已经成功安装在你的系统上。

3. 第一个 Node.js 应用

为了进一步验证安装，我们可以创建一个简单的 Node.js 应用。打开命令行，创建一个新的目录用于存放我们的项目，例如：

1
2

mkdir my-node-app
cd my-node-app

接下来，在这个目录中创建一个名为 app.js 的文件，并添加以下代码：

1
2

// app.js
console.log("Hello, Node.js!");

在命令行中运行这个文件：

1

node app.js

你将看到输出：

1

Hello, Node.js!

这表明你已经成功地运行了第一个 Node.js 应用。

小结

在本节中，我们完成了 Node.js 的安装，并通过一个简单的程序验证了安装的成功。接下来，我们将继续进行 Express.js 的安装，并开始构建我们的第一个 web 应用。

• 下一篇主题：环境搭建之2.2 Express.js安装

在上一节中，我们介绍了如何安装 Node.js，它是我们使用 Express.js 的基础。现在我们将进行 Express.js 的安装。这是构建 web 应用程序的关键步骤，让我们一起开始吧！

1. 创建项目目录

首先，您需要创建一个新的项目目录。这可以通过以下命令在终端中完成：

1
2

mkdir my-express-app
cd my-express-app

在此示例中，我们创建了一个名为 my-express-app 的新目录，并进入该目录。

2. 初始化 npm 项目

在安装 Express.js 之前，我们需要初始化一个 npm 项目。这可以通过运行以下命令在项目目录中完成：

1

npm init -y

这里的 -y 标志将使用默认配置初始化项目。执行此命令后，将会在项目目录中生成一个名为 package.json 的文件，该文件用于跟踪项目的依赖和配置信息。

3. 安装 Express.js

现在，您可以安装 Express.js。在命令行中运行以下命令：

1

npm install express --save

• express 是我们要安装的框架。
• --save 标志会将 express 作为依赖项添加到 package.json 文件中。

安装完成后，您将看到 node_modules 目录的创建，其中包含了 express 的所有依赖项。此外，package.json 文件的 dependencies 部分会更新，列出 express 的版本信息。

4. 创建基本的 Express.js 应用

现在，您已经成功安装了 Express.js，接下来，让我们创建一个基本的 Express.js 应用。

在项目目录中，创建一个名为 app.js 的文件，并添加以下代码：

1
2
3
4
5
6
7
8
9
10
11

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

在这个例子中，我们做了以下几件事：

1. 引入了 express 模块。
2. 创建了一个 Express 应用实例。
3. 设置了一个路由，当有人访问根路径 / 时，返回 Hello World!。
4. 启动应用并监听指定的端口。

5. 启动应用

您可以通过在终端中运行以下命令来启动应用：

1

node app.js

成功启动后，您将看到一条消息，告诉您服务器正在运行。

现在，在浏览器中打开 http://localhost:3000，您应该会看到显示 Hello World! 的页面。

6. 结论

在本节中，我们学习了如何安装 Express.js 并创建一个基本的应用。我们创建了项目目录，初始化了 npm 项目，安装了 Express，并编写了用于响应 HTTP 请求的代码。

在下一节中，我们将讨论如何选择适合的 IDE，以帮助您更高效地进行开发工作。希望通过这一系列的教程，您能逐步建立起对 Express.js 的理解和应用能力！

在进行Express.js开发之前，选择一个合适的集成开发环境（IDE）是非常重要的。一个好的IDE不仅能提高开发效率，还能提升代码质量和可维护性。在本节中，我们将讨论一些常见的IDE及其优缺点，以帮助你做出选择。

常见的IDE选择

Visual Studio Code

Visual Studio Code（VS Code）是目前最为流行的代码编辑器之一。它由微软开发，具有许多强大的功能，适合各种规模的项目开发。

优点：

• 轻量级: 启动迅速，运行流畅。
• 插件丰富: 拥有大量的插件支持，包括对JavaScript和Node.js的完美支持，比如ESLint、Prettier以及Debugger for Chrome等。
• 内置终端: 可以在IDE里直接运行命令，便于快速调试和运行脚本。
• Git集成: 集成了Git版本控制，使得代码管理更加方便。

示例配置

以配置ESLint为例，你可以在VS Code的扩展栏中搜索并安装ESLint插件。安装完成后，在你的项目根目录下创建一个.eslintrc.js文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

module.exports = {
    env: {
        browser: true,
        es2021: true,
        node: true,
    },
    extends: 'eslint:recommended',
    parserOptions: {
        ecmaVersion: 12,
    },
    rules: {
        indent: ['error', 4],
        'linebreak-style': ['error', 'unix'],
        quotes: ['error', 'single'],
        semi: ['error', 'always'],
    },
};

WebStorm

WebStorm是一个由JetBrains公司开发的强大IDE，专门针对JavaScript和前端开发，提供了丰富的开发工具和特性。

优点：

• 智能代码补全: 提供高级代码补全和重构能力，帮助开发者提升工作效率。
• 内置调试器: 强大的调试功能，支持Node.js及浏览器调试，非常适合进行Express.js开发。
• 版本控制支持: 内置Git支持，便于进行代码管理。

缺点：

• 收费: WebStorm是付费软件，虽然可以试用，但长期使用需要购买许可证。
• 较重: 相比VS Code稍微显得笨重，启动速度会慢一些。

Sublime Text

Sublime Text是一款跨平台的文本编辑器，因其简洁和高效受到了不少开发者的青睐。虽然它是一款文本编辑器，但也可以通过插件进行扩展。

优点：

• 快速: 启动和运行速度非常快。
• 高度可定制: 用户可以通过插件和主题进行个性化配置。

缺点：

• 功能有限: 相比VS Code和WebStorm，内置的功能较少，依赖插件。
• 不便于调试: 尤其在调试Node.js应用时不够方便。

选择的建议

• 如果你是初学者，Visual Studio Code是非常推荐的选择，因为它上手简单且功能强大，不需要过多的配置。
• 如果你已经对JavaScript开发有所了解，并且需要更强大的功能、智能提示和调试支持，可以考虑WebStorm。
• 如果你偏好轻量级和快速的文本编辑，可以选择Sublime Text，但在功能上可能需要依赖额外的配置和插件。

通过选择合适的IDE，你可以更专注于代码的编写和开发，提高开发效率。在这一章节中，我们讨论了IDE的选择和它们的优缺点，这将为后续创建你的第一个Express应用打下良好的基础。接下来的章节将引导你完成项目结构的建立与初始化。

在上篇中，我们讨论了如何选择合适的IDE以便高效地进行开发。在本篇中，我们将继续深入，创建一个基本的Express项目结构，为后续的开发打下坚实的基础。我们将逐步引导你如何组织文件和目录，使之便于维护和扩展。

3.1 创建基本项目结构

在开始之前，请确保你已经完成了环境搭建，并且已经安装了Node.js和npm（Node.js的包管理工具）。接下来，我们将创建一个新的Express项目，并构建其基本结构。

1. 创建项目目录

首先，打开终端（Terminal），并选择一个合适的位置来创建你的项目。可以使用以下命令创建一个名为 my-express-app 的新目录：

1
2

mkdir my-express-app
cd my-express-app

2. 初始化npm项目

接下来，我们需要通过npm初始化项目。运行以下命令：

1

npm init -y

-y选项会接受所有默认设置。完成后，你将在项目目录中看到一个名为 package.json 的文件，这个文件用于管理项目的依赖和配置信息。

3. 安装Express框架

现在，我们可以安装Express。运行以下命令来安装Express：

1

npm install express

安装完成后，你会在 node_modules 目录中看到Express及其依赖项，并且 package.json 文件也会更新。

4. 创建基本文件结构

接下来，我们需要创建一些基本的文件和目录，以便于后续的开发。我们可以创建如下文件结构：

1
2
3
4
5
6
7
8

my-express-app/
├── node_modules/
├── public/
├── routes/
│   └── index.js
├── views/
├── app.js
└── package.json

• node_modules/：这个目录由npm自动创建，用于存放所有的依赖包。
• public/：用于存放静态资源，例如CSS文件、JavaScript文件和图片等。
• routes/：用于存放路由文件，例如处理不同URL请求的Express路由。
• views/：用于存放视图模板文件，如果你使用模板引擎（如EJS或Pug）来渲染HTML。
• app.js：主应用程序文件，将在这里设置Express应用。
• package.json：项目的配置信息和依赖。

5. 创建主应用文件

在项目的根目录下，创建一个名为 app.js 的文件。可以使用你选择的IDE或文本编辑器来创建文件。然后在 app.js 文件中添加以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

const express = require('express');
const path = require('path');

const app = express();

// 设置静态文件目录
app.use(express.static(path.join(__dirname, 'public')));

// 路由设置
app.get('/', (req, res) => {
    res.send('Hello World!');
});

// 导出应用
module.exports = app;

在这个简单的Express应用中，我们做了以下几件事情：

• 引入了Express模块，并初始化了一个Express应用。
• 设置了静态文件目录，通过 express.static 中间件来提供静态文件服务。
• 创建了一个简单的路由，当根路径 / 被访问时，返回 “Hello World!”。

6. 总结

到此为止，我们已经成功创建了一个基本的项目结构，并编写了我们的第一个Express应用程序的主要文件。在接下来的章节中，我们将启动这个服务器，并进行更多的功能扩展。

希望本章内容对你理解Express应用的基本结构是有帮助的。请继续关注下一篇文章，我们将讨论如何启动服务器并使我们的应用在线运行。

在上一个部分中，我们创建了基本的项目结构，并添加了一些初始文件。现在，我们将开始真正的旅程：启动我们的第一个 Express 应用服务器。

1. 安装依赖

在开始之前，我们需要确保已经安装了 Express。如果还没有安装，可以使用以下命令进行安装：

1

npm install express

确保您在项目的根目录下运行这个命令，这个目录下应该包含您的 package.json 文件。

2. 创建服务器代码

在项目根目录下，我们通常会创建一个名为 app.js（或者 index.js 等）的文件，作为我们 Express 应用的入口文件。打开或创建 app.js，然后添加以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

const express = require('express'); // 引入Express模块
const app = express(); // 创建Express应用实例

const PORT = process.env.PORT || 3000; // 设置端口，优先使用环境变量中的PORT

// 定义一个根路由
app.get('/', (req, res) => {
    res.send('Hello, Express!'); // 当访问根路由时返回这个消息
});

// 启动服务器
app.listen(PORT, () => {
    console.log(`服务器正在 http://localhost:${PORT} 上运行...`); // 输出服务器运行信息
});

代码讲解

• const express = require('express');: 我们首先引入了 Express 模块。
• const app = express();: 通过 express() 方法创建了一个 Express 应用实例。
• const PORT = process.env.PORT || 3000;: 我们设置一个变量PORT，它优先使用环境变量中的 PORT，如果没有设置，则使用 3000 作为默认端口。
• app.get('/', (req, res) => { ... });: 我们为根路由定义了一个处理函数，当用户访问主页面时会返回 Hello, Express! 字符串。
• app.listen(PORT, () => { ... });: 启动服务器并监听指定端口，服务器启动后会在控制台输出运行信息。

3. 启动服务器

现在，我们可以通过以下命令来启动我们的服务器：

1

node app.js

如果一切正常，你将在控制台看到类似如下信息：

1

服务器正在 http://localhost:3000 上运行...

访问应用

打开你的网页浏览器，输入 http://localhost:3000，你应该可以看到页面上显示了 Hello, Express! 字样，这表示我们的 Express 应用已经成功启动并在运行。

4. 错误处理

在启动服务器的过程中，可能会遇到一些常见错误。以下是一些调试小技巧：

• 端口被占用: 如果你看到错误信息提示端口已经被占用，可以尝试更改 PORT 变量的值为其他未被使用的端口（如 3001）。
• 语法错误: JavaScript 语法错误会导致应用无法启动。请仔细检查代码，查看控制台中是否有指向错误行的提示。

5. 小结

到目前为止，我们创建了一个简单的 Express 应用并成功启动了服务器。这个过程中，我们了解了如何设置基本的路由和启动一个服务器。在下一节中，我们将对这个应用进行测试，确保它可以正确响应请求。

继续期待下一篇教程，我们将深入探索如何对应用进行测试，让这个小项目更加完整和稳定。

在前一章中，我们成功启动了我们的第一个 Express 服务器，现在我们将对其进行基本的测试，以确保它能够按照我们的预期工作。在本节中，我们会介绍如何通过不同的方法来测试我们的 Express 应用，包括手动测试和自动化测试。

手动测试

手动测试是验证我们的应用是否正常工作的一种直接方法。在本例中，我们将使用浏览器或命令行工具（如 curl）来访问我们之前创建的 GET 接口。

使用浏览器手动测试

假设您的应用运行在 http://localhost:3000，您可以在浏览器中输入以下 URL：

1

http://localhost:3000

如果一切正常，您应该会看到一个简单的欢迎信息，如：

1

Hello, World!

此时，您已经手动测试了您的 Express 应用。

使用 curl 命令手动测试

除了浏览器，您还可以使用 curl 在终端中测试您的应用。打开终端并输入：

1

curl http://localhost:3000

如果应用设置正确，您应该看到与浏览器中相同的 Hello, World! 输出。

自动化测试

对于更复杂的应用，手动测试可能不够高效，因此我们需要依靠自动化测试。这里我们将使用一个热门的测试框架 Mocha 和一个断言库 Chai 来进行自动化测试。

设置测试环境

首先，我们需要安装 Mocha 和 Chai。在项目根目录下运行以下命令：

1

npm install mocha chai --save-dev

接下来，我们需要创建一个测试目录和文件。通常我们在项目根目录下创建一个 test 文件夹，并在其中创建一个测试文件，例如 app.test.js。

您的项目结构应如下所示：

1
2
3
4
5
6

your-project/
├── node_modules/
├── package.json
├── app.js
└── test/
    └── app.test.js

编写测试代码

在 test/app.test.js 文件中，我们可以编写如下测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../app'); // 引入我们的 Express 应用
const expect = chai.expect;

chai.use(chaiHttp);

describe('GET /', function() {
    it('应该返回 Hello, World!', function(done) {
        chai.request(app)
            .get('/')
            .end(function(err, res) {
                expect(res).to.have.status(200);
                expect(res.text).to.equal('Hello, World!');
                done();
            });
    });
});

在这个测试中，我们使用 chai-http 插件来发送一个 GET 请求到根路径 /，并验证返回的 HTTP 状态码是否为 200，以及返回的文本是否为 Hello, World!。

运行测试

在 package.json 文件中，您需要添加一个测试脚本。例如：

1
2
3

"scripts": {
    "test": "mocha"
}

现在，您可以运行 npm test 来执行您的测试：

1

npm test

若一切正常，您应该看到类似如下的输出：

1
2
3
4

GET /
  ✓ 应该返回 Hello, World!

 1 passing (10ms)

通过运行测试，您可以确认您的应用逻辑是正确的。

小结

在这一节中，我们通过手动测试和自动化测试两种方式对我们的 Express 应用进行了基本的测试。手动测试可以快速验证接口是否正常，而自动化测试则可以随着应用的迭代而高效地保证程序的稳定性。在接下来的章节中，我们将进入更复杂的内容，探索如何定义路由来处理不同的请求。

接下来，我们将在第四章中学习如何为应用定义路由，敬请期待！

在上篇中，我们学习了如何创建第一个Express应用，并进行了简单的测试。在这一章中，我们将深入探讨如何在Express中定义和管理路由。路由是构建Web应用的核心部分，它决定了用户如何访问应用的不同部分和功能。让我们一起看看在Express中如何定义路由。

什么是路由？

在Web应用中，”路由”是指用来处理特定URL请求的定义。通过路由，应用可以将请求分发到相应的处理函数，以生成所需的响应。使用Express，定义路由非常简单且直观。

定义路由的基本方式

在Express中，我们可以使用app.get()、app.post()、app.put()、app.delete()等方法来定义不同类型的HTTP请求的路由。例如，我们可以定义一个GET请求的简单路由，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13

const express = require('express');
const app = express();
const port = 3000;

// 定义一个简单的GET路由
app.get('/', (req, res) => {
  res.send('欢迎来到我的Express应用！');
});

// 启动服务器
app.listen(port, () => {
  console.log(`应用正在监听 http://localhost:${port}`);
});

在上面的代码中，我们创建了一个基本的Express应用，并使用app.get()方法定义了一个根路由。当用户访问根URL(/)时，应用会响应“欢迎来到我的Express应用！”。

定义多个路由

在实际应用中，我们通常需要定义多个路由来处理不同的URL请求。例如，以下代码展示了如何定义多个GET路由：

1
2
3
4
5
6
7
8
9

// 定义一个关于路由
app.get('/about', (req, res) => {
  res.send('这是关于页面！');
});

// 定义联系路由
app.get('/contact', (req, res) => {
  res.send('这是联系页面！');
});

在上述示例中，我们添加了两个新的路由：/about和/contact。当访问这些路径时，应用会分别返回关于页面和联系页面的内容。

使用路由处理函数

路由处理函数可以接受三个参数：req（请求对象）、res（响应对象）和next（用于调用下一个中间件函数）。在大多数情况下，我们只需要req和res。下面是一个例子，展示了如何使用请求对象和响应对象：

1
2
3
4

app.get('/user', (req, res) => {
  const userId = req.query.id; // 从查询参数中获取用户ID
  res.send(`用户ID是: ${userId}`);
});

在这个例子中，我们创建了一个路由/user，它可以接受一个查询参数id。用户通过访问如/user?id=123的链接时，应用会返回“用户ID是: 123”。

中间件与路由

Express允许我们在路由中使用中间件，这为处理请求提供了更多的灵活性。例如，我们可以使用中间件来记录请求信息：

1
2
3
4

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next(); // 继续处理请求
});

在这个示例中，定义了一个中间件函数，用于记录每个请求的HTTP方法和URL。next()函数会将控制权传递给下一个中间件或路由处理程序。

总结

在本节中，我们探索了如何在Express中定义路由。从定义简单的路由到处理多个路由，以及如何使用中间件，我们掌握了一些基本的路由概念。正确地定义路由是构建高效的Web应用的关键，掌握这些要素将为你在后续的章节中学习路由参数等内容打下基础。

在下一章中，我们将继续深入学习如何使用路由参数来处理动态路径。

在本节中，我们将深入探讨 Express.js 中的路由参数。路由参数为我们创建动态和灵活的路由提供了强大的支持。通过路由参数，我们可以定义 URL 中的可变部分，并在处理请求时提取这些参数。

1. 什么是路由参数

路由参数 是在路由定义中指定的路径部分，它以冒号（:）开头。这些参数在请求到达服务器时会被解析，并可以在处理请求的回调函数中访问。

例如，在访问路径 /users/:userId 时，:userId 就是一个路由参数。如果用户请求 /users/42，那么 userId 的值将是 42。

2. 如何定义路由参数

在 Express.js 中，我们可以通过简单的语法来定义路由参数。以下是一个基本的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13

const express = require('express');
const app = express();

// 定义路由，带有路由参数
app.get('/users/:userId', (req, res) => {
    const userId = req.params.userId; // 从请求中提取参数
    res.send(`用户ID是: ${userId}`);
});

// 启动服务器
app.listen(3000, () => {
    console.log('服务器运行在 http://localhost:3000');
});

在这个例子中，当用户访问 http://localhost:3000/users/42 时，服务器将响应 用户ID是: 42。

3. 路由参数的多个值

路由参数也可以包含多个值。我们可以在路由中定义多个参数，如下所示：

1
2
3
4
5

app.get('/products/:productId/reviews/:reviewId', (req, res) => {
    const productId = req.params.productId;
    const reviewId = req.params.reviewId;
    res.send(`产品ID是: ${productId}, 评论ID是: ${reviewId}`);
});

在这个示例中，如果用户访问 http://localhost:3000/products/101/reviews/5，那么响应将是 产品ID是: 101, 评论ID是: 5。

4. 路由参数的匹配

Express.js 支持多种路由参数匹配。以下是几个示例：

• 只匹配数字：如果我们只想匹配数字，可以使用正则表达式。在路由定义中以 (:param) 的形式指明：

1
2
3

app.get('/posts/:postId(\\d+)', (req, res) => {
    res.send(`这是编号为 ${req.params.postId} 的帖子`);
});

在此示例中，只有数字形式的 postId 会被匹配。如果用户访问 /posts/abc，将不会匹配到这个路由。

• 可选参数：使用 ? 可以定义可选的路由参数：

1
2
3
4
5

app.get('/search/:query?/:page?', (req, res) => {
    const query = req.params.query || '无查询'; 
    const page = req.params.page || 1;
    res.send(`查询为: ${query}, 当前页面: ${page}`);
});

如果用户只访问 /search/test，则 页面 参数将会被默认设置为 1。

5. 提取路由参数的常用方法

在 Express.js 中，提取 路由参数 的主要方法是使用 req.params 对象。在这个对象中，路由参数的名称作为属性，参数值则为其对应的值。如下示例：

1
2
3
4

app.get('/users/:username', (req, res) => {
    const { username } = req.params; // 解构赋值
    res.send(`欢迎, ${username}!`);
});

在访问 /users/JohnDoe 时，结果将会是 欢迎, JohnDoe!。

6. 总结

在本节中，我们学习了 路由参数 的定义和使用方式。路由参数允许我们创建更灵活的路由，能够处理动态请求，同时提取重要的信息用于后续处理。在下一节中，我们将进一步探索如何实现 动态路由，以便使我们的路由更加强大和智能。

希望本节能够帮助你更好地理解 Express.js 的路由参数特性。请继续关注接下来的内容，我们将一起深入学习动态路由的实现与应用。

在前一章中，我们讨论了如何使用路由参数来提取和使用不同的请求参数。继续我们的旅程，本章将深入探讨 动态路由 的概念，以及如何在 Express.js 中使用它们来构建灵活的应用程序。

什么是动态路由

动态路由允许我们在 URL 中定义一些可变的部分。这使得 API 能够处理不同的请求而无需为每个 URL 都创建单独的路由。例如，我们可以创建一个动态路由来获取用户信息，通过用户的 ID 来实现。

创建动态路由

在 Express.js 中，我们可以使用冒号 : 来定义动态路由参数。以下是一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

const express = require('express');
const app = express();
const PORT = 3000;

// 动态路由示例
app.get('/users/:id', (req, res) => {
    // 获取路由参数
    const userId = req.params.id;
    res.send(`用户ID是: ${userId}`);
});

app.listen(PORT, () => {
    console.log(`服务器在 http://localhost:${PORT} 上运行`);
});

在上面的例子中，路由 '/users/:id' 是一个动态路由。当我们通过 URL /users/123 访问它时，req.params.id 将包含 123，并且响应将会显示 用户ID是: 123。

结合案例的详细解析

假设我们正在构建一个简单的用户管理系统，我们希望能够通过用户 ID 来获取用户的详细信息。我们可以扩展刚才的代码，并假设我们有一个简单的用户数据存储（例如一个对象数组）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

const express = require('express');
const app = express();
const PORT = 3000;

// 模拟用户数据
const users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' },
    { id: 3, name: 'Charlie' },
];

// 动态路由
app.get('/users/:id', (req, res) => {
    const userId = parseInt(req.params.id);
    const user = users.find(u => u.id === userId);
    
    if (user) {
        res.send(`用户ID是: ${user.id}, 用户名是: ${user.name}`);
    } else {
        res.status(404).send('用户未找到');
    }
});

app.listen(PORT, () => {
    console.log(`服务器在 http://localhost:${PORT} 上运行`);
});

在这个例子中，我们首先定义了一个 users 数组来模拟用户数据。当我们访问 URL /users/1 时，服务器将返回 用户ID是: 1, 用户名是: Alice。如果用户未找到，返回 404 状态和错误信息 用户未找到。

复杂的动态路由

动态路由不仅限于单个参数，也可以有多个参数以及参数的组合。例如，我们可以创建一个动态路由来处理包含 地区 和 类型 的请求。

1
2
3
4
5

app.get('/products/:category/:id', (req, res) => {
    const category = req.params.category;
    const productId = req.params.id;
    res.send(`商品分类: ${category}, 商品ID: ${productId}`);
});

这里，路由 '/products/:category/:id' 使得我们能够通过 URL /products/electronics/1001 来提取 category 和 id 两个参数。

总结

通过本章的学习，我们了解了如何在 Express.js 中使用动态路由，以及它们如何帮助我们构建灵活而强大的 API。动态路由能够有效地处理不同的请求，使我们的应用程序更加可扩展。接下来，我们将转向中间件，探索它们的定义及其在 Express.js 中的应用。

希望本章的内容能够帮助你更好的理解和使用动态路由！