node笔记总结

一、fs模块

1.readFile()

const fs=require（‘fs‘）
fs.readFile() 方法读取文件
参数1：读取文件的存放路径
参数2：读取文件时候采用的编码格式，一般默认指定 utf8
参数3：回调函数，拿到读取失败和成功的结果 err dataStr
fs.readFile(‘./files/11.txt’, ‘utf8’, function(err, dataStr) {
// 2.1 打印失败的结果
// 如果读取成功，则 err 的值为 null
// 如果读取失败，则 err 的值为 错误对象，dataStr 的值为 undefined
console.log(err.message)//错误信息
console.log(‘-------’)
// 2.2 打印成功的结果
console.log(dataStr)
})

2.writeFile()

调用 fs.writeFile() 方法，写入文件的内容
参数1：表示文件的存放路径
参数2：表示要写入的内容
参数3：回调函数

fs.writeFile(‘./files/3.txt’, ‘ok123’, function(err) {
// 2.1 如果文件写入成功，则 err 的值等于 null
// 2.2 如果文件写入失败，则 err 的值等于一个 错误对象
// console.log(err)

if (err) {
return console.log(‘文件写入失败！’ + err.message)
}
console.log(‘文件写入成功！’)

二、path模块

1.路径拼接使用

join（）

const path = require(‘path’)
path.join(__dirname,’文件路径’)

__dirname表示当前文件夹下面 后面加，然后要拼接的路径

2.打印出最基本的文件名字

basename()

第一个参数：要处理的文件路径
第二个参数：要过滤的.****后缀名

const path = require(‘path’)

// 定义文件的存放路径
const fpath = ‘/a/b/c/index.html’

// const fullName = path.basename(fpath)
// console.log(fullName)

const nameWithoutExt = path.basename(fpath, ‘.html’)
console.log(nameWithoutExt)

-----index

3.打印出文件的后缀名

extname（）

const path = require(‘path’)

// 这是文件的存放路径
const fpath = ‘/a/b/c/index.html’

const fext = path.extname(fpath)
console.log(fext)
–html

三、http模块

1.创建基本的Web服务器

// 1. 导入 http 模块
const http = require(‘http’)
// 2. 创建 web 服务器实例
const server = http.createServer()
// 3. 为服务器实例绑定 request 事件，监听客户端的请求
server.on(‘request’, function (req, res) {
console.log(‘Someone visit our web server.’)
})
// 4. 启动服务器
server.listen(8080, function () {
console.log(‘server running at http://127.0.0.1:8080’)
})

2.req请求对象

// req 是请求对象，包含了与客户端相关的数据和属性
// req.url 是客户端请求的 URL 地址
// req.method 是客户端请求的 method 类型

3.解决中文乱码问题

res.setHeader(‘Content-Type’, ‘text/html; charset=utf-8’)

3.1解决中文乱码案例

const http = require('http')
const server = http.createServer()

server.on('request', (req, res) => {
  // 定义一个字符串，包含中文的内容
  const str = `您请求的 URL 地址是 ${req.url}，请求的 method 类型为 ${req.method}`
  // 调用 res.setHeader() 方法，设置 Content-Type 响应头，解决中文乱码的问题
  res.setHeader('Content-Type', 'text/html; charset=utf-8')
  // res.end() 将内容响应给客户端
  res.end(str)
})

server.listen(80, () => {
  console.log('server running at http://127.0.0.1')

四、模块化

1.内置模块

（内置模块是由 Node.js 官方提供的，例如 fs、path、http 等

2.自定义模块

// 注意：在使用 require 加载用户自定义模块期间，
// 可以省略 .js 的后缀名

注意导出的对象永远是module.exports

3.第三方模块

（由第三方开发出来的模块，并非官方提供的内置模块，也不是用户创建的自定义模块，使用前需要先下载

五、npm

1.npm命令

查看包版本号 ：npm-v
在项目中下载包：npm install 包的完整名称 简写 npm i包的完整名称

2.初次安装包之后多了的文件

node_modules 文件夹用来存放所有已安装到项目中的包。require() 导入第三方包时，就是从这个目录中查找并加载包。
package-lock.json 配置文件用来记录 node_modules 目录下的每一个包的下载信息，例如包的名字、版本号、下载地址等。

3.安装指定版本的包

默认情况下，使用 npm install 命令安装包的时候，会自动安装最新版本的包。如果需要安装指定版本的包，可以在包 名之后，通过 @ 符号指定具体的版本。

4.包的语义化版本规范

包的版本号是以“点分十进制”形式进行定义的，总共有三位数字，例如 2.24.0 其中每一位数字所代表的的含义如下：
第1位数字：大版本
第2位数字：功能版本
第3位数字：Bug修复版本
版本号提升的规则：只要前面的版本号增长了，则后面的版本号归零

5.包管理配置文件

npm 规定，在项目根目录中，必须提供一个叫做 package.json 的包管理配置文件。用来记录与项目有关的一些配置 信息。
例如：
⚫ 项目的名称、版本号、描述等
⚫ 项目中都用到了哪些包
⚫ 哪些包只在开发期间会用到
⚫ 那些包在开发和部署时都需要用

5.1为什么需要有这个？

第三方包的体积过大，不方便团队成员之间共享项目源代码。
解决方案：共享时剔除node_modules

在项目根目录中，创建一个叫做 package.json 的配置文件，即可用来记录项目中安装了哪些包。从而方便剔除 node_modules 目录之后，在团队成员之间共享项目的源代码。
注意：今后在项目开发中，一定要把 node_modules 文件夹，添加到 .gitignore 忽略文件中

5.2如何创建

指令：npm init -y

注意：
① 上述命令只能在英文的目录下成功运行！所以，项目文件夹的名称一定要使用英文命名，不要使用中文，不能出现空格。
② 运行 npm install 命令安装包的时候，npm 包管理工具会自动把包的名称和版本号，记录到 package.json 中

5.3dependencies 节点

package.json 文件中，有一个 dependencies 节点，专门用来记录您使用 npm install 命令安装了哪些包

5.4devDependencies 节点

如果某些包只在项目开发阶段会用到，在项目上线之后不会用到，则建议把这些包记录到 devDependencies 节点中。 与之对应的，如果某些包在开发和项目上线之后都需要用到，则建议把这些包记录到 dependencies 节点中。

指令：npm i 包具体的名字 -D

6.卸载包

指令：npm uninstall 具体的包名
注意：npm uninstall 命令执行成功后，会把卸载的包，自动从 package.json 的 dependencies 中移除掉。

7.解决包下载速度的问题

7.1.为什么下包速度慢

在使用 npm 下包的时候，默认从国外的 https://registry.npmjs.org/ 服务器进行下载，此时，网络数据的传输需要经 过漫长的海底光缆，因此下包速度会很慢。

7.2.切换npm下包镜像源

//查看当前下包的镜像源
npm config get registry

//将下包的镜像源切换为***镜像源
npm config set registry=地址

8.包的分类

8.1 项目包

8.1.1解释

那些被安装到项目的 node_modules 目录中的包，都是项目包。

项目包又分为两类，分别是：
⚫ 开发依赖包（被记录到 devDependencies 节点中的包，只在开发期间会用到）
⚫ 核心依赖包（被记录到 dependencies 节点中的包，在开发期间和项目上线之后都会用到

apiRoute

const express = require('express')
const router = express.Router()

// 在这里挂载对应的路由
router.get('/get', (req, res) => {
  // 通过 req.query 获取客户端通过查询字符串，发送到服务器的数据
  const query = req.query
  // 调用 res.send() 方法，向客户端响应处理的结果
  res.send({
    status: 0, // 0 表示处理成功，1 表示处理失败
    msg: 'GET 请求成功！', // 状态的描述
    data: query, // 需要响应给客户端的数据
  })
})

// 定义 POST 接口
router.post('/post', (req, res) => {
  // 通过 req.body 获取请求体中包含的 url-encoded 格式的数据
  const body = req.body
  // 调用 res.send() 方法，向客户端响应结果
  res.send({
    status: 0,
    msg: 'POST 请求成功！',
    data: body,
  })
})

// 定义 DELETE 接口
router.delete('/delete', (req, res) => {
  res.send({
    status: 0,
    msg: 'DELETE请求成功',
  })
})

module.exports = router

app实例

// 导入 express
const express = require('express')
// 创建服务器实例
const app = express()

// 配置解析表单数据的中间件
app.use(express.urlencoded({ extended: false }))

// 必须在配置 cors 中间件之前，配置 JSONP 的接口
app.get('/api/jsonp', (req, res) => {
  // TODO: 定义 JSONP 接口具体的实现过程
  // 1. 得到函数的名称
  const funcName = req.query.callback
  // 2. 定义要发送到客户端的数据对象
  const data = { name: 'zs', age: 22 }
  // 3. 拼接出一个函数的调用
  const scriptStr = `${funcName}(${JSON.stringify(data)})`
  // 4. 把拼接的字符串，响应给客户端
  res.send(scriptStr)
})

// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
const cors = require('cors')
app.use(cors())

// 导入路由模块
const router = require('./16.apiRouter')
// 把路由模块，注册到 app 上
app.use('/api', router)

// 启动服务器
app.listen(80, () => {
  console.log('express server running at http://127.0.0.1')
})

8.2全局包

8.2.1解释

在执行 npm install 命令时，如果提供了 -g 参数，则会把包安装为全局包。
全局包会被安装到 C:\Users\用户目录\AppData\Roaming\npm\node_modules 目录下。

六、最简单的路由

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

// 挂载路由
app.get('/', (req, res) => {
  res.send('hello world.')
})
app.post('/', (req, res) => {
  res.send('Post Request.')
})

app.listen(80, () => {
  console.log('http://127.0.0.1')
})

七、模块化路由（Router）

7.1创建路由模块

// 这是路由模块
// 1. 导入 express
const express = require('express')
// 2. 创建路由对象
const router = express.Router()

// 3. 挂载具体的路由
router.get('/user/list', (req, res) => {
  res.send('Get user list.')
})
router.post('/user/add', (req, res) => {
  res.send('Add new user.')
})

// 4. 向外导出路由对象
module.exports = router

7.2注册路由模块

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


// 1. 导入路由模块
const router = require('./03.router')
// 2. 注册路由模块
app.use('/api', router)

// 注意： app.use() 函数的作用，就是来注册全局中间件

app.listen(80, () => {
  console.log('http://127.0.0.1')
})

7.3中间件

定义中间件函数

中间件的作用

多个中间件之间，共享同一份 req 和 res。基于这样的特性，我们可以在上游的中间件中，统一为 req 或 res 对象添加自定义的属性或方法，供下游的中间件或路由进行使用。

全局生效的中间件

客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。

通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件，示例代码如下：

定义多个全局中间件

可以使用 app.use() 连续定义多个全局中间件。客户端请求到达服务器之后，会按照中间件定义的先后顺序依次进行调用，示例代码如下：

局部生效的中间件

不使用 app.use() 定义的中间件，叫做局部生效的中间件，示例代码如下：

中间件的5个使用注意事项

① 一定要在路由之前注册中间件 (除了捕获错误的中间件要在路由之后)
② 客户端发送过来的请求，可以连续调用多个中间件进行处理
③ 执行完中间件的业务代码之后，不要忘记调用 next() 函数
④ 为了防止代码逻辑混乱，调用 next() 函数后不要再写额外的代码
⑤ 连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象

中间件的分类

为了方便大家理解和记忆中间件的使用，Express 官方把常见的中间件用法，分成了 5 大类，分别是：
① 应用级别的中间件
② 路由级别的中间件
③ 错误级别的中间件
④ Express 内置的中间件
⑤ 第三方的中间件

1.应用级别的中间件

通过 app.use() 或 app.get() 或 app.post() ，绑定到 app 实例上的中间件，叫做应用级别的中间件，代码示例如下：

2.路由级别的中间件

绑定到 express.Router() 实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app 实例上，路由级别中间件绑定到 router 实例上，代码示例如下：

3.错误级别的中间件

错误级别中间件的作用：专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。
格式：错误级别中间件的 function 处理函数中，必须有 4 个形参，形参顺序从前到后，分别是 (err, req, res, next)。

注意：错误级别的中间件，必须注册在所有路由之后

4.Express内置的中间件

自 Express 4.16.0 版本开始，Express 内置了 3 个常用的中间件，极大的提高了 Express 项目的开发效率和体验：
① express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）
② express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）
③ express.urlencoded 解析 URL-encoded 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

代码例子：
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()

// 注意：除了错误级别的中间件，其他的中间件，必须在路由之前进行配置
// 通过 express.json() 这个中间件，解析表单中的 JSON 格式的数据
app.use(express.json())
// 通过 express.urlencoded() 这个中间件，来解析 表单中的 url-encoded 格式的数据
app.use(express.urlencoded({ extended: false }))

app.post('/user', (req, res) => {
  // 在服务器，可以使用 req.body 这个属性，来接收客户端发送过来的请求体数据
  // 默认情况下，如果不配置解析表单数据的中间件，则 req.body 默认等于 undefined
  console.log(req.body)
  res.send('ok')
})

app.post('/book', (req, res) => {
  // 在服务器端，可以通过 req,body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据
  console.log(req.body)
  res.send('ok')
})

// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
  console.log('Express server running at http://127.0.0.1')
})

5.第三方中间件

非 Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。
例如：在 express@4.16.0 之前的版本中，经常使用 body-parser 这个第三方中间件，来解析请求体数据。使用步骤如下：
① 运行 npm install body-parser 安装中间件
② 使用 require 导入中间件
③ 调用 app.use() 注册并使用中间件
注意：Express 内置的 express.urlencoded 中间件，就是基于 body-parser 这个第三方中间件进一步封装出来的。