logo
node
发表于：2022-03-15 | 更新于：2023-01-13 | 分类： node

node

require // 引入
module.exprots // 导出

框架

koa2

官网：https://www.koajs.com.cn/

// 优点
1.koa利用async，await的新语法特性解决回调地狱的问题
2.koa是洋葱中间件模式，执行到next的时候，会去调下个中间件，
下个中间件执行完再接着执行上个中间件的next下面的代码
3.koa把request，response封装到了同一个上下文对象 contenet
4.koa2中间件都是异步函数

// koa是洋葱中间件模式，执行到next的时候，会去调下个中间件，
// 下个中间件执行完再接着执行上个中间件的next下面的代码
// ctx:上下文；next:下一个
app.use(async (ctx, next) => {
  console.log(1)
  await next()
  console.log(2)
})
app.use(async (ctx, next) => {
  console.log(3)
  await next()
  console.log(4)
})
console.log('打印') // 1342

// 请求
ctx.body                // 返回给前端的数据
ctx.query               // 获取前端传的数据(对象)
ctx.request.query       // 获取前端传的数据(对象)
ctx.querystring         // 获取前端传的数据(字符串)
ctx.request.querystring // 获取前端传的数据(字符串)

依赖下载

// 新建node.js,生成package.json文件
npm init -y
npm i koa --save
// 挂载
const Koa = require('koa');
const app = new Koa;
// 3000 端口号
app.listen(3000)
console.log('http://localhost:3000');

启动项目

npm i nodemon --save
// node.js 文件名
nodemon node.js
npm run test

路由

// 路由下载
npm i koa-router --save
// 挂载
const router = require('koa-router')()
app.use(router.routes())
app.use(router.allowedMethods())

前端格式

// 返回前端格式
npm i koa-json --save
npm i koa-bodyparser --save
// 挂载
const json = require('koa-json')()
const bodyparser = require('koa-bodyparser')
app.use(json())
app.use(bodyparser())

连接 mysql 数据库

// 依赖
npm i mysql --save
// 挂载
const mysql = require('mysql')
// 连接mysql数据库
var coonnection = mysql.createConnection({
  host: 'localhost', // 端口号
  user: 'root', // 账户
  password: '253547', // 密码
  database: 'node' // 表名
})
coonnection.connect(function (err) {
  if (err) {
    console.log('连接失败' + err.stack)
    return
  }
  console.log('连接成功' + coonnection.threadId)
})
封装连接池
// 新建models/mysql.js
const mysql = require('mysql')

// 创建数据库连接池
const pool = mysql.createPool({
  host: 'localhost', // 端口号
  user: 'root', // 账户
  password: '253547', // 密码
  database: 'node' // 表名
})

// 封装异步操作
let query = function (sql, values) {
  return new Promise((resolve, reject) => {
    pool.getConnection(function (err, connection) {
      if (err) {
        reject(err)
      } else {
        connection.query(sql, values, (err, rows) => {
          if (err) {
            reject(err)
          } else {
            resolve(rows)
          }
          connection.release()
        })
      }
    })
  })
}

module.exports = { query }
增删改查
// 新建router/index.js
const { query } = require('../models/mySql') //引入mySql
const router = require('koa-router')() //路由

// 增 INSERT into 表名 (字段名列表(逗号隔开)) values(值列表(逗号隔开));
router.post('/increase', async (ctx, next) => {
  let { username, password } = ctx.request.body
  // 新增sql
  let sql = 'INSERT into `user` (id,username,password) value(null,?,?);'
  let params = [username, password]
  let listdata = await query(sql, params)
  // 返回
  if (listdata.length === 0) {
    ctx.body = {
      code: 400,
      message: '增加失败'
    }
  } else {
    ctx.body = {
      code: 200,
      message: 'success'
    }
  }
})

// 删 DELETE FROM 表名 WHERE 删除条件;
router.post('/delete', async (ctx, next) => {
  let { username, password } = ctx.request.body
  // 删除sql
  let sql = 'DELETE FROM user WHERE username=?'
  let params = [username]
  let listdata = await query(sql, params)
  // 返回
  if (listdata.length === 0) {
    ctx.body = {
      code: 400,
      message: '删除失败'
    }
  } else {
    ctx.body = {
      code: 200,
      message: 'success'
    }
  }
})

// 改 UPDATE 表名 SET 字段1=表达式1,字段2=表达式2 WHERE 修改条件;
router.post('/change', async (ctx, next) => {
  let { username, password, id } = ctx.request.body
  // 删除sql
  let sql = 'UPDATE user SET username = ?,password = ? WHERE id = ?'
  let params = [username, password, id]
  let listdata = await query(sql, params)
  // 返回
  if (listdata.length === 0) {
    ctx.body = {
      code: 400,
      message: '更新用户失败'
    }
  } else {
    ctx.body = {
      code: 200,
      message: '成功'
    }
  }
})

// 查 `SELECT * FROM 表名 WHERE 字段 = '${参数}'`
router.post('/login', async (ctx, next) => {
  let { username, password } = ctx.request.body
  // 查询集合
  let sql = `SELECT * FROM user WHERE username = '${username}'`
  let listdata = await query(sql)
  // 返回
  if (listdata.length === 0) {
    ctx.body = {
      code: 400,
      message: '失败'
    }
  } else {
    ctx.body = {
      code: 200,
      message: '成功'
    }
  }
})
module.exports = router
node.js
// 挂载
const Koa = require('koa')
const app = new Koa()

// 挂载
const router = require('koa-router')()
const bodyparser = require('koa-bodyparser')
app.use(router.routes())
app.use(router.allowedMethods())
app.use(bodyparser())

// 挂载
const json = require('koa-json')
app.use(json())

//引入路由文件
const banner = require('./router/index')

//注册路由中间件
app.use(banner.routes(), banner.allowedMethods())

// 挂载
const mysql = require('mysql')

var coonnection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '253547',
  database: 'node'
})

coonnection.connect(function (err) {
  if (err) {
    console.log('连接失败' + err.stack)
    return
  }
  console.log('连接成功' + coonnection.threadId)
})

// 3000 端口号
app.listen(3000)
console.log('http://localhost:3000/')

连接 mongodb 数据库

// 依赖
npm i mongoose --save
// 挂载
const mongoose = require('mongoose')
// 连接阿里云数据库
mongoose
  .connect('公网地址(****为数据库密码)', {
    useNewUrlParser: true,
    useUnfindTopology: true,
    authSource: 'admin'
  })
  .then(res => {
    console.log('连接成功')
  })
  .catch(err => {
    console.log('连接失败')
  })
设计数据库字段
// 新建文件夹models/username.js
const mongoose = require('mongoose')
const Schemas = mongoose.Schema

const NameSchema = new Schemas({
  //注册对象模型 type：数据类型；require：必填
  name: {
    type: String,
    require: true
  },
  password: {
    type: String,
    require: true
  },
  openid: {
    type: String,
    require: true
  }
})

module.exports = Username = mongoose.model('usernamedata', NameSchema)
抒写路由
// 新建文件夹router/backend/optimiz.js
const username = require('../../models/username')
const { log } = console
//路由
const router = require('koa-router')()

//注册模型
const Username = require('../../models/username.js')

// 注册的路由
router.post('/register', async (ctx, next) => {
  await next()
  log('注册')
  log(ctx.request.body)
  ctx.body = {
    code: 200,
    msg: '成功'
  }
})

module.exports = router.routes()
增删改查
// name, password, openid需与模型定义字段一致
router.post('/register', async (ctx, next) => {
  await next()
  // 增 <Schema模型>.create(object)
  let { name, password, openid } = ctx.request.body
  const user = new Username({
    name: name,
    password: password,
    openid: openid
  })
  try {
    let result = await Username.create(user)
    ctx.body = {
      code: 200,
      msg: '添加新用户成功'
    }
  } catch (error) {
    ctx.body = {
      code: 400,
      msg: '添加新用户失败'
    }
  }
  // 删 <Schema模型>.deleteOne(object)
  let _id = ctx.request.body.openid
  try {
    let result = await Username.deleteOne({ openid: _id })
    ctx.body = {
      code: 200,
      msg: '删除用户成功'
    }
  } catch (error) {
    ctx.body = {
      code: 400,
      msg: '操作失败'
    }
  }
  // 改 <Schema模型>.updateOne(<filter筛选条件>,object)
  let openid = ctx.request.body.openid
  const user = {
    name: ctx.request.body.name,
    password: ctx.request.body.password
  }
  try {
    let result = await Username.updateOne({ openid: openid }, user)
    ctx.body = {
      code: 200,
      msg: '更新用户成功'
    }
  } catch (error) {
    ctx.body = {
      code: 400,
      msg: '更新用户失败'
    }
  }
  // 查 <Schema模型>.find(object) / <Schema模型>.findOne(object)
  try {
    let result = await Username.find({})
    ctx.body = {
      code: 200,
      data: result,
      msg: '获取用户信息成功'
    }
  } catch (error) {
    ctx.body = {
      code: 400,
      msg: '操作失败'
    }
  }
})

koa2 报错总结

save()，create() 报错 not authorized on admin to execute command

// 需要在dms里新建一个数据库，把代码里那个链接地址上的admin换成你新建数据库的命名
// 3717后面admin换成新建的数据库名即可
mongoose
  .connect(
    'mongodb://root:****@dds-uf63bbe5340f51641573-pub.mongodb.rds.aliyuncs.com:3717,dds-uf63bbe5340f51642116-pub.mongodb.rds.aliyuncs.com:3717/node?replicaSet=mgset-63496652',
    {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      authSource: 'admin'
    }
  )
  .then(res => {
    console.log('连接成功')
  })
  .catch(err => {
    console.log('连接失败')
  })

express

官网：https://www.expressjs.com.cn/

NestUS

官网：https://nestjs.bootcss.com/first-steps

下载依赖

npm i -g @nestjs/cli

创建项目

nest new project-name

启动项目

npm run start

项目地址：http://localhost:3000

NestUS 写接口

创建接口名 user

nest g resource user

创建 get,post 请求

返回参数

快捷键

技巧

拼接字符串

let qs = require('querystring')
const params = qs.stringify({
  name: '111',
  age: '18'
})
let url = 'https://api/sass?' + params
console.log(url) // https://api/sass?&name=111&age=18

读取/写入

// utf8/string() 转译
const fs = require('fs')
const path = require('path')
const paturl = path.resolve(__dirname, '文件路径')
// 异步读取
fs.readFile(paturl, 'utf8', (err, data) => {
  if (err) throw err
  console.log(data)
})
// 同步读取
let data = fs.readFileSync(paturl)
console.log(data.string())
// 异步写入
fs.writeFile(paturl, '内容', (err, data) => {
  if (err) throw err
  console.log(data)
})
// 同步写入
let data = fs.writeFileSync(paturl, '内容')
console.log(data.string())
node
上一篇:
插件
下一篇:
防抖和节流
本文目录
本文目录
    •

    Copyright © 2020 - 2022 wly | Powered by Hexo