node基础教程，编写接口

最新推荐文章于 2024-04-30 18:46:41 发布

纤阿

最新推荐文章于 2024-04-30 18:46:41 发布

阅读量240

点赞数

分类专栏：学习笔记文章标签： node.js npm javascript

本文链接：https://blog.csdn.net/qq_45484847/article/details/130188153

版权

学习笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

初始 Node.js

1. Node.js 简介

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。
Node.js 的官网地址： https://nodejs.org/zh-cn/

2. Node.js 环境安装

如果希望通过 Node.js 来运行 Javascript 代码，则必须在计算机上安装 Node.js 环境才行。
安装包可以从 Node.js 的官网首页直接下载，进入到 Node.js 的官网首页（https://nodejs.org/en/），点击
绿色的按钮，下载所需的版本后，双击直接安装即可。

打开终端，在终端输入命令 node –v 后，按下回车键，出现 Node.js 的版本号，即安装成功了

3. 在 Node.js 环境中执行 JavaScript 代码

node 文件路径

内置模块

fs 文件系统模块

fs 模块是官方提供的操作文件的模块

1. fs.readFile

fs.readFile() 用来 读取 指定文件中内容
格式：

fs.readFile(file[,options],callback（err,dataStr）)

file: 文件路径
options(可选): 读取文件编码格式,默认utf8
callback: 回调函数, err.message 错误信息， dataStr 文件内容

示例：

#导入模块
const fs = require('fs')

#读取文件
fs.readFile(__dirname+'1.txt','utf8',function(err,dataStr){
	if(err){
		return console.log('文件读取失败:'+err.message)
	}
	console.log('文件读取成功，内容是：'+dataStr)
})

2. fs.writeFile

fs.writeFile() 用来向指定文件 写入内容
fs.writeFile() 可以创建写入文件，但不能创建路径
格式：

fs.writeFile(file,data[,options],callback(err){})

file:文件路径
data:写入内容
options(可选):写入格式，默认utf8
callback:回调函数,err.message 错误信息，

示例：

// 导入模块
const fs = require('fs')

// 写入文件
// __dirname 为当前文件所在目录
fs.writeFile(__dirname+'2.txt','hello Node.js!',function(err){
	if(err){
		return console.log('文件写入失败！'+err.message)
	}
	console.log('文件写入成功！')
})

path 路径模块

path 模块是官方提供的，处理路径的模块

1. path.join

path.join() 用来进行路由拼接

格式：

path.jion(...paths)

示例：

const path = require('path')

const pathStr01 = path.join('/a','../','c')
console.log(pathStr01) // 输出 \c

const pathStr2 = path.join(__dirname,'./files/1.txt')
console.log(pathStr02) // 1.txt文件完成目录

涉及到路径拼接，都要使用 path.join(__dirname,'...') 提高可移植性

2. path.basename

path.basename() 在路径中获取文件名
格式：

path.basename(path[,ext])

path: 路径字符串
ext(可选): 文件扩展名

示例：

// 导入模块
const path = require('path')

const fpath = '/a/b/c/index.html'

var text01 = path.basename(fpath)
console.log(text01) // 输出 index.html

var text02= path.basename(fpath,'.html')
console.log(text02) // 输出 index

3. path.extname

path.extname() 获取路径中文件扩展名
格式：

path.extname(path)

path: 文件路径

示例：

// 导入模块
const path = require('path')

const fpath = '/a/b/c/index.html'

const text = path.extname(fpath)
console.log(text) // 输出 .html

http 模块

负责对外提供网络资源的电脑，叫做服务器
http模块，用来创建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')
})

1. 导入http模块

const http = require('http')

2. 创建web服务器示例

const server = http.createServer()

3. 为服务器示例绑定 request 事件

server.on('reqest',(req,res)=>{
	// req 是请求对象
	// req.url 是客户端请求的 URL 地址
	// req.method 是客户端的 method 请求类型
	const str=`Your request url is ${req.url},and method is ${req.method}`
	// 防止中文乱码，设置响应头
	res.setHeader('Content-Type','text/html;charset=utf-8')
	// res.end() 向客户端发送指定内容，并结束处理
	res.end(str)
})

4. 绑定监听事件

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

自定义模块

由用户创建的js文件

在自定义模块中定义变量、方法等，只能在当前模块内被访问，

在自定义模块中，可以将变量、方法挂载到 module.exports 对象上，将module.exports 对象暴露出去，外界可以通过 require（） 方法导入自定义模块，就可以使用自定义模块的方法和变量

test01.js

#1
module.exports.username = 'zs'
module.exports.sayHello = function() {
  console.log('Hello!')
}

#2
module.exports = {
  nickname: '小黑',
  sayHi() {
    console.log('Hi!')
  }
}

test02.js

// 导入一个自定义模块的时候
// m 就是那个模块中，通过 module.exports 指向的那个对象

const m = require(__dirname+'./test01.js')

console.log(m)

初始化包

1.以英文名作为包的名字
2.快速创建package.json npm init -y
3.文件夹下有 package.json(管理配置文件) 、index.js(包的入口文件) 、README(包的说明文档)

npm 包

1）nrm：切换镜像

#全局安装nrm
npm i nrm -g
#查看所有可用镜像源
nrm ls
#将镜像源切换为 taobao 镜像
nrm use taobao
#查看当前镜像
npm config get registry
npm config set registry=https://registry.npm.taobao.org/

2) i5ting_toc: md文档转html

#全局安装i5ting_toc
npm i i5ting_toc -g
#md文档转html
i5ting_toc -f md文件路径 -o

3) nodemon: 运行node项目并自动监听

#全局安装
npm install -g nodemon
#运行文件
nodemon 文件名

第三方模块

第三方模块是非官方提供，由第三方模块开发，使用前需要下载

Express

初识 Express

Express 是基于 Node.js 平台的 web 开发框架，通常用来创建Web服务器

安装：

npm i express@4.17.1

示例：

#导入
const express = require('express')
#创建web服务器
const app=express()

...

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

Express 路由

格式：

app.get('/',(req,res)=>{
	req.query为发送到服务器的对象，默认为空
})
app.post('/',(req,res)=>{
	req.body为发送到服务器的对象，默认为空
})
app.post('/:id',(req,res)=>{
	req.params为通过 ：动态匹配的参数
})

托管静态资源：
可以将文件目录下的资源对外开放，域名加路径直接访问

app.use(express.static('public')) 
// http://localhost:80/image.jpg

app.use('/text', express.static('public')) 
// 挂载前缀，http://localhost:80/public/image.jpg

Express 中间件

中间件特指业务流程的中间处理环节

中间件本质上就是一个function处理函数

注意：
1）要在路由之前注册中间件,错误中间件要在路由之后注册
2）不要忘记调用next（）函数，在next（）函数后不要写代码
3）连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象

1. 全局中间件

app.use(function(req,res,next){
	next()
})

2. 局部中间件

app.get('/',[nw1,nw2,...],(req.res) => { res.send('Home page.')})

3. 错误中间件
错误中间件要在路由之后注册

app.use(function(err,req,res,next){
	res.send('Error'+ err.message)
	next()
})

4. 内置中间件

① express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）

② express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

③ express.urlencoded 解析 URL-encoded 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

# 配置解析 application/json 格式数据中间件
app.use(express.json())

# 配置解析 application/x-www-form-urlencoded 格式数据的内置中间件
app.use(express.urlencoded({ extended: false }))

路由模块化

为了对路由进行模块化管理，Express不建议将路由挂载到app上，推荐将路由模块抽离为单独的模块

调用express.Router() 函数创建路由对象
在路由对象上挂载路由
使用 module.exports 向外共享路由对象
使用app.use()函数注册路由模块

示例：

apiRouter.js

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

// 3. 挂载具体的路由
router.get('/user/list', (req, res) => {
	const query = req.query
	res.send({
	status:0,
	msg:'sucess',
	data: query
	})
})

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

index.js

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

// 注意： app.use() 函数的作用，就是来注册全局中间件
app.use('/files', express.static('./files'))
// 1. 导入路由模块
const router = require('./03.router')
// 2. 注册路由模块
app.use('/api', router)

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

cors

cors 是 Express 的一个第三方中间件，通过安装配置，可以解决跨域问题

1.安装

npm install cors

2.导入

const cors = require('cors')

3.配置中间件（在路由之前）

app.use(cors())

可以指定 cors 响应头部，指定为 * 表示接受任何域的请求，默认只接受九个固定请求头

res.setHeader('Access-Control-Allow-Origin','*')

还可以指定 cors 支持客户端发起的请求,默认支持GET、POST、HEAD请求

res.setHeader('Access-Control-Allow-Methods','*')
res.setHeader('Access-Control-Allow-Methods','POST,DELETE')

mysql

mysql 基础使用

安装第三方模块mysql

npm install mysql

通过 mysql 模块连接到 mysql数据库

# 导入
const mysql = require('mysql')
# 建立与 MYSQL 的连接
const db = mysql.createPool({
	host:'127.0.0.1',  			// 数据库的 IP 地址
	user:'root',       			// 登录数据库的账号
	password:'admin123',		// 登录数据库的密码
	database:'my_db_01'			// 指定要操作的数据库
})

通过 mysql 模块执行 sql 语句

# 一
const user={ username:'bulen',password:'123456' }
cosnt sqlStr=`INSERT INTO users (username,password) VALUES (?,?)
db.query(sqlStr,[user.username,user.password],(err,resules)=>{
	if(err) return console.log(err.message)
	if(results.affectedRows===1){ console.log('插入数据成功！')}
})

# 二
const user={ username:'bulen',password:'123456' }
cosnt sqlStr=`INSERT INTO users SET ?`
db.query(sqlStr,user,(err,resules)=>{
	if(err) return console.log(err.message)
	if(results.affectedRows===1){ console.log('插入数据成功！')}
})

const sqlStr=`DELETE FORM users WHERE id=?`
# 如果有多个？占位符，则需要用数据包裹起来,例如：[7,6]
db.query(sqlStr,7,(err,results)=>{
	if(err) return console.log(err.message)
	if(results.affectedRows===1){ console.log("删除数据成功！")}
})

# 一
const user={ username:'bulen',password:'123456',id:7 }
cosnt sqlStr=`UPDATE users SET username=?,password=? WHERE id=?`
db.query(sqlStr,[user.username,user.password,user.id],(err,resules)=>{
	if(err) return console.log(err.message)
	if(results.affectedRows===1){ console.log('更新数据成功！')}
})

# 二
const user={ username:'bulen',password:'123456' }
cosnt sqlStr=`UPDATE users SET ? WHERE id=?`
db.query(sqlStr,[user,user.id],(err,resules)=>{
	if(err) return console.log(err.message)
	if(results.affectedRows===1){ console.log('更新数据成功！')}
})

const sqlStr = 'SELECT * FORM users WHERE id=?'
db.query(sqlStr,6,(err,result)=>{
    if(err) return console.log(err.message)
    console.log(result)
})

接口编写

npm init -y
npm i express
npm i cors
npm i mysql

5)编写文件
dbMysql.js

const mysql=require('mysql')
const db=mysql.createPool({
    host:'127.0.0.1',
    user:'root',
    password:'123123',
    database:'result'
})

module.exports=db

apiRouter.js

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

const path=require('path')
const db=require(path.join(__dirname,'./dbMysql'))

const sqlStr01=`select * from task01`

router.get('/task1',function(req,res){
    db.query(sqlStr01,function(err,results){
        if(err) return console.log(err.message);
        res.send({
            code:200,
            msg: '数据获取成功',
            data:results
        })
    })
})

router.post('/task1',function(req,res){
    db.query(sqlStr01,function(err,results){
        if(err) return console.log(err.message);
        res.send({
            code:200,
            msg: '数据获取成功',
            data:results
        })
    })
})


module.exports=router

index.js

const express=require('express')
const app=express()
const cors=require('cors')
app.use(cors())

const path=require('path')
const apiRouter=require(path.join(__dirname,'./apiRouter'))
app.use('/api',apiRouter)

app.listen(9999,()=>{
    console.log('server running at http://127.0.0.1');
})

express-session

session认证机制用于服务端渲染身份认证

用户登录成功后，服务器将生成对应的 Cookie 字符串发送给浏览器，浏览器自动把 Cookie 字符串存储在当前域名下,用来对用户身份认证。请求头携带 Cookie 查询用户信息，用户认证成功后，对用户生成特定响应内容

安装

npm install express-session

配置 express-session 中间件

#导入 session 中间件
var session = require('express-session')
#配置
app.use(session({
	secret: 'key123', // secret 属性值可以为任意字符串
	resave: false,
	saveUninitialized:true
}))

对session进行操作
1）从 session 中存数据
2）从 session 中取数据
3）清空 session
示例：

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

 // TODO_01：请配置 Session 中间件
 const session = require('express-session')
 app.use(
   session({
     secret: 'itheima',
     resave: false,
     saveUninitialized: true,
   })
 )

 // 托管静态页面
 app.use(express.static('./pages'))
 // 解析 POST 提交过来的表单数据
 app.use(express.urlencoded({ extended: false }))

 // 登录的 API 接口
 app.post('/api/login', (req, res) => {
   // 判断用户提交的登录信息是否正确
   if (req.body.username !== 'admin' || req.body.password !== '000000') {
     return res.send({ status: 1, msg: '登录失败' })
   }

   // TODO_02：请将登录成功后的用户信息，保存到 Session 中
   // 注意：只有成功配置了 express-session 这个中间件之后，才能够通过 req 点出来 session 这个属性
   req.session.user = req.body // 用户的信息
   req.session.islogin = true // 用户的登录状态

   res.send({ status: 0, msg: '登录成功' })
 })

 // 获取用户姓名的接口
 app.get('/api/username', (req, res) => {
   // TODO_03：请从 Session 中获取用户的名称，响应给客户端
   if (!req.session.islogin) {
     return res.send({ status: 1, msg: 'fail' })
   }
   res.send({
     status: 0,
     msg: 'success',
     username: req.session.user.username,
   })
 })

 // 退出登录的接口
 app.post('/api/logout', (req, res) => {
   // TODO_04：清空 Session 信息
   req.session.destroy()
   res.send({
     status: 0,
     msg: '退出登录成功',
   })
 })

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

JWT （ jsonwebtoken，express-jwt）

JWT认证机制用于前后端分离，session不能接受前端跨域访问

用户登录成功后，服务器将生成对应的 ToKen 字符串发送给浏览器，浏览器自动把 ToKen 存储在本地存储(LocalStorage)或会话存储(SessionStorage)下,用来对用户身份认证。请求头携带 ToKen 查询用户信息，用户认证成功后，对用户生成特定响应内容

JWT 通常由三部分组成，分别是 Header（头部）、Payload（有效荷载）、Signature（签名）。

其中：
⚫ Payload 部分才是真正的用户信息，它是用户信息经过加密之后生成的字符串。
⚫ Header 和 Signature 是安全性相关的部分，只是为了保证 Token 的安全性

三者之间使用英文的“.”分隔，格式如下：

Header.Payload.Signature

客户端收到服务器返回的 JWT 之后，通常会将它储存在 localStorage 或 sessionStorage 中。
此后，客户端每次与服务器通信，都要带上这个 JWT 的字符串，从而进行身份认证。推荐的做法是把 JWT 放在 HTTP
请求头的 Authorization 字段中，格式如下：

Authorization : Bearer <token>

1.安装

# jsonwebtoken 用于生成 JWT 字符串
#express-jwt 用于将 JWT 字符串解析还原成 JSON 对象

npm install jsonwebtoken express-jwt

2.使用

jsonwebtoken : 导入=》设置密钥 =》加密为 ToKen =》发送给客户端

express-jwt ：导入 =》设置为全局中间件，设置不需要身份认证的接口 =》错误中间件

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

// TODO_01：安装并导入 JWT 相关的两个包，分别是 jsonwebtoken 和 express-jwt
const jwt = require('jsonwebtoken')
const expressJWT = require('express-jwt')


const cors = require('cors')
app.use(cors())

app.use(bodyParser.urlencoded({ extended: false }))

// TODO_02：定义 secret 密钥，建议将密钥命名为 secretKey
const secretKey = 'key12313'

// TODO_04：注册将 JWT 字符串解析还原成 JSON 对象的中间件
// expressJWT({ secret: secretKey }) 用来解析 ToKen 中间件
// unless({ path: [/^\/api\//] })) 用来指定哪些接口不需要访问权限
app.use(expressJWT({ secret: secretKey }).unless({ path: [/^\/api\//] }))

// 登录接口
app.post('/api/login', function (req, res) {
  const userinfo = req.body
  if (userinfo.username !== 'admin' || userinfo.password !== '000000') {
    return res.send({
      status: 400,
      message: '登录失败！',
    })
  }
  // 登录成功
  // TODO_03：在登录成功之后，调用 jwt.sign() 方法生成 ToKen  字符串。并通过 token 属性发送给客户端
  // 参数1：用户的信息对象
  // 参数2：加密的秘钥
  // 参数3：配置对象，可以配置当前 token 的有效期
  // 记住：千万不要把密码加密到 token 字符中
  const tokenStr = jwt.sign({ username: userinfo.username }, secretKey, { expiresIn: '10h' })
  res.send({
    status: 200,
    message: '登录成功！',
    // 要发送给客户端的 token 字符串,为了方便客户端使用，在这里直接拼接上 Bearer 的前缀
    token: 'Bearer'+tokenStr, 
  })
})

// 这是一个有权限的 API 接口
app.get('/admin/getinfo', function (req, res) {
  // TODO_05：使用 req.user 获取用户信息，并使用 data 属性将用户信息发送给客户端
  console.log(req.user)
  res.send({
    status: 200,
    message: '获取用户信息成功！',
    data: req.user, // 要发送给客户端的用户信息
  })
})

// TODO_06：使用全局错误处理中间件，捕获解析 JWT 失败后产生的错误
app.use((err, req, res, next) => {
  // 这次错误是由 token 解析失败导致的
  if (err.name === 'UnauthorizedError') {
    return res.send({
      status: 401,
      message: '身份认证失败！',
    })
  }
})


app.listen(8888, function () {
  console.log('Express server running at http://127.0.0.1:8888')
})

bcryptjs

bcryptjs对密码进行加密，优点是 1. 无法逆向破解，2. 同意密码多次加密，得到的结果不同

1.安装
2.

npm i bcryptjs@2.4.3

2.导入

const bcrypt = require('bcryptjs')

3.使用

加密：在注册用户的处理函数中，确认用户名可用之后，调用 bcrypt.hashSync(明文密码, 随机盐的
长度) 方法，对用户的密码进行加密处理：

// 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
userinfo.password = bcrypt.hashSync(userinfo.password, 10)

2）对比密码：调用 bcrypt.compareSync(用户提交的密码, 数据库中的密码) 方法比较密码是
否一致,返回值是布尔值（true 一致、false 不一致）

// 拿着用户输入的密码,和数据库中存储的密码进行对比
const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)

joi and express-joi

joi and express-joi 用来对接受到的数据进行数据验证
npm 包搜索里面有使用文档 : https://www.npmjs.com/package/joi

1.安装

定义验证规则

npm  i   joi

验证功能

npm  i  express-joi

2.使用

schema.js

const joi = require('joi')
/**
* string() 值必须是字符串
* alphanum() 值只能是包含 a-zA-Z0-9 的字符串
* min(length) 最小长度
* max(length) 最大长度
* required() 值是必填项，不能为 undefined
* pattern(正则表达式) 值必须符合正则表达式的规则
*/
// 用户名的验证规则
const username = joi.string().alphanum().min(1).max(10).required()
// 密码的验证规则
const password = joi
.string()
.pattern(/^[\S]{6,12}$/)
.required()

// 注册和登录表单的验证规则对象
exports.reg_login_schema = {
    // 表示需要对 req.body 中的数据进行验证
    body: {
    username,
    password,
	oldPwd: password,

    // 解读：
    // 1. joi.ref('oldPwd') 表示 newPwd 的值必须和 oldPwd 的值保持一致
    // 2. joi.not(joi.ref('oldPwd')) 表示 newPwd 的值不能等于 oldPwd 的值
    // 3. .concat() 用于合并 joi.not(joi.ref('oldPwd')) 和 password 这两条验证规则
    newPwd: joi.not(joi.ref('oldPwd')).concat(password),
    },
}

router.js

const express = require('express')
const router = express.Router()
const userHandler = require('../router_handler/user')

// 1. 导入验证表单数据的中间件
const expressJoi = require('@escook/express-joi')
// 2. 导入需要的验证规则对象
const { reg_login_schema } = require('./schema')

// 注册新用户
// 3. 在注册新用户的路由中，声明局部中间件，对当前请求中携带的数据进行验证
// 3.1 数据验证通过后，会把这次请求流转给后面的路由处理函数
// 3.2 数据验证失败后，终止后续代码的执行，并抛出一个全局的 Error 错误，进入全局错误级别中间件
中进行处理
router.post('/reguser', expressJoi(reg_login_schema), userHandler.regUser)

module.exports = router

app.js

const joi = require('@hapi/joi')
// 错误中间件
app.use(function (err, req, res, next) {
// 数据验证失败
if (err instanceof joi.ValidationError) return res.cc(err)
// 未知错误
res.cc(err)
})

纤阿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
node基础教程，编写接口

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 的官网地址： https://nodejs.org/zh-cn/，由用户创建的js文件在自定义模块中定义变量、方法等，只能在当前模块内被访问，在自定义模块中，可以将变量、方法挂载到对象上，将对象暴露出去，外界可以通过require（）方法导入自定义模块
复制链接

扫一扫