express的使用

妹妹是娜娜莉
189 阅读5分钟

安装

// express安装
$ npm install express
//nodemon可以监听js文件的变化,变化时重新node 文件.js
$ npm install nodemon -g

起步

// 引入express
var express = require('express')
// 用app接收创建的express实例
var app = express()
// app.listen('端口号',回调函数);
app.listen(8080,()=>{
    console.log('我监听了8080')
    console.log('http://127.0.0.1:8080')
})

// app.METHOD(PATH,HANDLER)
// app是一个express实例
// METHOD是个小写的HTTP请求方法。
// PATH是服务器上的路径。
// HANDLER是匹配路线知时执行的功能。
app.get('/',(req,res)=>{
    res.send('给客户端返回的内容');
})
app.post('/',(req,res)=>{
    res.send('给客户端返回的内容');
})

req对象

request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP 头部等属性

  • req.query 查询参数
//访问 http://127.0.0.1:8080?name=kawaii&age=20
app.get('/',(req,res)=>{
    res.send(req.query)
})
//返回JSON对象
{
    "name": "kawaii",
    "age": "20"
}
  • req.params获取路由的parameters
//访问 http://127.0.0.1:8080/html/kawaii
app.get('/html/:name',(req,res)=>{
    res.send(req.params)
})
//返回JSON对象
{
    "name": "kawaii"
}
// 不能这样访问 http://127.0.0.1:8080/html/kawaii/keai

res对象

response 对象表示 HTTP 响应，即在接收到请求时向客户端发送的 HTTP 响应数据

  • res.send() 传送HTTP响应
// 访问http://127.0.0.1:8080
app.get('/',(req,res)=>{
    res.send('给客户端返回的内容');
})
app.post('/',(req,res)=>{
    res.send('给客户端返回的内容');
})

托管静态资源

  • 托管静态资源例子
//express.static默认从node_modules同目录查找

const express = require('express')
const app = express()
// 使用与main.js同目录下的public目录,也必须和module同目录
app.use(express.static('public'))
    // 访问 http://127.0.0.1:8080/image/tx.jpg
    // 访问 http://127.0.0.1:8080/css/test.css
// 目录结构
|-node_modules
|-public
|-main.js
---------------------------------------------
const express = require('express')
//引入path模块
const path = require('path')
const app = express()
//使用绝对路径
app.use(express.static(path.resolve(__dirname,'public'));
//使用常规目录
app.use(express.static('express/public'))
    // 访问 http://127.0.0.1:8080/image/tx.jpg
    // 访问 http://127.0.0.1:8080/css/test.css
//目录结构
|-node_modules
|-express
|-|-public
|-|-|-image
|-|-|-css
|-|-main.js
  • 挂载路径前缀例子
const express = require('express')
const app = express()
//挂载路径前缀
app.use('/kawaii',express.static('express/public'))
// 访问 http://127.0.0.1:8080/kawaii/image/tx.jpg

路由

路由简单使用

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

app.get('/',(req,res)=>{
    res.send('hello get')
})
app.post('/',(req,res)=>{
    res.send('hello post')
})

app.listen(8080,()=>{
    console.log('我监听了8080 http://127.0.0.1:8080')
})

路由模块化

为了方便对路由进行模块化的管理，Express 不建议将路由直接挂载到 app 上，而是推荐将路由抽离为单独的模块。将路由抽离为单独模块的步骤如下：

  1. 创建路由模块对应的 .js 文件
  2. 调用 express.Router() 函数创建路由对象
  3. 向路由对象上挂载具体的路由
  4. 使用 module.exports 向外共享路由对象
  5. 使用 app.use() 函数注册路由模块
// router.js
const express = require('express') //引入express
const router = express.Router() // 创建路由对象

router.get('/home',(req,res)=>{
    res.send('hello router get')
})
router.post('/home',(req,res)=>{
    res.send('hello router post')
})

module.exports = router //导出对象
-------------------------------------------
// main.js
const express = require('express')
const app = express()

const myRouter = require('./router') //引入router模块
app.use(myRouter) //注册路由模块

app.listen(8080,()=>{
    console.log('我监听了8080 http://127.0.0.1:8080')
})
    //访问 http://127.0.0.1:8080/home 

目录结构
|-node_modules
|-express
|-|-public
|-|-|-image
|-|-|-css
|-|-main.js
|-|-router.js

路由模块挂载前缀

const myRouter = require('./router') //引入router模块
app.use('/myrouter',myRouter) //注册路由模块并挂载前缀
    // 访问 http://127.0.0.1:8080/myrouter/home

中间件起步

注意事项:

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

简单中间件

// 中间件处理函数
const middleware = function (req,res,next){
    console.log('中间件处理') //处理逻辑
    next() //必须调用next(),传递给下一个中间件或路由
}

全局中间件

//普通
const express = require('express')
const app = express()
const middleware = function (req,res,next){
    console.log('中间件处理') //处理逻辑
    next() //必须调用next(),传递给下一个中间件或路由
}
app.use(middleware)
-----------------------------------------------------
//简化
app.use(function (req,res,next){
    console.log('中间件处理') //处理逻辑
    next() //必须调用next(),传递给下一个中间件或路由
})

//例子
// 按顺序从上往下执行,只要是访问了服务器就会执行全局中间件
const express = require('express')
const app = express()
app.use((req,res,next)=>{
    console.log('我是第一个中间件函数')
    next()
})
app.use((req,res,next)=>{
    console.log('我是第二个中间件函数')
    next()
})
app.get('/',(req,res)=>{
    console.log('我是路由')
    res.send('abc')
})
    // 访问 http://127.0.0.1:8080/
// 输出
// 我是第一个中间件函数
// 我是第二个中间件函数
// 我是路由

局部中间件

const express = require('express')
const app = express()
// 中间件函数定义
const middleware = function (req,res,next){
    console.log('我是中间件')
    next()
}
app.get('/',(req,res)=>{
    console.log('hello /')
})
// 使用局部中间件函数
app.get('/html',middleware,(req,res)=>{
    console.log('hello html')
})
// 访问 '/' 不会触发中间件 middleware
// 访问 '/html' 才会触发中间件 middleware

// 使用多个局部中间件
app.get('/html',middleware1,middleware2,(req,res)=>{
    console.log('hello html')
})
app.get('/html',[middleware1,middleware2],(req,res)=>{
    console.log('hello html')
})

中间件的分类

应用级别中间件

绑定到 app 实例上的中间件

const express = require('express') //引入express
const middleware = function (req,res,next){
    console.log('我是中间件')
    next()
}
app.use(middleware)
app.get('/',middleware,(req,res)=>{
    console.log('hello /')
})

路由级别中间件

绑定到 express.Router() 实例上的中间件

const express = require('express') //引入express
const router = express.Router() // 创建路由对象
const middleware = function (req,res,next){
    console.log('我是中间件')
    next()
}
router.use(middleware)
router.get('/home',middleware,(req,res)=>{
    res.send('hello router get')
})

错误级别中间件

专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题,错误级别的中间件,必须注册在所有路由之后

app.get('/',(req,res)=>{
    throw new Error('不能访问'); // 抛出后,直接到错误中间件
    res.send('hello /'); // 访问不到
})
app.use((err,req,res,next)=>{
    console.log('发生了错误'+err.message); //打印错误信息
    res.send(err.message) //向客户端发生错误信息
})

内置中间件

  • express.static 快速托管静态资源的内置中间件
  • express.json 解析 JSON 格式的请求体数据
  • express.urlencoded 解析 URL-encoded 格式的请求体数据
// express.json中间件使用
const express = require('express')
const app = express()
// 不配置 express.json 中间件,req.body与res.body都为undefined
app.use(express.json())
app.post('/',(req,res)=>{
    console.log(req.body)
    res.send(req.body)
})
// req.body为JSON对象
// 可以接受到number类型

// express.urlencoded中间件使用
const express = require('express')
const app = express()
// 不配置 express.urlencoded 中间件,req.body与res.body都为undefined
app.use(express.urlencoded({extended:false}))
app.post('/',(req,res)=>{
    console.log(req.body)
    res.send(req.body)
})
// req.body为JSON对象
// number类型被转为string类型

第三方中间件

由第三方开发出来的中间件 Express内置的express.urlencoded中间件，就是基于body-parser这个第三方中间件进一步封装出来的。

avatar
文章
阅读
粉丝