Node.js后端实战：EV大事件Web后台 API 开发

最新推荐文章于 2024-05-28 22:57:50 发布
最新推荐文章于 2024-05-28 22:57:50 发布
阅读量680 收藏 28
点赞数 17
分类专栏： 技多不压身系列 文章标签： node.js 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53324833/article/details/138768480
版权

前言

这个小 demo 基本涵盖了开发一个 Node.js 后台项目的基本流程和方法，因此值得学习一下。

项目的源码地址：api_server项目源码；

初始化工作

创建项目

1、我这里使用 WebStorm 进行开发，创建新项目，名为 api_server：

在这里插入图片描述

因为这个 IDE 比较智能，因此不需要我们手动进行 npm init -y 的初始化操作了。

2、因为我们是用 Express 框架进行开发，因此我们要安装 express 这个第三方包。

运行如下的命令，安装特定版本的 express：

npm i express

在这里插入图片描述

3、在项目根目录中新建 app.js 作为整个项目的入口文件，并初始化如下的代码：

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

//2、创建 express 的服务器实例
const app = express()

//write your code here...

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

项目结构如下：

在这里插入图片描述

配置跨域

  1. 运行如下的命令，安装 cors 中间件：
npm i cors

在这里插入图片描述

  1. 在 app.js 中导入并注册 cors 中间件：
//1、导入 express 模块
const express = require('express')

//2、创建 express 的服务器实例
const app = express()

// 导入并注册 cors 中间件
const cors = require('cors')
// 将 cors 注册为全局中间件
app.use(cors())

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

配置解析表单数据的中间件

  1. 通过如下的代码，配置解析 application/x-www-form-urlencoded 格式的表单数据的内置中间件，注册在 app.js 入口文件中作全局中间件：
//1、导入 express 模块
const express = require('express')

//2、创建 express 的服务器实例
const app = express()

// 导入并注册 cors 中间件
const cors = require('cors')
// 将 cors 注册为全局中间件
app.use(cors())

//配置解析表单数据的内置中间件，这个中间件只能解析 application/x-www-form-urlencoded 格式的表单文件
app.use(express.urlencoded({ extended: false}))

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

初始化路由相关的文件夹

  1. 在项目根目录中，新建 router 文件夹，用来存放所有的路由模块

    路由模块中，只存放客户端的请求与处理函数之间的映射关系（相当于Java 项目中的 Controller 层）

  2. 在项目根目录中，新建 router_handler 文件夹，用来存放所有的 路由处理函数模块

    路由处理函数模块中，专门负责存放每个路由对应的处理函数（相当于 Java 项目中的 Service 层）

现在的项目目录结构如下：

在这里插入图片描述

初始化用户路由模块

  1. 在 router 文件夹中，新建 user.js 文件，作为用户的路由模块，并初始化代码如下：
const express = require('express')
// 创建路由对象
const router = express.Router()

// 注册新用户
router.post('/reguser', (req, res) => {
  res.send('reguser OK')
})

// 登录
router.post('/login', (req, res) => {
  res.send('login OK')
})

// 将路由对象共享出去
module.exports = router
  1. 在 app.js 中，导入并使用 用户路由模块 ：
// 导入并注册用户路由模块
const userRouter = require('./router/user')
app.use('/api', userRouter)

抽离用户路由模块中的处理函数

目的：为了保证 路由模块 的纯粹性，所有的 路由处理函数，必须抽离到对应的 路由处理函数模块 中

  1. 在 /router_handler/user.js 中，使用 exports 对象，分别向外共享如下两个 路由处理函数 ：
/**
 * 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
 */
//对外共享注册用户的处理函数
module.exports.regUser = (req,res)=>{
    res.send('reguser ok')
}

//对外共享登录处理函数
module.exports.login = (req,res)=>{
    res.send('login ok')
}
  1. 将 /router/user.js 中的代码修改为如下结构：
//引入 express
const express = require('express')
//创建路由对象
const router = express.Router()

//导入用户路由处理函数模块
const userHandler = require('../router_handler/user')

//注册新用户
router.post('/reguser',userHandler.regUser)

//登录
router.post('/login',userHandler.login)

//将路由对象共享出去
module.exports = router

最佳实践

对外共享模块成员时，建议统一使用 module.exports 这样的方式，因为这样肯定不会出错。

使用 exports 在某些情况下会有问题的。

登录注册

新建 ev_users 用户信息表：

在这里插入图片描述

安装并配置 mysql 模块

在 API 接口项目中，需要安装并配置 mysql 这个第三方模块，来连接和操作 MySQL 数据库

  1. 运行如下命令，安装 mysql 模块：
npm i mysql

在这里插入图片描述

  1. 在项目根目录中新建 /db/index.js 文件，在此自定义模块中创建数据库的连接对象：
/**
 * 这里是 MySQL 数据库的配置模块
 */

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

//创建数据库连接对象
const db = mysql.createPool({
    host: '127.0.0.1',
    user: 'root',
    password: '123456',
    database: 'node'
})

//向外共享 db 数据库连接对象
module.exports = db

此时的项目目录结构如下：

在这里插入图片描述

注册

实现逻辑

在我们的路由处理函数 /router_handler/user.js 中的 reguser 函数内完成注册功能：

  1. 检测表单数据是否合法
  2. 检测用户名是否被占用
  3. 对密码进行加密处理
  4. 插入新用户

检测表单数据是否合法

  1. 判断用户名和密码是否为空
// 获取客户端提交给服务器的用户信息
    const userInfo = req.body
    // 对表单数据进行合法性校验
    if(userInfo.username == null || userInfo.password == null){
        return res.send({
            status: 1,
            message: '用户名或者密码不合法'
        })
    }

检测用户名是否被占用

  1. 导入数据库操作模块：
const db = require('../db/index')
  1. 定义 SQL 语句：
//定义 sql 语句，查询用户名是否被占用
const sqlStr = 'select * from ev_users where username = ?'
  1. 执行 SQL 语句并根据结果判断用户名是否被占用：
//执行 sql 语句
    db.query(sqlStr,userInfo.username,(err,res)=>{
        //如果 sql 执行失败
        if(err){
            return res.send({
                status: 1,
                message: err.message
            })
        }
        // 否则执行成功，那么判断用户名是否被占用
        // 这里因为查询语句的返回结果是一个数组，所以有一个 length 属性可以使用
        if(res.length > 0){
            return res.send({
                status: 1,
                message: '用户名被占用，请更换其他用户名!'
            })
        }
        //TODO: 用户名可以使用，继续后续流程...
    })

对密码进行加密处理

为了保证密码的安全性，不建议在数据库以 明文 的形式保存用户密码，推荐对密码进行 加密存储

在当前项目中，使用 bcryptjs 对用户密码进行加密，优点：

  • 加密之后的密码，无法被逆向破解
  • 同一明文密码多次加密，得到的加密结果各不相同，保证了安全性
  1. 运行如下命令，安装指定版本的 bcryptjs ：
npm i bcryptjs

在这里插入图片描述

  1. 在 /router_handler/user.js 中，导入 bcryptjs ：
const bcrypt = require('bcryptjs')
  1. 在注册用户的处理函数中，确认用户名可用之后，调用 bcrypt.hashSync(明文密码, 随机盐的长度) 方法，对用户的密码进行加密处理：
// 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
userinfo.password = bcrypt.hashSync(userinfo.password, 10)

插入新用户

  1. 定义插入用户的 SQL 语句：
const sql = 'insert into ev_users set ?'
  1. 调用 db.query() 执行 SQL 语句，插入新用户：
db.query(sql, { username: userinfo.username, password: userinfo.password }, function (err, results) {
  // 执行 SQL 语句失败
  if (err) return res.send({ status: 1, message: err.message })
  // SQL 语句执行成功，但影响行数不为 1
  if (results.affectedRows !== 1) {
    return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
  }
  // 注册成功
  res.send({ status: 0, message: '注册成功！' })
})

完整注册用户的代码

//对外共享注册用户的处理函数
module.exports.regUser = (req,res)=>{
    // 获取客户端提交给服务器的用户信息
    const userInfo = req.body
    // 对表单数据进行合法性校验
    if(userInfo.username == null || userInfo.password == null){
        return res.send({
            status: 1,
            message: '用户名或者密码不合法'
        })
    }
    //定义 sql 语句，查询用户名是否被占用
    const sqlStr = 'select * from ev_users where username = ?'
    //执行 sql 语句
    db.query(sqlStr,userInfo.username,(err,results)=>{
        //如果 sql 执行失败
        if(err){
            return res.send({
                status: 1,
                message: err.message
            })
        }
        // 否则执行成功，那么判断用户名是否被占用
        // 这里因为查询语句的返回结果是一个数组，所以有一个 length 属性可以使用
        if(results.length > 0){
            return res.send({
                status: 1,
                message: '用户名被占用，请更换其他用户名!'
            })
        }
        //对用户名密码进行 bcrypt 加密
        userInfo.password = bcrypt.hashSync(userInfo.password, 10)
        //插入新用户
        const sql = 'insert into ev_users set ?'
        /*
        这里插入信息我们选用的是插入信息对象，该对象有两个属性：username 和 password
        因为客户端发送过来的信息里面可能不止 username 和 password 这两个属性
        可能还有一些其他的属性，但我们只希望插入 username 和 password
        因此这里手动声明了一个对象
         */
        db.query(sql,{username: userInfo.username, password: userInfo.password},(err,results)=>{
            //判断 sql 语句是否执行成功
            if(err){
                return res.send({
                    status: 1,
                    message: err.message
                })
            }
            // 判断影响行数是否为1
            if(results.affectedRows !== 1){
                return res.send({
                    status: 1,
                    message: '注册用户失败，请稍后再试!'
                })
            }
            //上面流程都没出问题，说明插入成功，注册用户成功
            res.send({
                status: 0,
                message: '注册成功'
            })
        })
    })
}

优化 res.send() 代码

在处理函数中，需要多次调用 res.send() 向客户端响应 处理失败 的结果，为了简化代码，可以手动封装一个 res.cc() 函数

  1. 在 app.js 中，所有路由之前，声明一个全局中间件，为 res 对象挂载一个 res.cc() 函数 ：
// 响应数据的中间件
//在路由之前封装 res.cc 函数：用来统一返回前端的结果集
app.use((req,res,next)=>{
    // status 默认值为1，表示失败的情况
    // err的值，可能是一个错误对象，也可能是一个错误的描述字符串
    res.cc = function (err, status=1){
        res.send({
            status,
            message: err instanceof Error ? err.message : err
        })
    }
    next()
})

经过这样的处理，我们不管是发送成功或者是失败的消息就都可以用这个 cc 函数来发送了：

来看优化后的用户注册处理函数：

//对外共享注册用户的处理函数
module.exports.regUser = (req,res)=>{
    // 获取客户端提交给服务器的用户信息
    const userInfo = req.body
    // 对表单数据进行合法性校验
    if(userInfo.username == null || userInfo.password == null){
        // return res.send({
        //     status: 1,
        //     message: '用户名或者密码不合法'
        // })
        return res.cc('用户名或者密码不合法')
    }
    //定义 sql 语句，查询用户名是否被占用
    const sqlStr = 'select * from ev_users where username = ?'
    //执行 sql 语句
    db.query(sqlStr,userInfo.username,(err,results)=>{
        //如果 sql 执行失败
        if(err){
            // return res.send({
            //     status: 1,
            //     message: err.message
            // })
            return res.cc(err)
        }
        // 否则执行成功，那么判断用户名是否被占用
        // 这里因为查询语句的返回结果是一个数组，所以有一个 length 属性可以使用
        if(results.length > 0){
            // return res.send({
            //     status: 1,
            //     message: '用户名被占用，请更换其他用户名!'
            // })
            return res.cc('用户名被占用，请更换其他用户名!')
        }
        //对用户名密码进行 bcrypt 加密
        userInfo.password = bcrypt.hashSync(userInfo.password, 10)
        //插入新用户
        const sql = 'insert into ev_users set ?'
        /*
        这里插入信息我们选用的是插入信息对象，该对象有两个属性：username 和 password
        因为客户端发送过来的信息里面可能不止 username 和 password 这两个属性
        可能还有一些其他的属性，但我们只希望插入 username 和 password
        因此这里手动声明了一个对象
         */
        db.query(sql,{username: userInfo.username, password: userInfo.password},(err,results)=>{
            //判断 sql 语句是否执行成功
            if(err){
                // return res.send({
                //     status: 1,
                //     message: err.message
                // })
                return res.cc(err)
            }
            // 判断影响行数是否为1
            if(results.affectedRows !== 1){
                // return res.send({
                //     status: 1,
                //     message: '注册用户失败，请稍后再试!'
                // })
                return res.cc('注册用户失败，请稍后再试!')
            }
            //上面流程都没出问题，说明插入成功，注册用户成功
            // res.send({
            //     status: 1,
            //     message: '注册成功'
            // })
            res.cc('注册成功',0)
        })
    })
}

优化表单数据验证

表单验证的原则：前端验证为辅，后端验证为主，后端永远不要相信前端提交过来的任何内容

在实际开发中，前后端都需要对表单的数据进行合法性的验证，而且，后端做为数据合法性验证的最后一个关口，在拦截非法数据方面，起到了至关重要的作用。

单纯的使用 if...else... 的形式对数据合法性进行验证，效率低下、出错率高、维护性差。因此，推荐使用第三方数据验证模块，来降低出错率、提高验证的效率与可维护性，让后端程序员把更多的精力放在核心业务逻辑的处理上。

  1. 安装 joi 包，为表单中携带的每个数据项，定义验证规则：
npm install joi

在这里插入图片描述

  1. 安装 @escook/express-joi 中间件，来实现自动对表单数据进行验证的功能：
npm i @escook/express-joi

在这里插入图片描述

  1. 新建 /schema/user.js 用户信息验证规则模块，并初始化代码如下：
// 导入定义校验规则的 joi 第三方包
const joi = require('joi')

/**
 * string() 值必须是字符串
 * alphanum() 值只能是包含 a-z、A-Z、0-9 的字符串
 * min(length) 最小长度
 * max(length) 最大长度
 * required() 值是必填项，不能为 undefined
 * pattern(正则表达式) 值必须符合正则表达式的规则
 */

// 用户名的验证规则
const username = joi.string().alphanum().min(1).max(10).required()
// 密码的验证规则
const password = joi
    .string()
    //下面这一句正则表达式的含义是：
    //1、字符串的长度必须在6到12个字符之间（包括6和12）。
    //2、字符串中不能包含任何空白字符（如空格、制表符、换行符等）。
    .pattern(/^[\S]{6,12}$/)
    .required()

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

此时的项目目录结构为：

在这里插入图片描述

  1. 修改 /router/user.js 中的代码如下：
//引入 express
const express = require('express')
//创建路由对象
const router = express.Router()

//导入用户路由处理函数模块
const userHandler = require('../router_handler/user')

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


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

//登录
router.post('/login', userHandler.login)

//将路由对象共享出去
module.exports = router
  1. 在 app.js 中还要注册一个全局的错误处理中间件：
//定义全局错误级别的中间件，一定要放在路由和其他中间件的最后面嗷
app.use((err, req, res, next)=>{
    //验证失败导致的错误
    if(err instanceof joi.ValidationError){
        return res.cc(err)
    }
    //否则就是未知的错误
    res.cc(err)
})

登录

实现步骤

  1. 检测表单数据是否合法
  2. 根据用户名查询用户的数据
  3. 判断用户输入的密码是否正确
  4. 生成 JWT 的 Token 字符串

检测登录表单的数据是否合法

  1. 将 /router/user.js 中 登录 的路由代码修改如下：
// 登录的路由
router.post('/login', expressJoi(reg_login_schema), userHandler.login)

根据用户名查询用户的数据

  1. 接收表单数据：
const userinfo = req.body
  1. 定义 SQL 语句：
const sql = `select * from ev_users where username=?`
  1. 执行 SQL 语句，查询用户的数据：
db.query(sql, userinfo.username, function (err, results) {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // 执行 SQL 语句成功，但是查询到数据条数不等于 1
  if (results.length !== 1) return res.cc('登录失败！')
  // TODO：判断用户输入的登录密码是否和数据库中的密码一致
})

判断用户输入的密码是否正确

核心实现思路：调用 bcrypt.compareSync(用户提交的密码, 数据库中的密码) 方法比较密码是否一致

返回值是布尔值（true 一致、false 不一致）

具体的实现代码如下：

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

// 如果对比的结果等于 false, 则证明用户输入的密码错误
if (!compareResult) {
  return res.cc('登录失败！')
}

// TODO：登录成功，生成 Token 字符串

生成 JWT 的 Token 字符串

核心注意点：在生成 Token 字符串的时候，一定要剔除 密码 和 头像 的值

  1. 通过 ES6 的高级语法，快速剔除 密码 和 头像 的值：
// 剔除完毕之后，user 中只保留了用户的 id, username, nickname, email 这四个属性的值
const user = { ...results[0], password: '', user_pic: '' }
  1. 运行如下的命令，安装生成 Token 字符串的包：
npm i jsonwebtoken

在这里插入图片描述

  1. 在 /router_handler/user.js 模块的头部区域，导入 jsonwebtoken 包：
// 用这个包来生成 Token 字符串
const jwt = require('jsonwebtoken')
  1. 创建 config.js 文件，并向外共享 加密 和 还原 Token 的 jwtSecretKey 字符串：
module.exports = {
  jwtSecretKey: 'itheima No1. ^_^',
}
  1. 将用户信息对象加密成 Token 字符串：
// 导入配置文件
const config = require('../config')

// 生成 Token 字符串
const tokenStr = jwt.sign(user, config.jwtSecretKey, {
  expiresIn: '10h', // token 有效期为 10 个小时
})
  1. 将生成的 Token 字符串响应给客户端：
res.send({
  status: 0,
  message: '登录成功！',
  // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀
  token: 'Bearer ' + tokenStr,
})

完整登录用户的代码：

//对外共享登录处理函数
module.exports.login = (req,res)=>{
    //接收表单的数据
    const userInfo = req.body
    //定义 sql 语句
    const sql = 'select * from ev_users where username = ?'
    //执行 sql 语句
    db.query(sql, userInfo.username, (err, results)=>{
        //执行失败
        if(err) return res.cc(err)
        //执行成功，但是获取到的数据条数不等于 1
        if(results.length !== 1) return res.cc('登录失败')
        // 拿着用户输入的密码和数据库中存储的密码进行对比
        // 第一个参数是输入的密码，第二个参数才是数据库中的密码嗷
        const compareRes = bcrypt.compareSync(userInfo.password, results[0].password)
        if(compareRes === false){
            return res.cc('登录失败')
        }
        //在服务端生成 Token 的字符串
        const user = { ...results[0], password:'', user_pid:''}
        //对用户信息进行加密，生成 Token 字符串
        const tokenStr = jwt.sign(user, config.jwtSecretKey, { expiresIn: config.expiresIn })
        //响应给客户端
        res.send({
            status: 0,
            message: '登录成功',
            token: 'Bearer ' + tokenStr
        })
    })
}

配置解析 Token 的中间件

  1. 运行如下的命令，安装解析 Token 的中间件：
npm i express-jwt

在这里插入图片描述

  1. 在 app.js 中注册路由之前，配置解析 Token 的中间件：
// 导入配置文件
const config = require('./config')

// 解析 token 的中间件
const expressJWT = require('express-jwt')

// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
// 这里是以 /api 开头的接口都不需要进行 token 认证
app.use(expressJWT.expressjwt({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({ path: [/^\/api/]}))
  1. 在 app.js 中的 错误级别中间件 里面，捕获并处理 Token 认证失败后的错误：
// 错误中间件
app.use((err, req, res, next)=>{
    //验证失败导致的错误
    if(err instanceof joi.ValidationError){
        return res.cc(err)
    }
    //身份认证失败后的错误
    if(err.name === 'UnauthorizedError') {
        return res.cc('身份认证失败')
    }
    //否则就是未知的错误
    res.cc(err)
})

完整的 app.js 代码

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

//2、创建 express 的服务器实例
const app = express()

// 导入并注册 cors 中间件
const cors = require('cors')
// 将 cors 注册为全局中间件
app.use(cors())

//导入 joi 包
const joi = require('joi')

// 一定要在路由之前配置解析 Token 的中间件
const expressJWT = require('express-jwt')
//还要引入我们编写的配置文件
const config = require('./config')

//在路由之前封装 res.cc 函数：即全局处理失败的中间件函数
app.use((req,res,next)=>{
    // status 默认值为1，表示失败的情况
    // err的值，可能是一个错误对象，也可能是一个错误的描述字符串
    res.cc = function (err, status=1){
        res.send({
            status,
            message: err instanceof Error ? err.message : err
        })
    }
    next()
})

//注册全局中间件
app.use(expressJWT.expressjwt({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({ path: [/^\/api/]}))

//配置解析表单数据的内置中间件，这个中间件只能解析 application/x-www-form-urlencoded 格式的表单文件
app.use(express.urlencoded({ extended: false}))

//导入并注册用户路由模块
const userRouter = require('./router/user')
app.use('/api', userRouter)

//定义错误级别的中间件
app.use((err, req, res, next)=>{
    //验证失败导致的错误
    if(err instanceof joi.ValidationError){
        return res.cc(err)
    }
    //身份认证失败后的错误
    if(err.name === 'UnauthorizedError') {
        return res.cc('身份认证失败')
    }
    //否则就是未知的错误
    res.cc(err)
})

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

注意：如果报 res.cc is not a function 错误

必须将我们的自定义全局中间件放在 jwt 中间件引入和解析的前面，不然代码还没有运行到 cc 函数那里就已经报错了。

个人中心

获取用户的基本信息

实现步骤

  1. 初始化 路由 模块
  2. 初始化 路由处理函数 模块
  3. 获取用户的基本信息

初始化路由模块

  1. 创建 /router/userinfo.js 路由模块，并初始化如下的代码结构：
// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()

// 获取用户的基本信息
router.get('/userinfo', (req, res) => {
  res.send('ok')
})

// 向外共享路由对象
module.exports = router
  1. 在 app.js 中导入并使用个人中心的路由模块：
// 导入并使用用户信息路由模块
const userinfoRouter = require('./router/userinfo')
// 注意：以 /my 开头的接口，都是有权限的接口，需要进行 Token 身份认证
app.use('/my', userinfoRouter)

初始化路由处理函数模块

  1. 创建 /router_handler/userinfo.js 路由处理函数模块，并初始化如下的代码结构：
// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  res.send('ok')
}
  1. 修改 /router/userinfo.js 中的代码如下：
const express = require('express')
const router = express.Router()

// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')

// 获取用户的基本信息
router.get('/userinfo', userinfo_handler.getUserInfo)

module.exports = router

获取用户的基本信息

  1. 在 /router_handler/userinfo.js 头部导入数据库操作模块：
// 导入数据库操作模块
const db = require('../db/index')
  1. 定义 SQL 语句：
// 根据用户的 id，查询用户的基本信息
// 注意：为了防止用户的密码泄露，需要排除 password 字段
const sql = `select id, username, nickname, email, user_pic from ev_users where id=?`
  1. 调用 db.query() 执行 SQL 语句：
// 注意：req 对象上的 auth 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
    db.query(sql, req.auth.id, (err, results) => {
        // 1. 执行 SQL 语句失败
        if (err) return res.cc(err)

        // 2. 执行 SQL 语句成功，但是查询到的数据条数不等于 1
        if (results.length !== 1) return res.cc('获取用户信息失败！')

        // 3. 将用户信息响应给客户端
        res.send({
            status: 0,
            message: '获取用户基本信息成功！',
            data: results[0],
        })
    })

更新用户的基本信息

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现更新用户基本信息的功能

定义路由和处理函数

  1. 在 /router/userinfo.js 模块中，新增 更新用户基本信息 的路由：
// 更新用户的基本信息
router.post('/userinfo', userinfo_handler.updateUserInfo)
  1. 在 /router_handler/userinfo.js 模块中，定义并向外共享 更新用户基本信息 的路由处理函数：
// 更新用户基本信息的处理函数
module.exports.updateUserInfo = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 /schema/user.js 验证规则模块中，定义 id，nickname，email 的验证规则如下：
// 定义 id, nickname, emial 的验证规则
const id = joi.number().integer().min(1).required()
const nickname = joi.string().required()
const user_email = joi.string().email().required()
  1. 并使用 exports 向外共享如下的 验证规则对象：
// 验证规则对象 - 更新用户基本信息
module.exports.update_userinfo_schema = {
    body: {
        id,
        nickname,
        //上面因为规则里叫id且前端传的参数也叫id，因此可以简写成一个id
        //如果不一样的话，比如下面这个规则里user_email
        //然后前端传来的又叫 email 的话，就需要写成这种键值对形式
        email: user_email,
    },
}
  1. 在 /router/userinfo.js 模块中，导入验证数据合法性的中间件：
// 导入验证数据合法性的中间件
const expressJoi = require('@escook/express-joi')
  1. 在 /router/userinfo.js 模块中，导入需要的验证规则对象：
// 导入需要的验证规则对象
const { update_userinfo_schema } = require('../schema/user')
  1. 在 /router/userinfo.js 模块中，修改 更新用户的基本信息 的路由如下：
// 更新用户的基本信息
router.post('/userinfo', expressJoi(update_userinfo_schema), userinfo_handler.updateUserInfo)

实现更新用户基本信息的功能

  1. 定义待执行的 SQL 语句：
const sql = `update ev_users set ? where id=?`
  1. 调用 db.query() 执行 SQL 语句并传参：
db.query(sql, [req.body, req.body.id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 执行 SQL 语句成功，但影响行数不为 1
  if (results.affectedRows !== 1) return res.cc('修改用户基本信息失败！')

  // 修改用户信息成功
  return res.cc('修改用户基本信息成功！', 0)
})

重置密码

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现重置密码的功能

定义路由和处理函数

  1. 在 /router/userinfo.js 模块中，新增 重置密码 的路由：
// 重置密码的路由
router.post('/updatepwd', userinfo_handler.updatePassword)
  1. 在 /router_handler/userinfo.js 模块中，定义并向外共享 重置密码 的路由处理函数：
// 重置密码的处理函数
module.exports.updatePassword = (req, res) => {
  res.send('ok')
}

验证表单数据

核心验证思路：旧密码与新密码，必须符合密码的验证规则，并且新密码不能与旧密码一致！

  1. 在 /schema/user.js 模块中，使用 exports 向外共享如下的 验证规则对象：
// 验证规则对象 - 重置密码
module.exports.update_password_schema = {
  body: {
    // 使用 password 这个规则，验证 req.body.oldPwd 的值
    oldPwd: password,
    // 使用 joi.not(joi.ref('oldPwd')).concat(password) 规则，验证 req.body.newPwd 的值
    // 解读：
    // 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),
  },
}
  1. 在 /router/userinfo.js 模块中，导入需要的验证规则对象：
// 导入需要的验证规则对象
const { update_userinfo_schema, update_password_schema } = require('../schema/user')
  1. 并在 重置密码的路由 中，使用 update_password_schema 规则验证表单的数据，示例代码如下：
router.post('/updatepwd', expressJoi(update_password_schema), userinfo_handler.updatePassword)

实现重置密码的功能

  1. 根据 id 查询用户是否存在：
// 定义根据 id 查询用户数据的 SQL 语句
const sql = `select * from ev_users where id=?`

// 执行 SQL 语句查询用户是否存在
db.query(sql, req.auth.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 检查指定 id 的用户是否存在
  if (results.length !== 1) return res.cc('用户不存在！')

  // TODO：判断提交的旧密码是否正确
})
  1. 判断提交的 旧密码 是否正确：
// 在头部区域导入 bcryptjs 后，
// 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
// compareSync() 函数的返回值为布尔值，true 表示密码正确，false 表示密码错误
const bcrypt = require('bcryptjs')

// 判断提交的旧密码是否正确
const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
if (!compareResult) return res.cc('原密码错误！')
  1. 对新密码进行 bcrypt 加密之后，更新到数据库中：
// 定义更新用户密码的 SQL 语句
const sql = `update ev_users set password=? where id=?`

// 对新密码进行 bcrypt 加密处理
const newPwd = bcrypt.hashSync(req.body.newPwd, 10)

// 执行 SQL 语句，根据 id 更新用户的密码
db.query(sql, [newPwd, req.auth.id], (err, results) => {
  // SQL 语句执行失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新密码失败！')

  // 更新密码成功
  res.cc('更新密码成功！', 0)
})

更新用户头像

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现更新用户头像的功能

定义路由和处理函数

  1. 在 /router/userinfo.js 模块中，新增 更新用户头像 的路由：
// 更新用户头像的路由
router.post('/update/avatar', userinfo_handler.updateAvatar)
  1. 在 /router_handler/userinfo.js 模块中，定义并向外共享 更新用户头像 的路由处理函数：
// 更新用户头像的处理函数
module.exports.updateAvatar = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 /schema/user.js 验证规则模块中，定义 avatar 的验证规则如下：
// dataUri() 指的是如下格式的字符串数据：
// data:image/png;base64,VE9PTUFOWVNFQ1JFVFM=
const avatar = joi.string().dataUri().required()
  1. 并使用 exports 向外共享如下的 验证规则对象：
// 验证规则对象 - 更新头像
module.exports.update_avatar_schema = {
  body: {
    avatar,
  },
}
  1. 在 /router/userinfo.js 模块中，导入需要的验证规则对象：
const { update_avatar_schema } = require('../schema/user')
  1. 在 /router/userinfo.js 模块中，修改 更新用户头像 的路由如下：
router.post('/update/avatar', expressJoi(update_avatar_schema), userinfo_handler.updateAvatar)

实现更新用户头像的功能

  1. 定义更新用户头像的 SQL 语句：
const sql = 'update ev_users set user_pic=? where id=?'
  1. 调用 db.query() 执行 SQL 语句，更新对应用户的头像：
db.query(sql, [req.body.avatar, req.auth.id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 执行 SQL 语句成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新头像失败！')

  // 更新用户头像成功
  return res.cc('更新头像成功！', 0)
})

文章分类管理

新建 ev_article_cate 表

创建表结构

在这里插入图片描述

新增两条初始数据

在这里插入图片描述

获取文章分类列表

实现步骤

  1. 初始化路由模块
  2. 初始化路由处理函数模块
  3. 获取文章分类列表数据

初始化路由模块

  1. 创建 /router/artcate.js 路由模块，并初始化如下的代码结构：
// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()

// 获取文章分类的列表数据
router.get('/cates', (req, res) => {
  res.send('ok')
})

// 向外共享路由对象
module.exports = router
  1. 在 app.js 中导入并使用文章分类的路由模块：
// 导入并使用文章分类路由模块
const artCateRouter = require('./router/artcate')
// 为文章分类的路由挂载统一的访问前缀 /my/article
app.use('/my/article', artCateRouter)

初始化路由处理函数模块

  1. 创建 /router_handler/artcate.js 路由处理函数模块，并初始化如下的代码结构：
// 获取文章分类列表数据的处理函数
module.exports.getArticleCates = (req, res) => {
  res.send('ok')
}
  1. 修改 /router/artcate.js 中的代码如下：
const express = require('express')
const router = express.Router()

// 导入文章分类的路由处理函数模块
const artcate_handler = require('../router_handler/artcate')

// 获取文章分类的列表数据
router.get('/cates', artcate_handler.getArticleCates)

module.exports = router

获取文章分类列表数据

  1. 在 /router_handler/artcate.js 头部导入数据库操作模块：
// 导入数据库操作模块
const db = require('../db/index')
  1. 定义 SQL 语句：
// 根据分类的状态，获取所有未被删除的分类列表数据
// is_delete 为 0 表示没有被 标记为删除 的数据
const sql = 'select * from ev_article_cate where is_delete=0 order by id asc'
  1. 调用 db.query() 执行 SQL 语句：
db.query(sql, (err, results) => {
  // 1. 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 2. 执行 SQL 语句成功
  res.send({
    status: 0,
    message: '获取文章分类列表成功！',
    data: results,
  })
})

新增文章分类

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 查询 分类名称 与 分类别名 是否被占用
  4. 实现新增文章分类的功能

定义路由和处理函数

  1. 在 /router/artcate.js 模块中，添加 新增文章分类 的路由：
// 新增文章分类的路由
router.post('/addcates', artcate_handler.addArticleCates)
  1. 在 /router_handler/artcate.js 模块中，定义并向外共享 新增文章分类 的路由处理函数：
// 新增文章分类的处理函数
module.exports.addArticleCates = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 创建 /schema/artcate.js 文章分类数据验证模块，并定义如下的验证规则：
// 导入定义验证规则的模块
const joi = require('joi')

// 定义 分类名称 和 分类别名 的校验规则
const name = joi.string().required()
const alias = joi.string().alphanum().required()

// 校验规则对象 - 添加分类
module.exports.add_cate_schema = {
  body: {
    name,
    alias,
  },
}
  1. 在 /router/artcate.js 模块中，使用 add_cate_schema 对数据进行验证：
// 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 导入文章分类的验证模块
const { add_cate_schema } = require('../schema/artcate')

// 新增文章分类的路由
router.post('/addcates', expressJoi(add_cate_schema), artcate_handler.addArticleCates)

查询分类名称与别名是否被占用

  1. 定义查重的 SQL 语句：
// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where name=? or alias=?`
  1. 调用 db.query() 执行查重的操作：
// 执行查重操作
db.query(sql, [req.body.name, req.body.alias], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 判断 分类名称 和 分类别名 是否被占用
  if (results.length === 2) return res.cc('分类名称与别名被占用，请更换后重试！')
  // 分别判断 分类名称 和 分类别名 是否被占用
  if (results.length === 1 && results[0].name === req.body.name) return res.cc('分类名称被占用，请更换后重试！')
  if (results.length === 1 && results[0].alias === req.body.alias) return res.cc('分类别名被占用，请更换后重试！')

  // TODO：新增文章分类
})

实现新增文章分类的功能

  1. 定义新增文章分类的 SQL 语句：
const sql = `insert into ev_article_cate set ?`
  1. 调用 db.query() 执行新增文章分类的 SQL 语句：
db.query(sql, req.body, (err, results) => {
  // SQL 语句执行失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('新增文章分类失败！')

  // 新增文章分类成功
  res.cc('新增文章分类成功！', 0)
})

根据 Id 删除文章分类

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现删除文章分类的功能

定义路由和处理函数

  1. 在 /router/artcate.js 模块中，添加 删除文章分类 的路由：
// 删除文章分类的路由
router.get('/deletecate/:id', artcate_handler.deleteCateById)
  1. 在 /router_handler/artcate.js 模块中，定义并向外共享 删除文章分类 的路由处理函数：
// 删除文章分类的处理函数
module.exports.deleteCateById = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 /schema/artcate.js 验证规则模块中，定义 id 的验证规则如下：
// 定义 分类Id 的校验规则
const id = joi.number().integer().min(1).required()
  1. 并使用 exports 向外共享如下的 验证规则对象：
// 校验规则对象 - 删除分类
module.exports.delete_cate_schema = {
  params: {
    id,
  },
}
  1. 在 /router/artcate.js 模块中，导入需要的验证规则对象，并在路由中使用：
// 导入删除分类的验证规则对象
const { delete_cate_schema } = require('../schema/artcate')

// 删除文章分类的路由
router.get('/deletecate/:id', expressJoi(delete_cate_schema), artcate_handler.deleteCateById)

实现删除文章分类的功能

  1. 定义删除文章分类的 SQL 语句：
const sql = `update ev_article_cate set is_delete=1 where id=?`
  1. 调用 db.query() 执行删除文章分类的 SQL 语句：
db.query(sql, req.params.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('删除文章分类失败！')

  // 删除文章分类成功
  res.cc('删除文章分类成功！', 0)
})

根据 Id 获取文章分类数据

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 实现获取文章分类的功能

定义路由和处理函数

  1. 在 /router/artcate.js 模块中，添加 根据 Id 获取文章分类 的路由：
router.get('/cates/:id', artcate_handler.getArticleById)
  1. 在 /router_handler/artcate.js 模块中，定义并向外共享 根据 Id 获取文章分类 的路由处理函数：
// 根据 Id 获取文章分类的处理函数
module.exports.getArticleById = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 /schema/artcate.js 验证规则模块中，使用 exports 向外共享如下的 验证规则对象：
// 校验规则对象 - 根据 Id 获取分类
module.exports.get_cate_schema = {
  params: {
    id,
  },
}
  1. 在 /router/artcate.js 模块中，导入需要的验证规则对象，并在路由中使用：
// 导入根据 Id 获取分类的验证规则对象
const { get_cate_schema } = require('../schema/artcate')

// 根据 Id 获取文章分类的路由
router.get('/cates/:id', expressJoi(get_cate_schema), artcate_handler.getArticleById)

实现获取文章分类的功能

  1. 定义根据 Id 获取文章分类的 SQL 语句：
const sql = `select * from ev_article_cate where id=?`
  1. 调用 db.query() 执行 SQL 语句：
db.query(sql, req.params.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是没有查询到任何数据
  if (results.length !== 1) return res.cc('获取文章分类数据失败！')

  // 把数据响应给客户端
  res.send({
    status: 0,
    message: '获取文章分类数据成功！',
    data: results[0],
  })
})

根据 Id 更新文章分类数据

实现步骤

  1. 定义路由和处理函数
  2. 验证表单数据
  3. 查询 分类名称 与 分类别名 是否被占用
  4. 实现更新文章分类的功能

定义路由和处理函数

  1. 在 /router/artcate.js 模块中，添加 更新文章分类 的路由：
// 更新文章分类的路由
router.post('/updatecate', artcate_handler.updateCateById)
  1. 在 /router_handler/artcate.js 模块中，定义并向外共享 更新文章分类 的路由处理函数：
// 更新文章分类的处理函数
module.exports.updateCateById = (req, res) => {
  res.send('ok')
}

验证表单数据

  1. 在 /schema/artcate.js 验证规则模块中，使用 exports 向外共享如下的 验证规则对象：
// 校验规则对象 - 更新分类
module.exports.update_cate_schema = {
  body: {
    Id: id,
    name,
    alias,
  },
}
  1. 在 /router/artcate.js 模块中，导入需要的验证规则对象，并在路由中使用：
// 导入更新文章分类的验证规则对象
const { update_cate_schema } = require('../schema/artcate')

// 更新文章分类的路由
router.post('/updatecate', expressJoi(update_cate_schema), artcate_handler.updateCateById)

查询分类名称与别名是否被占用

  1. 定义查重的 SQL 语句：
// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where Id<>? and (name=? or alias=?)`
  1. 调用 db.query() 执行查重的操作：
// 执行查重操作
db.query(sql, [req.body.Id, req.body.name, req.body.alias], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 判断 分类名称 和 分类别名 是否被占用
  if (results.length === 2) return res.cc('分类名称与别名被占用，请更换后重试！')
  if (results.length === 1 && results[0].name === req.body.name) return res.cc('分类名称被占用，请更换后重试！')
  if (results.length === 1 && results[0].alias === req.body.alias) return res.cc('分类别名被占用，请更换后重试！')

  // TODO：更新文章分类
})

实现更新文章分类的功能

  1. 定义更新文章分类的 SQL 语句：
const sql = `update ev_article_cate set ? where Id=?`
  1. 调用 db.query() 执行 SQL 语句：
db.query(sql, [req.body, req.body.Id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新文章分类失败！')

  // 更新文章分类成功
  res.cc('更新文章分类成功！')
})

总结

那么 Node.js 到这里就全部结束啦！

后端接口基本都是 CRUD 的各种变种，掌握这些已经足以成为一名 Express.js 的后端开发工程师了捏。

继续加油！

在地球迷路的怪兽
关注
  • 17
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Nodejs服务端开发实战——大事件后台API项目（获取文章的列表数据功能待完善...）
SongD1114的博客
04-03 2561
Nodejs服务端开发实战之大事件后台API项目
技术淘宝
dicha7140的博客
06-23 2万+
???? ???? ???? ????精度前端学习 ——前端开发100天（置顶） http://alloyteam.github.io/CodeGuide/https://github.com/AlloyTeam/CodeGuide cmd控制台的小技巧：可以直接将文件夹/文件丢进去，这样就会打印出该路径了。 舒服的字体家族样式： font: 300 16px/1.8 ...
Nodejs后台项目 —— 大事件后台 API 接口项目实战（JWT + Cors + MySQL）
秋天，黄叶坠地，凉风有信。
03-25 2545
文章目录大事件后台API接口项目实战详解1. 初始化1.1 创建项目1.2 配置 cors 跨域1.3 配置解析表单数据的中间件1.4 初始化路由相关的文件夹1.5 初始化用户路由模块1.6 抽离用户路由模块中的处理函数2. 登录注册2.1 新建 ev_users 表2.2 安装并配置 mysql 模块2.3 注册2.3.0 实现步骤2.3.1 检测表单数据是否合法2.3.2 检测用户名是否被占用2.3.3 对密码进行加密处理2.3.4 插入新用户2.4 优化 res.send() 代码2.5 优化表单数据
工作中使用到的单词（软件开发）_2023_0316备份
sun0322
03-16 9939
目录■Java学习汇总■常用链接■2020/03/15 （最初整理 242个单词）2020 6/28 整理2020 6/29 整理2020 7/6 整理■2020 7/23 整理■2020/10/07 以降整理■2020/11/02 以降整理■2020/12/04 以降整理■2020/12/14以降整理■2021/01/01以降整理■2021/02/22以降整理■匿名内部类，lambda表达式，JDK7新特性，等等java相关■2021/03/18以降整理Linux系统性能 相关■其他各种单词，知识（l
2024前端面试题！（附答案及解析）（2024.5月最新版）
热门推荐
这世上从不缺让人上头的新鲜感，能顾及你情绪的人实属难得。
03-27 7万+
2024前端面试题！面试宝典！总结心得！（附答案及解析）会持续更新哦！（2024.5月最新版）
Web应用开发基础
2301_76541246的博客
12-23 927
对于web前端学习小白来说，html+css基础尤为重要，可以说是编程小白的必经之路，学完后能写出你看到的静态页面。1）PC端网站布局包含知识点： HTML基础，CSS基础，CSS核心属性；CSS样式层叠，继承，盒模型；容器，溢出及元素类型；浏览器兼容与宽高自适应……2）HTML5+CSS3基础包含知识点： HTML5新增的元素与属性；表单域增强元素；CSS3选择器；文字字体相关样式；CSS3位移与变形处理……3）WebApp页面布局包含知识点： 移动端页面设计规范；移动端切图；
谷粒商城：06. 前端开发基础知识
KaiSarH
04-20 1106
谷粒商城：06. 前端开发基础知识
前端面试35k题库2021-@莫成尘
莫成尘的博客
07-28 1867
Web前端面试题宝典【精编版】 过了八月，马上到了金九银十的跳槽季，找工作的时候曾一周面试了十多家公司，从一开始被面试官虐的体无完肤到最后对答如流，过程中经历了多少挑灯夜战的晚上，恶补前端知识，努力的付出终会有回报，最终获得了心仪的offer，所有的一切都是值得的。整理一下面试过程中遇到的高频题目，这些都是精简后的真题，就算不能百分百涵盖，至少也囊括7、8%了，如果面试过程中的你能回答出百分之八十左右的题目，不出大的纰漏offer基本上也就稳收囊中了，剩下的百分之二十是面试官测试你的技术极限在哪里，也会因
最全面、最详细web前端面试题及答案总结
HanXiaoXi_yeal的博客
02-01 3万+
2021最全面、最详细web前端面试题及答案总结 总结不易，希望可以帮助到即将面试或还在学习中的web前端小伙伴，祝面试顺利，拿高薪！ 本章是HTML考点的⾮重难点，因此我们采⽤简略回答的⽅式进⾏撰写，所以不会有太多详细的解释。我们约定，每个问题后我们标记『✨ 』的为⾼频⾯试题 doctype的作⽤是什么？✨ DOCTYPE是html5标准⽹⻚声明，且必须声明在HTML⽂档的第⼀⾏。来告知浏览器的解析器⽤什么⽂档标准解析这个 ⽂档，不同的渲染模式会影响到浏览器对于 CSS 代码甚⾄ JavaScript
知识领域： 后端开发 技术关键词： Node.js 内容关键词： Express框架 用途： 构建RESTful API
04-04
软件设计说明书知识领域： 后端开发 技术关键词： Node.js 内容关键词： Express框架 用途： 构建RESTful API 对资源的描述： 该资源是一个实用的视频课程，教授开发者如何使用Node.js和Express框架构建高性能的...
知识领域： 后端开发 技术关键词： Node.js 内容关键词： 服务器端编程
05-16
unity游戏知识领域： 后端开发 技术关键词： Node.js 内容关键词： 服务器端编程 用途： 用于创建和维护高性能的服务器端应用程序。 对资源的描述： 该资源是一个Node.js服务器端编程的实践指南，提供了如何使用Node...
NodeArch是一个Node.js后端框架-Node.js开发
05-27
NodeArch是一个Node.js后端框架，旨在解决为后端创建Node.js APP时的设计和体系结构问题。 NodeArch:waving_hand:欢迎使用NodeArch NodeArch是一个Node.js后端框架，旨在解决在为后端创建Node.js APP时的设计和体系...
从零开始学习后端开发：Node.js与Express框架入门教程
04-19
本教程将带领你从零基础开始学习后端开发，并通过一个简单的案例来展示如何将所学知识应用到实际项目中。我们将使用Node.js作为后端开发的工具，并结合Express框架来快速搭建一个功能完善的应用程序。
后端开发 技术关键词： Node.js 内容关键词： 服务器端JavaScript开发 用途： 用于构建高性能的服务器端应用程序
03-26
后端开发 技术关键词： Node.js ...内容描述： 这个资源是一个全面的Node.js开发指南，涵盖了从基础概念到高级主题的所有内容，包括异步编程、事件驱动、模块化以及如何与数据库和外部APIs交互的最佳实践。
node.js —— 解读http模块
迪幻的博客
05-19 625
只要服务器接收到了客户端的请求，就会调用通过 server.on() 为服务器绑定的 request 事件处理函数。
使用Node.js搭建服务器
最新发布
AGW.的博客
05-28 241
由于实践中很多地方需要搭建服务器，所以整理了一下如何用node.js搭建一个服务器。
Node.js和npm常用命令
ChinaDragon10的博客
05-28 756
Node.js 是一个开源的、跨平台的 JavaScript 运行时环境。 npm(Node Package Manager)是Node.js的软件包管理器。
Axios的使用简单说明
m0_59365887的博客
05-24 264
axios可以发送ajax请求，不同的方法可以发送不同的请求:axios.get：发送get请求axios.post：发送post请求axios.put：发送put请求：发送delete请求无论哪种方法，第一个参数为请求的后端接口因为post和put请求方式，参数会放到请求体中，而get和delete请求方式，参数会放在url中所以1.post 和put请求时，第二个参数是一个对象，存储要发送给后端的数据2.get 和put。
node.js后端开发
03-28
Node.js是一个基于Chrome V8引擎的JavaScript运行时环境，它允许开发者使用JavaScript语言进行后端开发。相比于传统的后端开发语言，如Java或Python，Node.js具有以下几个特点： 1. 异步非阻塞：Node.js采用事件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在地球迷路的怪兽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值