1. 安装好node、parcel、yarn和VSCode及插件Fitten Code等工具，复习Node.js创建第一个应用，代码和简述写入实验报告
2. 根据 https://www.runoob.com/nodejs/nodejs-tutorial.html 学习REPL，回调函数、事件循环，代码和简述写入实验报告
3. 内容9-20，自选3个的代码和简述写入实验报告
4. 内容21-26，自选3个的代码和简述写入实验报告
5. 百度里输入 “node.js写一个简单CMS”根据提示完成调试，记录过程并写入实验报告

2.创建第一个Node.js代码

2.1 安装 VSCode 和所需插件

下载并安装 VSCode。
打开 VSCode 后，建议安装以下插件：
- Fitten Code：代码优化工具。
- ESLint：JavaScript 代码检查工具。
- Prettier：代码格式化工具。

2.2 安装 Node.js 和 Yarn

安装 Node.js，可以使用默认设置完成安装。安装完成后，您可以在终端中输入 node -v，确保安装成功。
安装 Yarn 包管理工具，使用以下命令：

npm install -g yarn

2.3 创建 Node.js 项目

2.3.1 在 VSCode 中打开一个新文件夹

点击 "File" -> "Open Folder..."，选择一个空文件夹，作为项目的根目录。

2.3.2 初始化 Node.js 项目

打开 VSCode 的终端（可以通过菜单栏中的 "Terminal" -> "New Terminal" 来打开），输入以下命令来初始化一个新的项目：

yarn init -y
这会生成一个 package.json 文件，用于管理项目的依赖项。

2.3.3 安装 Express

在终端中输入以下命令来安装 Express.js 作为 Web 框架：

yarn add express

2.4 编写 Node.js 应用

2.4.1 创建主文件

在项目根目录下，创建一个名为 app.js 的文件，编写以下代码：

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

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

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

2.4.2 运行应用

在 VSCode 终端中运行以下命令启动 Node.js 应用：

node app.js
您将在终端中看到提示 Server is running at http://localhost:3000。现在，您可以在浏览器中访问 http://localhost:3000，会看到页面显示 Hello, Node.js from VSCode!。

2.5 使用 Parcel 自动化开发 (可选，做了解)

如果希望更方便地进行开发，可以使用 Parcel 来自动刷新页面。

2.4.1 项目结构

project-root/
│
├── app.js (服务器端代码,注意前面的是服务端)
├── public/ (存放前端文件)
│ ├── index.html (前端 HTML 文件)
│ └── app.js (前端 JavaScript 文件)
└── node_modules/ (依赖包)

2.5.2 安装 Parcel

在 VSCode 终端中输入：

yarn global add parcel-bundler

2.5.3 配置 Parcel

在项目目录下创建一个 index.html 文件，内容如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Node.js with Parcel</title>
</head>
<body>
    <script src="./app.js"></script>
</body>
</html>

2.5.4 启动 Parcel

Parcel 会自动打包文件并在浏览器中显示结果，您无需每次手动刷新页面。

在终端中使用以下命令启动 Parcel 进行开发：

parcel index.html

2.6 简述

通过使用 VSCode 创建并运行 Node.js 应用，我们能够快速搭建一个 Web 服务。整个过程涵盖了环境配置、项目初始化、开发工具安装和调试等核心步骤。

3.REPL、回调函数、事件循环

3.1 REPL（Read-Eval-Print Loop）

REPL 是 Node.js 提供的一个交互式环境，用于执行 JavaScript 代码。

3.1.1 代码示例：

$ node
> const x = 10;
> const y = 20;
> x + y
30

3.1.2 简述：

Read：读取用户输入。
Eval：执行输入的代码。
Print：打印执行结果。
Loop：等待用户输入新的指令。

REPL 常用于测试小段代码或简单逻辑。

3.2 回调函数（Callback Function）

3.2.1 代码示例：

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        return console.error(err);
    }
    console.log('文件内容:', data);
});

3.2.2 简述：

回调函数是一种异步编程的实现方式，它作为参数传递给另一个函数，并在操作完成时调用。
上述代码展示了如何使用 fs.readFile() 异步读取文件。当文件读取完成后，Node.js 会调用提供的回调函数，并传入读取结果或错误信息。

3.3 事件循环（Event Loop）

3.3.1 代码示例：

console.log('Start');

setTimeout(() => {
    console.log('Timeout');
}, 1000);

console.log('End');

3.3.2 简述：

事件循环是 Node.js 处理异步操作的机制。JavaScript 本身是单线程的，但事件循环允许它管理异步任务，如 I/O 操作、计时器等。
在上述代码中，console.log('Start') 和 console.log('End') 会立即执行。而 setTimeout() 设定的回调函数则会在 1 秒后通过事件循环执行。

3.4 总结

REPL 是一个快速测试 JavaScript 代码的交互环境。
回调函数 是 Node.js 中处理异步操作的核心，通过将函数作为参数传递来实现任务的延迟执行。
事件循环 则确保异步代码按顺序执行，并避免阻塞主线程。

4. 内容 9-26

4.1 Node.js EventEmitter

4.1.1 用途及能做什么：

实现 事件驱动编程，在应用程序中基于事件来触发逻辑执行。
适用于 用户操作反馈、资源加载完成事件或 异步任务完成后的通知。

4.1.2 解决的问题：

解耦逻辑：将复杂逻辑拆分成多个事件处理程序，提高代码灵活性和可维护性。

4.1.3代码示例：

const events = require('events'); // 引入事件模块
const eventEmitter = new events.EventEmitter(); // 创建事件发射器

// 监听事件 'message'，并定义事件触发时的回调
eventEmitter.on('message', (msg) => {
    console.log(`收到消息: ${msg}`);
});

// 触发 'message' 事件，并传递消息
eventEmitter.emit('message', '你好，Node.js!');

4.1.4 代码解释：

require('events')：引入 Node.js 的事件模块。
new EventEmitter()：创建一个事件发射器实例。
.on()：监听特定事件并绑定回调函数。
.emit()：触发事件，并将参数传递给事件处理函数。

4.2 Node.js Buffer

4.2.1 用途及能做什么：

处理 二进制数据，适用于文件、图片、音频和视频流等。
在网络传输时，数据通常以二进制形式传递，Buffer 是处理这些数据的核心工具。

4.2.2 解决的问题：

JavaScript 不支持直接操作二进制数据，Buffer 让你可以处理二进制文件和网络数据流。

4.2.3 代码示例：

const buffer = Buffer.from('Hello, Buffer!'); // 将字符串转换为 Buffer
console.log('Buffer 内容:', buffer); // 打印 Buffer 数据
console.log('转换为字符串:', buffer.toString()); // 将 Buffer 转换回字符串

4.2.4 代码解释：

Buffer.from()：将字符串转换为二进制 Buffer 数据。
console.log()：输出 Buffer 数据，显示其内容。
.toString()：将 Buffer 还原为可读的字符串。

4.3 Node.js Stream

4.3.1 用途及能做什么：

处理大文件和实时数据流，避免一次性加载所有数据到内存中。
常用于文件读写、网络请求和媒体流传输。

4.3.2 解决的问题：

避免内存耗尽：Stream 通过分段处理数据，提升应用性能。

4.3.3 代码示例：

const fs = require('fs'); // 引入文件系统模块
const readStream = fs.createReadStream('input.txt'); // 创建读取流
const writeStream = fs.createWriteStream('output.txt'); // 创建写入流

// 使用管道传递数据
readStream.pipe(writeStream);
console.log('文件流处理完成');

4.3.4 代码解释：

createReadStream()：逐步读取文件内容，避免一次性加载。
createWriteStream()：逐步写入文件，提高性能。
.pipe()：将读取流的数据传输到写入流。

4.4 Node.js 模块系统

4.4.1 用途及能做什么：

组织代码为多个模块，提高代码的复用性和可维护性。
支持引入第三方模块和自定义模块。

4.4.2 解决的问题：

避免代码冗余，使大型应用更易于维护和扩展。

4.4.3 代码示例：

math.js:

exports.add = (a, b) => a + b;

app.js:

const math = require('./math'); // 引入自定义模块
console.log(`1 + 2 = ${math.add(1, 2)}`);

代码解释：

exports：导出模块中的函数。
require()：引入模块，并使用模块中的函数。

4.5 Node.js 路由

4.5.1 用途及能做什么：

定义 请求路径与响应逻辑，适用于 Web 应用和 API 服务。

4.5.2 解决的问题：

管理不同页面或路径，使 Web 应用更易于维护和扩展。

4.5.3 代码示例：

const express = require('express'); // 引入 Express 框架
const app = express(); // 创建 Express 应用

// 定义首页路由
app.get('/', (req, res) => res.send('欢迎访问首页'));

// 定义关于页面路由
app.get('/about', (req, res) => res.send('关于我们'));

app.listen(3000, () => console.log('服务器运行于 http://localhost:3000'));

4.5.4 代码解释：

express()：创建 Express 应用实例。
app.get()：定义 GET 请求路由。
res.send()：发送响应内容。

4.6 Node.js 全局对象

4.6.1 用途及能做什么：

提供 常用的全局工具，如文件路径和计时器。

4.6.2 解决的问题：

简化开发任务，无需重复引入常见工具模块。

4.6.3 代码示例：

console.log('当前文件:', __filename);
setTimeout(() => console.log('3秒后执行'), 3000);

4.6.3 代码解释：

__filename：获取当前文件的绝对路径。
setTimeout()：延迟执行回调函数。

4.7 Node.js RESTful API

4.7.1 用途及能做什么：

实现 客户端和服务器之间的数据交互。

4.7.2 解决的问题：

提供标准化的接口，支持前后端分离开发。

4.7.3 代码示例：

const express = require('express');
const app = express();
app.use(express.json());

let users = [{ id: 1, name: 'Alice' }];

app.get('/users', (req, res) => res.json(users));
app.post('/users', (req, res) => {
    const newUser = req.body;
    users.push(newUser);
    res.status(201).json(newUser);
});

app.listen(3000, () => console.log('API 运行于 http://localhost:3000'));

4.7.4 代码解释：

app.use()：使用 JSON 解析中间件。
app.get()：定义 GET 请求路由，返回用户列表。
app.post()：定义 POST 请求路由，添加新用户。

4.8 Node.js 文件系统

4.8.1 用途及能做什么：

4.8.2 解决的问题：

实现应用与本地文件系统的交互。

4.8.3 代码示例：

const fs = require('fs');

fs.writeFile('test.txt', 'Hello, Node.js!', (err) => {
    if (err) throw err;
    console.log('文件已写入');
});

fs.readFile('test.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log('文件内容:', data);
});

4.8.4 代码解释：

fs.writeFile()：异步写入文件。
fs.readFile()：异步读取文件内容。

4.9 Node.js GET/POST 请求

4.9.1 用途及能做什么：

处理 HTTP 请求，支持客户端与服务器之间的数据交互。
GET 用于获取资源，POST 用于提交数据。

4.9.2 解决的问题：

提供基础的 Web 服务功能，支持数据的获取和提交。

4.9.3 代码示例：

const http = require('http'); // 引入 HTTP 模块

const server = http.createServer((req, res) => {
    if (req.method === 'GET') {
        res.end('GET 请求响应'); // 响应 GET 请求
    } else if (req.method === 'POST') {
        res.end('POST 请求响应'); // 响应 POST 请求
    }
});

// 启动服务器并监听端口 3000
server.listen(3000, () => console.log('服务器运行于 http://localhost:3000'));

4.9.4 代码解释：

http.createServer()：创建 HTTP 服务器。
req.method：检查请求的类型（GET 或 POST）。
res.end()：结束响应并发送数据给客户端。

4.10 Node.js 工具模块

4.10.1 用途及能做什么：

提供 加密、调试和格式化字符串 等常用工具。
适用于：开发安全性需求较高的应用，如用户身份验证和数据加密。

4.10.2 解决的问题：

简化日常开发任务，提供现成的加密和调试工具。

4.10.3 代码示例：

const crypto = require('crypto'); // 引入加密模块

const hash = crypto.createHash('sha256').update('Hello').digest('hex');
console.log('SHA256 哈希值:', hash);

4.10.4 代码解释：

crypto.createHash()：创建 SHA256 哈希对象。
.update()：向哈希对象添加数据。
.digest()：计算哈希值，并将其以十六进制格式输出。

4.11 Node.js Web 模块

4.11.1 用途及能做什么：

快速创建 Web 服务器，处理 HTTP 请求。
支持静态页面或动态内容的返回。

4.11.2 解决的问题：

让开发者无需复杂配置就能快速启动 Web 服务。

4.11.3 代码示例：

const http = require('http'); // 引入 HTTP 模块

http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/html' }); // 设置响应头
    res.end('<h1>Hello, World!</h1>'); // 返回 HTML 内容
}).listen(3000);

console.log('服务器运行于 http://localhost:3000');

4.11.4 代码解释：

http.createServer()：创建 HTTP 服务器。
res.writeHead()：设置响应头信息。
res.end()：返回响应内容，并结束请求。

4.12 Node.js Express 框架

4.12.1 用途及能做什么：

Express 是一个轻量级框架，用于构建 Web 应用和 API。
支持路由管理和中间件的灵活使用。

4.12.2 解决的问题：

简化了服务器开发流程，使路由管理更加方便。

4.12.3 代码示例：

const express = require('express'); // 引入 Express 框架
const app = express(); // 创建 Express 应用

app.get('/', (req, res) => res.send('Hello Express!')); // 定义 GET 请求路由

app.listen(3000, () => console.log('服务器运行于 http://localhost:3000'));

4.12.4 代码解释：

express()：创建 Express 应用实例。
app.get()：定义 GET 请求路由。
res.send()：发送响应内容。

4.13 Node.js 多进程

4.13.1 用途及能做什么：

创建 多个进程 执行任务，提高并发性能。
适用于 CPU 密集型任务 和 异步操作。

4.13.2 解决的问题：

避免单线程阻塞，提高应用的响应速度。

4.13.3 代码示例：

const { exec } = require('child_process'); // 引入子进程模块

exec('ls', (err, stdout, stderr) => {
    if (err) {
        console.error(`错误: ${stderr}`);
        return;
    }
    console.log(`输出: ${stdout}`);
});

4.13.4 代码解释：

exec()：执行系统命令，并返回结果。
stdout：输出命令执行的结果。
stderr：输出错误信息。

4.14 Node.js MySQL

4.14.1 用途及能做什么：

连接和操作 MySQL 数据库，执行查询和数据管理。
常用于 用户信息、订单管理和数据分析 系统。

4.14.2 解决的问题：

实现结构化数据的存储和查询。

4.14.3 代码示例：

const mysql = require('mysql'); // 引入 MySQL 模块

const connection = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: '',
    database: 'test'
});

connection.connect(); // 连接数据库

// 执行查询操作
connection.query('SELECT * FROM users', (err, results) => {
    if (err) throw err;
    console.log('用户数据:', results);
});

connection.end(); // 关闭连接

4.14.4 代码解释：

mysql.createConnection()：创建数据库连接。
connection.query()：执行 SQL 查询。
connection.end()：关闭数据库连接。

4.15 Node.js MongoDB

4.15.1 用途及能做什么：

连接 MongoDB 数据库，处理 文档型数据。
适用于 灵活的数据模型，如用户信息、传感器数据等。

4.15.2 解决的问题：

提供灵活的数据存储方式，适应不断变化的数据结构。

4.15.3 代码示例：

const { MongoClient } = require('mongodb'); // 引入 MongoDB 客户端
const url = 'mongodb://localhost:27017'; // MongoDB 连接地址
const client = new MongoClient(url); // 创建客户端实例

async function run() {
    await client.connect(); // 连接到 MongoDB
    const db = client.db('test'); // 选择数据库
    const users = await db.collection('users').find({}).toArray(); // 查询集合中的数据
    console.log('用户:', users); // 打印查询结果
    await client.close(); // 关闭连接
}

run().catch(console.error); // 捕获错误

4.15.4 代码解释：

MongoClient：创建用于连接 MongoDB 的客户端实例。
client.connect()：连接数据库。
db.collection()：选择数据库中的集合。
find().toArray()：查询数据并转换为数组。
client.close()：关闭数据库连接。

5.基于 Node.js 和 MySQL 的简易 CMS 系统开发

步骤 1：创建项目结构

simple-cms
├── models
│ └── article.js
├── routes
│ └── articles.js
├── views
│ ├── index.ejs
│ ├── articles
│ │ ├── new.ejs
│ │ ├── edit.ejs
│ │ └── show.ejs
├── config
│ └── database.js
├── app.js
└── package.json

步骤 2：安装依赖

执行以下命令初始化项目，并安装相关包：

npm install express mysql2 sequelize ejs body-parser

步骤 3：配置 MySQL 数据库连接

创建 `config/database.js`

const { Sequelize } = require('sequelize');

// 配置数据库连接
const sequelize = new Sequelize('simple_cms', 'root', 'password', {
  host: 'localhost',
  dialect: 'mysql',
});

module.exports = sequelize;

确保 MySQL 数据库中有一个名为 simple_cms 的数据库，并且 MySQL 服务已启动。

步骤 4：创建模型文件 `models/article.js`

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');

// 定义 Article 模型
const Article = sequelize.define('Article', {
  title: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  content: {
    type: DataTypes.TEXT,
    allowNull: false,
  },
  createdAt: {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW,
  },
});

module.exports = Article;

步骤 5：创建路由文件 `routes/articles.js`

const express = require('express');
const Article = require('../models/article');
const router = express.Router();

// 获取所有文章
router.get('/', async (req, res) => {
  const articles = await Article.findAll({ order: [['createdAt', 'DESC']] });
  res.render('index', { articles });
});

// 新建文章页面
router.get('/new', (req, res) => {
  res.render('articles/new', { article: {} });
});

// 显示单篇文章
router.get('/:id', async (req, res) => {
  const article = await Article.findByPk(req.params.id);
  if (!article) return res.redirect('/');
  res.render('articles/show', { article });
});

// 创建文章
router.post('/', async (req, res) => {
  const { title, content } = req.body;
  try {
    const article = await Article.create({ title, content });
    res.redirect(`/articles/${article.id}`);
  } catch (error) {
    res.render('articles/new', { article: { title, content } });
  }
});

// 编辑文章页面
router.get('/edit/:id', async (req, res) => {
  const article = await Article.findByPk(req.params.id);
  res.render('articles/edit', { article });
});

// 更新文章
router.post('/edit/:id', async (req, res) => {
  const { title, content } = req.body;
  try {
    await Article.update({ title, content }, { where: { id: req.params.id } });
    res.redirect(`/articles/${req.params.id}`);
  } catch (error) {
    res.redirect('/');
  }
});

// 删除文章
router.post('/delete/:id', async (req, res) => {
  try {
    await Article.destroy({ where: { id: req.params.id } });
    res.redirect('/');
  } catch (error) {
    res.redirect('/');
  }
});

module.exports = router;

步骤 6：创建主应用文件 `app.js`

const express = require('express');
const bodyParser = require('body-parser');
const articleRouter = require('./routes/articles');
const sequelize = require('./config/database');
const app = express();

// 设置模板引擎
app.set('view engine', 'ejs');

// 中间件
app.use(bodyParser.urlencoded({ extended: false }));
app.use('/articles', articleRouter);

// 数据库同步
sequelize.sync().then(() => console.log('Database synced'));

// 主页路由
app.get('/', (req, res) => {
  res.redirect('/articles');
});

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

步骤 7：创建模板文件

`views/index.ejs`

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Simple CMS</title>
</head>
<body>
  <h1>All Articles</h1>
  <a href="/articles/new">Create New Article</a>
  <ul>
    <% articles.forEach(article => { %>
      <li>
        <a href="/articles/<%= article.id %>"><%= article.title %></a>
      </li>
    <% }) %>
  </ul>
</body>
</html>

`views/articles/new.ejs`

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>New Article</title>
</head>
<body>
  <h1>Create a New Article</h1>
  <form action="/articles" method="POST">
    <input type="text" name="title" placeholder="Title" required />
    <textarea name="content" placeholder="Content" required></textarea>
    <button type="submit">Create</button>
  </form>
  <a href="/">Back to Home</a>
</body>
</html>

`views/articles/show.ejs`

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title><%= article.title %></title>
</head>
<body>
  <h1><%= article.title %></h1>
  <p><%= article.content %></p>
  <a href="/articles/edit/<%= article.id %>">Edit</a>
  <form action="/articles/delete/<%= article.id %>" method="POST" style="display:inline;">
    <button type="submit">Delete</button>
  </form>
  <a href="/">Back to Home</a>
</body>
</html>

`views/articles/edit.ejs`

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Edit Article</title>
</head>
<body>
  <h1>Edit Article</h1>
  <form action="/articles/edit/<%= article.id %>" method="POST">
    <input type="text" name="title" value="<%= article.title %>" required />
    <textarea name="content" required><%= article.content %></textarea>
    <button type="submit">Update</button>
  </form>
  <a href="/">Back to Home</a>
</body>
</html>