Node-进阶知识

原生 node

// 原生 node
const http = require('http') // Node 自带的
const querystring = require('querystring') // 处理query参数，Node 自带的
const server = http.createServer((req, res) => {
    console.log('req', req)
    console.log('res', res)

    const method = req.method
    const url = req.url
    const path = url.split('?')[0]
    const query = querystring.parse(url.split('?')[1]) // get 参数获取
    const env = process.env.NODE_ENV // 环境变量，在 scripts 中通过 cross-env NODE_ENV=dev 来设置
    res.setHeader('Content-type', 'application/json') // 字符串的格式是json
    const resData = { method, url, path, query, env } // get请求并且路由是'/api/get'

    // 下面这两个判断逻辑，可以按模块抽离到 router 文件夹中，这边只是做演示
    if (method === 'GET' && path === '/api/get') {
        res.end(JSON.stringify(resData)) // 返回字符串或二进制
        return
    }

    // post请求并且路由是'/api/post'
    if (method === 'POST' && path === '/api/post') {
        // POST 请求参数获取
        // 方式一（这种方式可能出现截断问题，不推荐）
        let postData = ''
        req.on('data', (chunk) => {
            postData += chunk.toString()
        })
        req.on('end', () => {
            resData.postData = postData
            res.end(JSON.stringify(resData)) // 返回字符串或二进制
        })

        // 方式二（推荐使用）
        const chunks = []
        req.on('data', (chunk) => {
            chunks.push(chunk)
        })
        req.on('end', () => {
            const buf = Buffer.concat(chunks)
            const str = buf.toString()
            const obj = JSON.parse(str) // 参数对象
            res.end(buf) // 返回字符串或二进制
        })
        return
    }

    // 未命中路由, 返回404
    res.writeHead(404, {
        'Content-type': 'text/plain'
    })
    res.write('404 Not Found')
    res.end()
})
server.listen(8000, () => {
    console.log('localhost:8000启动成功！')
})

express

// express
1. 使用express脚手架创建
    npm install express-generator -g // 安装
    express test // 创建
    npm install // 安装依赖
    npm start // 运行
2. 在node中引入
npm i -S express
const express = require('express')
const cookieParser = require('cookie-parser')
const logger = require('morgan')
const session = require('express-session')
const redis = require('redis')
const redisStore = require('connect-redis')(session)
const fs = require('fs')
const path = require('path')

const app = express() // 创建 express 应用

const ENV = process.env.NODE_ENV
if (ENV !== 'production') {
    // logger 可以传入不同的 type，不同类型的日志不一样，不止下面两种，具体看文档
  app.use(logger('dev')) // 开发模式
//   app.use(logger('combined')) // 更全面的日志
} else {
  const logFileName = path.join(__dirname, 'logs', 'access.log')
  const writeStream = fs.createWriteStream(logFileName, {
    flags: 'a' // 追加写入
  })
  app.use(logger('combined', {
    stream: writeStream
  }))
}

app.use(express.static(path.join(__dirname, 'public'))) // 静态文件
app.use(express.json()) // 解析post请求json格式的数据, 可以直接通过req.body获取
app.use(express.urlencoded({ extended: false })) // 解析post请求其他格式的数据, 可以直接通过req.body获取
app.use(cookieParser()) // 解析cookie, 可以直接通过req.cookie获取

const redisClient = redis.create(lient(3006, '127.0.0.1'))  // 连接redis
const sessionStore = new redisStore({
  client: redisClient
})
app.use(session({ // 设置session
  secret: 'chenj666', // 密钥
  cookie: {
    path: '/',
    httpOnly: true,
    maxAge: 24 * 60 * 60 * 1000
  },
  store: sessionStore // 存储到redis中
}))

app.use('/', function(req, res, next) { // 相当于统一处理的路由, 有next
  console.log('路由中间件')
  console.log(req.body) // 可以直接拿到Post请求的参数
  console.log(req.query) // 可以直接拿到get请求的参数
  next()
})
app.get('/get', function(req, res) { // 只针对于get路由, 没有next
  console.log('get路由')
  console.log(req.body) // 可以直接拿到Post请求的参数
  console.log(req.query) // 可以直接拿到get请求的参数
  // res.json 相当于 res.setHeader('Content-type', 'application/json') + res.end(JSON,stringify(data))
  res.json({ code: 0 }) // 可以直接只用res.json返回json格式的数据, 不用再使用res.end(JSON.stringify(resData))
})
app.post('/post', function(req, res) { // 只针对于post路由, 没有next
  console.log('post路由')
  console.log(req.body) // 可以直接拿到Post请求的参数
  console.log(req.query) // 可以直接拿到get请求的参数
  // res.json 相当于 res.setHeader('Content-type', 'application/json') + res.end(JSON,stringify(data))
  res.json({ code: 0 }) // 可以直接只用res.json返回json格式的数据, 不用再使用res.end(JSON.stringify(resData))
})

// 参数可以多个, 相当于中间件, 用于校验登录权限等
app.post('/post', fn1, function(req, res) { // 只针对于post路由, 没有next
  console.log('post路由')
  console.log(req.body) // 可以直接拿到Post请求的参数
  console.log(req.query) // 可以直接拿到get请求的参数
  // res.json 相当于 res.setHeader('Content-type', 'application/json') + res.end(JSON,stringify(data))
  res.json({ code: 0 }) // 可以直接只用res.json返回json格式的数据, 不用再使用res.end(JSON.stringify(resData))
})

// 使 express 监听 5000 端口号发起的 http 请求
const server = app.listen(5000, function() {
  console.log('ok')
})
----------------------------------------------------------------------------------------------
// 路由演示, 有两个文件, 实际匹配的路由是 /blog/get
// app文件
const express = require('express')
const blogRouter = require('./routes/blog')
const app = express() // 创建 express 应用
app.use('/blog', blogRouter)
// 路由blog文件
const express = require('express')
const router = express.Router()
router.get('/get', function(req, res, next) { // /blog/get
  res.json({ code: 0 })
})
module.exports = router
----------------------------------------------------------------------------------------------
// 中间件, 中间件是一个函数,在请求和响应周期中被顺序调用
// 中间件需要在响应结束前被调用,除了异常处理的中间件需要后置
// 如果中间件中有异步代码，则会影响到后面中间件的执行时间
// express 会等异步执行完之后才会继续执行下一个中间件
const myLogger = function(req, res, next) {
  console.log('myLogger')
  next()
}
app.use(myLogger)
----------------------------------------------------------------------------------------------
// 异常处理,通过自定义异常处理中间件处理请求中产生的异常
// 注意:
// 第一,参数一个不能少,否则会视为普通的中间件
// 第二,中间件需要在请求之后引用
1. 异常中间件的回调函数中包含了 4 个参数
2. 异常中间件全局只包含一个
3. 异常中间件可以传递给普通中间件
4. 异常中间件需要放在所有中间件的最后
5. 异常中间件只能捕获回调函数中的异常
  1. 全局的异常捕获需要监听 'uncaughtException' 事件
    process.on('uncaughtException', function(err) => { console.log(err) })
  2. 全局的 promise 异常需要监听 'unhandleRejection' 事件
    process.on('unhandleRejection', function(err) => { console.log(err) })
app.get('/', function(req, res) {
  throw new Error('something has error...')
})

const errorHandler = function (err, req, res, next) {
  console.log('errorHandler...')
  res.status(500)
  res.send('down...')
}

app.use(errorHandler)
----------------------------------------------------------------------------------------------
app.use 方法的路由和中间件会按匹配规则顺序执行，通过 next 执行下一个（重要！！！）
app.get 和 app.post 也是一样，如果中间件直接 res.json()，没有调用 next，则不会直接下一个
这三个方法都可以传入无数个函数作为参数，这些参数也是通过 next 进行连接
    1. 执行顺序
        app.use((req, res, next) => { next() })
        app.use('/', (req, res, next) => { next() })
        app.use('/api', (req, res, next) => { next() })
        app.get('/api', (req, res, next) => { next() })
        app.get('/api/get-list', (req, res, next) => { next() })
    2. 多个中间件参数，这边的 loginCheck 也是个中间件
        app.get('/api/get-list', loginCheck, (req, res, next) => {
            next()
        })
----------------------------------------------------------------------------------------------
// 中间件实现逻辑
1. app.use 用来注册中间件，先收集起来
2. 遇到 http 请求，根据 path 和 method 判断触发哪些
3. 实现 next 机制，即上一个通过 next 触发一下

KOA

// KOA
1. koa的中间件就是一个函数使用
2. const app = new koa()
   app.use((ctx, next) => { code }) // ctx用于中间件之间的传值,可以直接向ctx上面挂载属性,如ctx.a = 1,在另一个中间件中使用ctx.a获取
   app.listen(3000) // 监听3000端口
3. 洋葱模型,next()就是分界线
  1. 请求进来可能会经过多个中间件，而中间件可能需要依赖其他中间件，所以洋葱模型
     可以相当于如果有调用新的中间件就会一直调用下去，但是调用方本身的中间件并未
     执行完成，当所有调用中间件完成后，才会往上一步一步返回响应，最后结束第一个中间件
  2. 执行的顺序：顺序执行
  3. 回调的顺序：反向执行
  4. 先进后出
4. 中间件的调用都会返回promise,在每个next()方法前面加上await保证执行顺序是洋葱模型
5. koa-router
    const router = new Router()
    router.get('/', (ctx, next) => { code })
    app.use(router.routes())
    router.post('/v1/:id/books', (ctx, next) => {
      const path = ctx.params // 获取url上的参数id
      const query = ctx.request.query // 获取查询参数?后面的
      const headers = ctx.request.header // 获取请求头的内容
      app.use(parser()) // koa-bodyparser中间件
      const body = ctx.request.body // 获取http请求的body内容
    })
6. 在ctx中可以获取到很多: ctx.path、ctx.method等
7. ctx.body = { key: 'book' } // 在浏览器中显示的是json对象
8. 可以使用nodemon app.js来自动重启服务 // npm install nodemon
9. 通过requireDirectory实现路由自动加载
10. try/catch不能捕获到异步代码的异常,需要使用async和await来捕获异常
11. 在异步调用中必须使用async和await来同步代码
12. 浏览器中或API中返回NO Found是因为API没有返回结果
----------------------------------------------------------------------------------------------
// 示例
1. 使用koa脚手架创建, koa有两个版本, koa1是用generator做的, koa2是用async/await做的
    npm install koa-generator -g // 安装
    koa2 test // 创建
    koa2 -e test // ejs 模板
    npm install // 安装依赖
    npm start // 运行
2. 在node中引入
const Koa = require('koa')
const app = new Koa()
const json = require('koa-json')
const helmet = require('koa-helmet')
const bodyparser = require('koa-bodyparser') // 替换方案是 koa-body，它支持图像上传，koa-bodyparser 不支持
const logger = require('koa-logger') // 只是把在node环境中的console的打印格式优化, 并非日志
const morgan = require('koa-morgan') // 记录日志
const fs = require('fs')
const path = require('path')
const session = require('koa-generic-session')
const redisStore = require('koa-redis')

app.use(helmet()) // 自动添加安全的 hearder 头

app.use(bodyparser({ // 解析post请求json和其他格式的数据, 可以直接通过ctx.request.body获取
  enableTypes: ['json', 'form', 'text']
}))
app.use(json()) // 用于返回 json 格式的字符串

 // 日志
app.use(logger()) // 只是把在node环境中的console的打印格式优化, 并非日志
const ENV = process.env.NODE_ENV
if (ENV !== 'production') {
  app.use(morgan('dev')) // 记录日志, 也可传入 combined 记录更全面的日志
} else {
  const logFileName = path.join(__dirname, 'logs', 'access.log')
  const writeStream = fs.createWriteStream(logFileName, {
    flags: 'a' // 追加写入
  })
  app.use(morgan('combined', {
    stream: writeStream
  }))
}

app.use(require('koa-static')(__dirname + '/public')) // 静态文件

// session配置, 要放在路由注册之前
app.keys = ['chenj666']
app.use(session({
  // 配置cookie
  cookie: {
    path: '/',
    httpOnly: true,
    maxAge: 24 * 60 * 60 * 1000
  },
  // 配置redis
  store: redisStore({
    all: '127.0.0.1:9528'
  })
}))

// 使 koa2 监听 5000 端口号发起的 http 请求
const server = app.listen(5000, function() {
  console.log('ok')
})
----------------------------------------------------------------------------------------------
// 路由演示, 有两个文件, 实际匹配的路由是 /blog/get
// app文件
const blogRouter = require('./routes/blog')
const Koa = require('koa')
const app = new Koa()

 // 引入路由，allowedMethods 表示只支持路由中定义的方法进行访问，即 get 方法不能用 post 访问
app.use(blogRouter.routes(), blogRouter.allowedMethods())

// 路由blog文件
const router = require('koa-router')() // 默认koa2不支持router, 需要引入koa-router
router.prefix('/blog')
router.get('/get', async (ctx, next) => {
  const path = ctx.params // 获取url上的参数
  const query = ctx.request.query // 获取查询参数?后面的
  const headers = ctx.request.header // 获取请求头的内容
  const body = ctx.request.body // 获取http请求的body内容
  ctx.body = { // ctx.body相当于express的res.json
    path,
    query,
    headers,
    body,
    code: 0
  }
})
module.exports = router
----------------------------------------------------------------------------------------------
// ejs 模板
1. <% '脚本' 标签，用于流程控制，无输出
2. <%_ 删除其前面的空格符
3. <%= 输出数据到模板（输出是转义 HTML 标签）
4. <%- 输出非转义的数据到模板
5. <%# 注释标签，不执行、不输出内容
6. <%% 输出字符串 '<%'
7. %> 一般结束标签
8. -%> 删除紧随其后的换行符
9. _%> 将结束标签后面的空格符删除
10. 示例
<!DOCTYPE html>
<html>
  <head>
  <title><%= title %><title>
  </head>
  <body>
    // title 是变量
    <h1><%= title %></h1>

    // 不确定 title 一定存在时前面可以加 locals，否则会报错
    <p><%= locals.title %></p>

    // 条件语句，注意括号要分开
    <div>
      <% if(isFlag) { %>
        <h1>flag 是 true</h1>
      <% } else { %>
        <h1>flag 是 false</h1>
      <% } %>
    </div>

    // 循环
    // list: [{ id: 1, name: 'chen' }, { id: 2, name: 'jie' }]
    <ul>
      <% list.forEach(item => { %>
        <li data-id="<%= item.id %">
          <%= item.name %>
        </li>
      <% }) %>
    </ul>

    // 组件引入，'widget/user-info' 是路径，name 是变量
    <%- include('widget/user-info', { name }) %>

    <script>
      console.log('在 ejs 中可以写 script')
    </script>
  </body>
</html>

// widget/user-info 组件，和正常的模板一样
<div>
  <h1><%= name %></h1>
</div>

Node 连接数据库

// node连接mysql,属于硬盘数据库
// 下载链接 https://dev.mysql.com/downloads/mysql
1. npm install mysql // 安装，现在使用 mysql2 比较多
2. const mysql = require('mysql') // 引入
3. const con = mysql.createConnection({ // 创建连接对象
      host: 'localhost',
      user: 'root',
      password: '123456',
      port: '3306',
      database: '库名'
   })
4. con.connect() // 开始连接
5. con.query(sql语句, (err, data) => { code }) // 执行sql语句
6. con.end() // 关闭连接，线上不需要关闭，这边只是演示
7. 如果是插入语句,会返回一个obj对象,其中可以判断insertId插入的id,从而知道是否执行成功
8. 如果是更新和删除语句,会返回一个obj对象,其中可以判断affectedRows影响了几行,从而知道是否执行成功
----------------------------------------------------------------------------------------------
// node连接redis，属于内存数据库
// 2.x 版本
1. 在命令行执行 redis-server 启动redis
2. npm install redis
3. const redis = require('redis')
4. const c = redis.createClient(6379, '127.0.0.1')
5. c.on('error', err => { code })
6. c.set('name', 'cj', redis.print) // 第三个参数是插入name=cj成功后在控制台打印ok
7. c.get('name', (err, data) => { code }) // 获取name
8. c.quit() // 退出
9. 把session存储在redis中就可以避免session过大会把node服务进程内存挤爆, 而且在做集群时,启用多个node服务即多个进程,无法共享数据
// 4.x 版本
const redis = require('redis');

(async function () {
    const c = redis.createClient(6379, '127.0.0.1')

    try {
        // 连接
        await c.connect()
        console.log('redis connect success')
    } catch (err) {
        console.log(err)
    }

    // 设置
    await c.set('name', 'chenj')

    // 获取
    const name = await c.get('name')
    console.log('name', name)

    // 退出
    c.quit()
})()


----------------------------------------------------------------------------------------------
// node 连接 mongodb
const MongoClient = require('mongodb').MongoClient // npm install mongodb
const url = 'mongodb://localhost:27017' // 地址
const dbName = 'myblog' // 库名

MongoClient.connect(
    url,
    {
        useUnifiedTopology: true
    },
    (err, client) => {
        if (err) {
            console.error('mongodb connect error', err)
            return
        }

        // 没有报错，说明连接成功
        console.log('mongodb connect success')

        // 切换到数据库（控制台 `use myblog`）
        const db = client.db(dbName)

        // 使用集合
        const usersCollection = db.collection('users') // users 即集合名称

        // 新增
        usersCollection.insertOne({
            username: 'chenj',
            password: 'abc',
            realname: '一条牛'
        }, (err, result) => {
            if (err) {
                console.error('users insert error', err)
                return
            }
            console.log(result)

            // 关闭连接，线上不需要关闭，这边只是演示
            client.close()
        })

        // 修改
        usersCollection.updateOne(
            { username: 'zhangsan' }, // 查询条件
            { $set: { realname: '张三A' } }, // 修改的内容，注意有 $set
            (err, result) => {
                if (err) {
                    console.error('users update error', err)
                    return
                }
                console.log(result)

                // 关闭连接，线上不需要关闭，这边只是演示
                client.close()
            }
        )

        // 删除
        usersCollection.deleteOne(
            { a: 101 },
            (err, result) => {
                if (err) {
                    console.error('users delete error', err)
                    return
                }
                console.log(result)

                // 关闭连接，线上不需要关闭，这边只是演示
                client.close()
            }
        )

        // 查询
        usersCollection.find({
            username: 'zhangsan',
            password: '123'
        }).toArray((err, result) => {
            if (err) {
                console.error('users find error', err)
                return
            }
            console.log(result)

            // 关闭连接，线上不需要关闭，这边只是演示
            client.close()
        })
    }
)
----------------------------------------------------------------------------------------------
// node 连接 mongoose
1. Schema 定义数据格式的规范
2. Model 规范 Collection
3. 规范数据操作的 API
4. mongoose 连接 mongodb
// db.js
const mongoose = require('mongoose')
const url = 'mongodb://localhost:27017'
const dbName = 'myblog'

mongoose.set('useFindAndModify', false)

mongoose.connect(`${url}/${dbName}`, {
    useNewUrlParser: true,
    useUnifiedTopology: true
})

const db = mongoose.connection

// 发生错误
db.on('error', err => {
    console.error(err)
})

// 连接成功
db.once('open', () => {
    console.log('mongoose connect success…')
})

module.exports = mongoose

5. model 和 Schema
// blog.js 即 connection
// 对应 blog 集合
const mongoose = require('../db')

// 规范
const BlogSchema = mongoose.Schema({
    title: {
        type: String,
        required: true // 必需
    },
    content: String,
    author: {
        type: String,
        required: true
    }
}, { timestamps: true }) // 会自动加时间戳

const Blog = mongoose.model('blog', BlogSchema) // blog 对应 blogs 集合

module.exports = Blog

6. mongoose 操作 mongodb
const Blog = require('../models/Blog')

!(async () => {

    // 新建博客
    const blog1 = await Blog.create({
        title: '标题3',
        content: '内容3',
        author: 'shuangyue'
    })
    console.log(blog1)

    // 获取列表
    const list = await Blog.find({
        // author: 'zhangsan'
        title: /A/ // 正则表达式，模糊查询
    }).sort({ _id: -1 })
    console.log(list)

    // 根据 id 获取单个博客
    const blog3 = await Blog.findById('5f4cc1824e9b73583b69b404')
    console.log(blog3)

    // 修改博客
    const res = await Blog.findOneAndUpdate(
        { _id: '5f4cc1824e9b73583b69b404' }, // 条件
        { content: '内容3内容3内容3' },
        {
            new: true // 返回修改之后的最新的内容，默认为 false
        }
    )
    console.log(res)

    // 删除
    const res = await Blog.findOneAndDelete({
        _id: '5f4cc1824e9b73583b69b404',
        author: 'shuangyue' // 验证一下作者，增加安全性，防止误删
    })
    console.log(res)
})()
----------------------------------------------------------------------------------------------
// sequelize
1. ORM // Object Relational Mapping 即对象关系映射
  1. 数据表，用 js 中的模型（'class' 或对象）代替
  2. 一条或多条记录，用 js 中一个对象或数组代替
  3. sql 语句，用对象方法代替
2. 建模（外键）同步到数据库 // 相当于建表建字段等
3. 增删改查、连表查询 // 使用 sequelize API 而不用 sql
4. 连接测试
const Sequelize = require('sequelize') // npm
const config = {
  host: 'localhost',
  dialect: 'mysql' // 类型，mysql
}
// 线上环境使用连接池，如果没有位置，则用户会进行等待
// 如果不用连接池，每来一个用户就会创建一个连接，资源消耗很大
config.pool = {
  max: 5, // 连接池中最大的连接数量
  min: 0, // 连接池中最小的连接数量
  idle: 10 * 1000 // 如果一个连接池 10s 之内没有被使用，则释放
}
const seq = new Sequelize('库名', 'root', '123456', config)
seq.authenticate().then(() => {
  console.log('成功')
}).catch(() => {
  console.log('失败')
})
module.exports = seq
5. 创建模型
const Sequelize = require('sequelize') // npm
const seq = require('./连接测试') // 第 4 点的代码
// 创建 user 模型，数据表的名字是 users（英文复数）
const User = req.define('user', {
  // id 会自动创建，并设为主键自增
  // createdAt（创建时间） 和 updatedAt（更新时间） 也会自动创建
  userName: {
    type: Sequelize.STRING, // 相当于 varchar(255)
    allowNull: false // 不能为空
  }
  password: {
    type: Sequelize.STRING, // 相当于 varchar(255)
    allowNull: false // 不能为空
  },
  nickName: {
    type: Sequelize.STRING, // 相当于 varchar(255)
    comment: '昵称' // 这是注释
  }
})
// 创建 blog 模型，数据表的名字是 blogs
const Blog = req.define('blog', {
  // id 会自动创建，并设为主键自增
  // createdAt 和 updatedAt 也会自动创建
  title: {
    type: Sequelize.STRING, // 相当于 varchar(255)
    allowNull: false // 不能为空
  }
  content: {
    type: Sequelize.TEXT, // 比 varchar(255) 长
    allowNull: false // 不能为空
  },
  userId: {
    type: Sequelize.STRING, // 相当于 varchar(255)
    allowNull: false // 不能为空
  }
})
// 外键关联1（看第 7 点的连表查询）
Blog.belongsTo(User, {
  // 创建外键 Blog.userId -> User.id
  foreignKey: 'userId'
})
// 外键关联2（看第 7 点的连表查询）
User.hasMany(Blog, {
  // 创建外键 Blog.userId -> User.id
  foreignKey: 'userId'
})
// 同步模型到数据库中，只需要执行一遍，这一步可以单独抽离到一个文件中，单独的去执行
seq.sync({ force: true }).then(() => {
    process.exit()
})
module.exports = {
  User,
  Blog
}
6. 插入数据
const { User, Blog } = require('./创建模型') // 第 5 点的代码
!(async function() {
  // 创建用户 相当 insert into users (...) values (...)
  const zhangsan = await User.create({
    userName: 'zhangsan',
    password: '123',
    nickName: '张三'
  })
  console.log('zhangsan:', zhangsan.dataValues)
  const zhangsanId = zhangsan.dataValues.id

  const lisi = await User.create({
    userName: 'lisi',
    password: '123',
    nickName: '李四'
  })
  console.log('lisi:', lisi.dataValues)
  const lisiId = lisi.dataValues.id

  // 创建博客
  const blog1 = await Blog.create({
    title: '标题1',
    content: '内容1',
    userId: zhangsanId
  })
  console.log('blog1', blog1.dataValues)

  const blog2 = await Blog.create({
    title: '标题2',
    content: '内容2',
    userId: lisiId
  })
  console.log('blog2', blog2.dataValues)
})()
7. 查询
const Sequelize = require('sequelize') // npm
const { User, Blog } = require('./创建模型') // 第 5 点的代码
!(async function() {
  // 查询一条记录
  const zhangsan = await User.finOne({
    where: {
      userName: 'zhangsan',
      realName: {
        [Sequelize.Op.like]: '%名称%' // 模糊查询，和 SQL 的 like 一样
      }
    },
    // 排序
    order: [
      ['id', 'desc']
    ]
  })
    // 注意，这里如果是查询不到，则会返回 Null
    if (zhangsan) {
        console.log('zhangsan', zhangsan.dataValues)
    }

  // 查询特定的列
  const zhangsanName = await User.findOne({
    attributes: ['userName', 'nickName'],
    where: {
      userName: 'zhangsan'
    }
  })
  console.log('zhangsanName', zhangsanName.dataValues)

  // 查询一个列表
  const zhangsanBlogList = await Blog.findAll({
    where: {
      userId: 1
    },
    // 排序
    order: [
      ['id', 'desc']
    ]
  })
    // 如果查询不到，则返回 []
  console.log('zhangsanBlogList', zhangsanBlogList.map(item => item.dataValues))

  // 查询总数
  const blogListAndCount = await Blog.findAndCountAll({
    limit: 2, // 限制本次查询 2 条
    offset: 2, // 跳过多少条
    order: [
      ['id', 'desc']
    ]
  })
  console.log('blogListAndCount', blogListAndCount.count, blogListAndCount.rows.map(item => item.dataValues))

  // 连表查询1（对应第 5 点的关联外键 1）
  const blogListWithUser = await Blog.findAndCountAll({
    order: [
      ['id', 'desc']
    ],
    include: [
      {
        model: User,
        attributes: ['userName', 'nickName'],
        where: {
          userName: 'zhangsan'
        }
      }
    ]
  })
  console.log('blogListWithUser', blogListWithUser.count, blogListWithUser.rows.map(item => {
    const blogValue = item.dataValues
    blogValue.user = blogValue.user.dataValues
    return blogValue
  }))

  // 连表查询2（对应第 5 点的关联外键 2）
  const userListWithBlog = await Blog.findAndCountAll({
    attributes: ['userName', 'nickName'],
    include: [
      {
        model: Blog,
      }
    ]
  })
  console.log('userListWithBlog', userListWithBlog.count, userListWithBlog.rows.map(item => {
    const userValue = item.dataValues
    userValue.blogs = userValue.blogs.map(subItem => subItem.dataValues)
    return userValue
  }))

})()
8. 更新
const { User, Blog } = require('./创建模型') // 第 5 点的代码
!(async function() {
  const updateRes = await User.update({
    // 要修改的内容
    nickName: '张三'
  }, {
    // 条件
    where: {
      userName: 'zhangsan'
    }
  })
  console.log('updateRes', updateRes[0] > 0)
})()
9. 删除
const { User, Blog } = require('./创建模型') // 第 5 点的代码
!(async function() {
  // 删除一条博客
  const delBlogRes = await Blog.destroy({
    where: {
      id: 4
    }
  })
  console.log('delBlogRes', delBlogRes > 0)

  // 删除一个用户
  const delUserRes = await User.destroy({
    where: {
      id: 1
    }
  })
  console.log('delUserRes', delUserRes > 0)
})()

面试真题

nodejs 是什么？

1. nodejs 是基于 Chrome V8 引擎的 javascript 运行时
2. nodejs 出现之前，js 只能在浏览器运行
3. nodejs 出现之后，js 可以在任何安装 nodejs 的环境运行

nodejs 和前端 js 的区别是什么？

1. 语法 都是使用 ES 语法 前端 js 使用 web API，如 DOM、BOM 等 nodejs 使用 node API，如 http、querystring 等
2. 应用 前端 js 用于网页，在浏览器运行 nodejs 可用于服务端，如开发 web server nodejs 也可用于本机，如 webpack 等本机的工具

nodejs 如何调试？

1. 启动 nodejs 服务时，使用 inspect，如 node --inspect-brk index.js
2. 代码中使用 debugger 断点
3. 使用 chrome 调试，chrome://inspect

如何获取当前文件和当前目录的路径？

1. __filename
2. __dirname
3. 两个都是全局变量

commonjs 和 ES6 Module 的区别？

1. 语法不同
2. commonjs 是动态引入，执行时引入
3. ES6 Module 是静态引入，编译时引入，需要放在最外层顶部引入，webpack tree shaking 只支持 ES6 Module

path.resolve 和 path.join 的区别？

1. 两者都是用于拼接文件路径
2. path.resolve 获取绝对路径
3. path.join 获取相对路径或拼接路径

event loop 在浏览器和 nodejs 中的区别？

1. 浏览器 js 的异步
   1. 宏任务：setTimeout、setInterval、ajax 等
   2. 微任务：promise、async/await
   3. 微任务比宏任务更早执行
2. 浏览器的 event loop
   1. call stack 空闲时，将触发 event loop 机制，执行宏任务
   2. 而触发 event loop 之前，会把现有的微任务都执行完
   3. 所以微任务比宏任务执行时机更早
3. nodejs 的异步
   1. 宏任务：setTimeout、setInterval、setImmediate、I/O 文件、网络、socket 连接，如连接 mysql
   2. 微任务：promise、async/await、process.nextTick
4. nodejs 的 event loop
   1. 因为 nodejs 中的微任务不多，宏任务类型较多，如果宏任务都放在 callback queue 中就不好管理
   2. nodejs 事件循环的分为 6 个阶段（宏任务）
      1. timer ——> I/O ——> idle，prepare ——> poll ——> check ——> close callback
      2. timer：执行 setTimeout 以及 setInterval 的回调
      3. I/O：callback 处理网络、流、TCP 的错误回调
      4. idle，prepare：闲置阶段，node 内部使用
      5. poll：执行 poll 中的 I/O 队列，检查定时器是否到时间
      6. check：存放 setImmediate 回调
      7. close callback：关闭回调，例如 socket.on('close')
   3. 原则上还是先执行微任务再执行宏任务，而宏任务的执行顺序通过上面的 6 个阶段执行
   4. 微任务中，process.nextTick 优先级最高，最早被执行 （process.nextTick 现已不推荐使用，因为会阻塞 IO）
   5. 细节
      1. setTimeout 比 setImmediate 执行更早
      2. process.nextTick 比 promise.then 执行更早
      3. 建议用 setImmediate 代替 process.nextTick
   6. 区别
      1. nodejs 异步 API 更多，宏任务类型也更多
      2. nodejs 的 event loop 分为 6 个阶段，要按照顺序执行
      3. 微任务中 process.nextTick 优先级更高

session 如何实现登录？

1. cookie 如何实现登录校验
   1. 前端登录成功后，服务端会设置 cookie，当前端进行其他操作时会带上 cookie，服务端进行校验
2. session 和 cookie 的关系
   1. 当在 cookie 中存储敏感信息时会不安全，则换成存储 userId，对应到服务端则是用户信息
3. session 为何需要存储在 redis 中
   1. 进程有内存限制
   2. 进程的内存是相互隔离的
   3. 存储到 redis 中，可解决这些问题

描述 koa2 和 express 的中间件机制？

1. 从代码来看，中间件就是一个函数
2. 从业务来看，中间件则是一个独立的模块
3. 模块拆分，模块流转，即可完成复杂的功能

nodejs 如何读取大文件？

1. stream —— 流
2. 1G 大小的 access.log
3. 分析其中的 Chrome 浏览器占比
4. 考虑 cpu 和内存的限制

nodejs 线上为何开启多进程？（pm2）

1. 高效使用多核 CPU
2. 充分利用服务器内存
3. 最终：压榨服务器，不浪费资源