【nodejs-03】黑马nodejs学习笔记03-express中间件与跨域

最新推荐文章于 2024-04-11 11:08:29 发布
最新推荐文章于 2024-04-11 11:08:29 发布
阅读量529 收藏 4
点赞数
分类专栏： node.js 文章标签： node.js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liqiannan8023/article/details/128932876
版权

文章目录


接上篇： 【nodejs-02】黑马nodejs学习笔记02-express

3.Express中间件

3.1 中间件的概念

1. 什么是中间件

中间件（Middleware ），特指业务流程的中间处理环节。

2. 现实生活中的例子

在处理污水的时候，一般都要经过三个处理环节，从而保证处理过后的废水，达到排放标准。
处理污水的这三个中间处理环节，就可以叫做中间件

3. Express 中间件的调用流程

当一个请求到达 Express 的服务器之后，可以连续调用多个中间件，从而对这次请求进行预处理.

在这里插入图片描述

4. Express 中间件的格式

Express 的中间件，本质上就是一个 function 处理函数，Express 中间件的格式如下：
注意：中间件函数的形参列表中，必须包含 next 参数。而路由处理函数中只包含 req 和 res。

在这里插入图片描述
5. next 函数的作用
next 函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由。
在这里插入图片描述

3.2 Express 中间件的初体验

1. 定义中间件函数
可以通过如下的方式，定义一个最简单的中间件函数：

//定义一个最简单的中间件
const mw = function (req, res, next) {
  console.log("这是最简单的一个中间件函数");
  // 注意:在当前中间件的业务处理完毕后,必须调用next()函数
  // 表示吧流转关系转交给下一个中间件或者路由
  next()
}

2. 全局生效的中间件
客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。
通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件，示例代码如下：

const mw = function (req, res, next) {
  console.log("这是最简单的一个中间件函数")
  next()
}
//注册全局生效的中间件
app.use(mw)

3. 定义全局中间件的简化形式

//全局生效的中间件
app.use((req,res,next)=>{
	console.log("这是最简单的一个中间件函数")
 	next()
})

4. 中间件的作用

多个中间件之间，共享同一份 req 和 res。基于这样的特性，我们可以在上游的中间件中，统一为 req 或 res 对象添加自定义的属性或方法，供下游的中间件或路由进行使用。
在这里插入图片描述

5. 定义多个全局中间件

可以使用 app.use() 连续定义多个全局中间件。客户端请求到达服务器之后，会按照中间件定义的先后顺序依次进行
调用，示例代码如下：

aa.use((req, res, next)=> {
  console.log("这是第一个中间件");
  next()
})
app.use( (req, res, next) =>{
  console.log("这是第2个中间件");
  next()
})
app.get('/', [mw1, mw2], function (req, res) {
  res.send('home page')
})

6. 局部生效的中间件

不使用 app.use() 定义的中间件，叫做局部生效的中间件，示例代码如下：

// 不使用app.use()定义的中间件叫做局部生效的中间件
const express = require('express')
const app = express()

//定义一个最简单的中间件
const mw = function (req, res, next) {
  //获取到请求到达服务器的时间
  const time = Date.now()
  //为req对象挂载自定义属性,从而把时间共享给后续的所有路由
  req.startTime = time
  next()
}
//只在/中生效的中间件
app.get('/', mw, (req, res) => {
  res.send("home page" + req.startTime)
})

// /user中req.startTime无定义内容
app.get('/user', (req, res) => {
  res.send("User page" + req.startTime)
})
//使用postman进行路由的调用


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

7. 定义多个局部中间件

可以在路由中，通过如下两种等价的方式，使用多个局部中间件：

const express = require('express')
const app = express()
//定义局部中间件
const mw1 = function (req, res, next) {
  console.log("这是第一个中间件");
  next()
}
const mw2 = function (req, res, next) {
  console.log("这是第2个中间件");
  next()
}
app.get('/', [mw1, mw2], function (req, res) {
  res.send('home page')
})
//或者
// app.get('/', mw1, mw2, function (req, res) {
//   res.send('home page')
// })

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

8. 了解中间件的5个使用注意事项

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

3.3 中间件的分类

为了方便大家理解和记忆中间件的使用，Express 官方把常见的中间件用法，分成了 5 大类，分别是：
① 应用级别的中间件
② 路由级别的中间件
③ 错误级别的中间件
④ Express 内置的中间件
⑤ 第三方的中间件
1. 应用级别的中间件
通过 app.use() 或 app.get() 或 app.post() ，绑定到 app 实例上的中间件，叫做应用级别的中间件，代码示例如下：

//应用级别的中间件（全局中间件）
app.use((req,res,next)=>{
	next()
})
//应用级别的中间件（局部中间件）
app.get('/',mw1,(req,res)=>{
	res.send('Home page')
})

2. 路由级别的中间件
绑定到 express.Router() 实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app 实例上，路由级别中间件绑定到 router 实例上，代码示例如下：

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

//路由级别的中间件
router.use((req,res,next)=>{
	console.log('Time:',Date.now())
	next()
})
app.use('/',router)

3. 错误级别的中间件
错误级别中间件的作用：专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。
格式：错误级别中间件的 function 处理函数中，必须有 4 个形参，形参顺序从前到后，分别是 (err, req, res, next)。
注意：错误级别的中间件，必须注册在所有路由之后！

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

app.get('/', function (req, res) {
  //1.1人为的制造错误
  throw new Error('服务器内部发生了错误!')
  res.send('home page')
})
//错误级别中间件,必须注册在所有路由之后
app.use((err, req, res, next) => {
  console.log("发生了错误" + err.message)
  res.send('home page' + err.message)
})



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

4. Express内置的中间件

自 Express 4.16.0 版本开始，Express 内置了 3 个常用的中间件，极大的提高了 Express 项目的开发效率和体验：
① 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}))

5. 第三方的中间件

非 Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。
例如：在 express@4.16.0 之前的版本中，经常使用 body-parser 这个第三方中间件，来解析请求体数据。使用步骤如下：
① 运行 npm install body-parser 安装中间件
② 使用 require 导入中间件
③ 调用 app.use() 注册并使用中间件

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

3.4 自定义中间件

1. 需求描述与实现步骤

自己手动模拟一个类似于 express.urlencoded 这样的中间件，来解析 POST 提交到服务器的表单数据。实现步骤：
① 定义中间件
② 监听 req 的 data 事件
③ 监听 req 的 end 事件
④ 使用 querystring 模块解析请求体数据
⑤ 将解析出来的数据对象挂载为 req.body
⑥ 将自定义中间件封装为模块

2. 定义中间件
使用 app.use() 来定义全局生效的中间件，代码如下：

app.use((req,res,next)=>{
//中间业务逻辑

})

3. 监听 req 的 data 事件
在中间件中，需要监听 req 对象的 data 事件，来获取客户端发送到服务器的数据。
如果数据量比较大，无法一次性发送完毕，则客户端会把数据切割后，分批发送到服务器。所以 data 事件可能会触发多次，每一次触发 data 事件时，获取到数据只是完整数据的一部分，需要手动对接收到的数据进行拼接。

//定义变量，用来存储客户端发送过来的请求数据
let str=''
//监听req对象的data事件（客户端发送过来的请求体数据）
req.on('data',(chunk)=>{
	//拼接请求体数据，隐式转换为字符串
	str+=chunk
})

4. 监听 req 的 end 事件
当请求体数据接收完毕之后，会自动触发 req 的 end 事件。
因此，我们可以在 req 的 end 事件中，拿到并处理完整的请求体数据。示例代码如下：

//监听req对象的end事件（请求发送完毕后自动触发）
 req.on('end', () => {
    next()
    // console.log(body);
  })

})

5. 使用 querystring 模块解析请求体数据
Node.js 内置了一个 querystring 模块，专门用来处理查询字符串。通过这个模块提供的 parse() 函数，可以轻松把
查询字符串，解析成对象的格式。示例代码如下：

//4.1导入queryString模块把字符串解析成对象格式
const qs = require("querystring")
//4. Node.js 内置了一个 querystring 模块，专门用来处理查询字符串。通过这个模块提供的 parse() 函数，可以轻松把查询字符串，解析成对象的格式。
    const body = qs.parse(str)//调用qs.parse()方法,把查询的字符串解析为对象

6. 将解析出来的数据对象挂载为 req.body
上游的中间件和下游的中间件及路由之间，共享同一份 req 和 res。因此，我们可以将解析出来的数据，挂载为 req 的自定义属性，命名为 req.body，供下游使用。示例代码如下：

req.on('end', () => {
    const body = qs.parse(str)//调用qs.parse()方法,把查询的字符串解析为对象
    req.body = body //将解析出来的请求体对象,挂载为req.body属性,供上游和写有的中间件及路由间使用,共享同一份req和res
    next()
  })

})

7. 将自定义中间件封装为模块
为了优化代码的结构，我们可以把自定义的中间件函数，封装为独立的模块，示例代码如下：

// custom-body-parser.js 模块中的代码
 const qs = require( 'querystring')
3function bodyParser(req，res，next)  /* 省略其它代码 */ }4 module.exports = bodyParser // 向外导出解析请求体数据的中间件函数
 //分割线--
 // 1，导入自定义的中间件模块
const myBodyParser = require( 'custom-body-parser')
 // 2.注册自定义的中间件模块
 app.use(myBodyParser)

完整示例代码：

// 自己手动模拟一个类似于 express.urlencoded 这样的中间件，来解析 POST 提交到服务器的表单数据。
// 实现步骤：
// ① 定义中间件
// ② 监听 req 的 data 事件
// ③ 监听 req 的 end 事件
// ④ 使用 querystring 模块解析请求体数据
// ⑤ 将解析出来的数据对象挂载为 req.body
// ⑥ 将自定义中间件封装为模块
const express = require('express')
const app = express()
//4.1导入queryString模块把字符串解析成对象格式
const qs = require("querystring")

//解析表单数据的中间件
app.use((req, res, next) => {
  // 定义中间件具体的业务逻辑
  // 需要监听 req 对象的 data 事件，来获取客户端发送到服务器的数据。
  // 如果数据量比较大，无法一次性发送完毕，则客户端会把数据切割后，分批发送到服务器。所以 data 事件可能会触发多次，每一次触发 data 事件时，获取到数据只是完整数据的一部分，需要手动对接收到的数据进行拼接。
  //1.定义一个str字符串,专门存放客户端发送过来的请求体数据
  let str = ""
  //2.监听req的data事件
  req.on('data', (chunk) => {
    str += chunk
  })


  //3.当请求体数据接收完毕之后,就会自动触发req的end事件
  req.on('end', () => {
    //str中存放的是完整的请求体数据
    // console.log(str);
    // TODO:把字符串格式的请求体数据解析成对象格式
    //4. Node.js 内置了一个 querystring 模块，专门用来处理查询字符串。通过这个模块提供的 parse() 函数，可以轻松把查询字符串，解析成对象的格式。
    const body = qs.parse(str)//调用qs.parse()方法,把查询的字符串解析为对象
    req.body = body //将解析出来的请求体对象,挂载为req.body属性,供上游和写有的中间件及路由间使用,共享同一份req和res
    next()
    // console.log(body);
  })

})
app.post('/user', (req, res) => {
  // res.send("ok")
  res.send(req.body)
})


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

模块化拆分

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


//1.导入自己封装的中间件模块
const customBodyParser = require('./14.custom-body-parser')

//2.将自定义的中间件函数组测为全局可用的中间件
app.use(customBodyParser)

app.post('/user', (req, res) => {
  // res.send("ok")
  res.send(req.body)
})


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

4.使用Express写接口

4.1 创建基本的服务器

// 导入 express 模块
 const express = require( 'express')
// 创建 express 的服务器实例
 const app = express( )
// write your code here...
 // 调用 app.listen 方法，指定端口号并启动web服务器
 app.listen(80, function () {
10console.log('Express server running at http://127.0.0.1')
})

4.2 创建 API 路由模块

 // apiRouter.js[路由模块)
 const express = require( 'express')
 const apiRouter = express.Router()
 // bind your router here...
 module.exports = apiRouter

// app.js [导入并注册路由模块]
 const apiRouter = require('./apiRouter.js' )
 app.use('/api',apiRouter)

4.3 编写 GET 接口

apiRouter.get('/get' ,(req, res) => (
// 1.获取到客户端通过查询字符串，发送到服务器的数据
const query = req.query
// 2.调用 res.send() 方法，把数据响应给客户端
res.send((
	status: 0,
	//状态，0 表示成功，1 表示失败
	msg:'GET请求成功!',// 状态描述
	data: query
	//需要响应给客户端的具体数据
})

4.4 编写 POST 接口

apiRouter.post('/post',(req, res) => (
// 1.获取到客户端通过查询字符串，发送到服务器的数据
const query = req.body
// 2.调用 res.send() 方法，把数据响应给客户端
res.send((
	status: 0,
	//状态，0 表示成功，1 表示失败
	msg:'POST请求成功!',// 状态描述
	data: body
	//需要响应给客户端的具体数据
})

注意：如果要获取 URL-encoded 格式的请求体数据，必须配置中间件 app.use(express.urlencoded({ extended: false }))

4.5 CORS 跨域资源共享

1. 接口的跨域问题

刚才编写的 GET 和 POST接口，存在一个很严重的问题：不支持跨域请求。
解决接口跨域问题的方案主要有两种：
① CORS（主流的解决方案， 推荐使用）
② JSONP（有缺陷的解决方案：只支持 GET 请求）

2. 使用 cors 中间件解决跨域问题

cors 是 Express 的一个第三方中间件。通过安装和配置 cors 中间件，可以很方便地解决跨域问题。
使用步骤分为如下 3 步：
① 运行 npm install cors 安装中间件
② 使用 const cors = require(‘cors’) 导入中间件
③ 在路由之前调用 app.use(cors()) 配置中间件

3. 什么是 CORS
CORS （Cross-Origin Resource Sharing，跨域资源共享）由一系列 HTTP 响应头组成，这些 HTTP 响应头决定浏览器是否阻止前端 JS 代码跨域获取资源。
浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如果接口服务器配置了 CORS 相关的 HTTP 响应头，就可以解除浏览器端的跨域访问限制。
在这里插入图片描述
4. CORS 的注意事项

① CORS 主要在服务器端进行配置。客户端浏览器无须做任何额外的配置，即可请求开启了 CORS 的接口。
② CORS 在浏览器中有兼容性。只有支持 XMLHttpRequest Level2 的浏览器，才能正常访问开启了 CORS 的服务端接口（例如：IE10+、Chrome4+、FireFox3.5+）。

5. CORS 响应头部 - Access-Control-Allow-Origin
如果指定了 Access-Control-Allow-Origin 字段的值为通配符 *，表示允许来自任何域的请求，示例代码如下：

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

6. CORS 响应头部 - Access-Control-Allow-Headers
默认情况下，CORS 仅支持客户端向服务器发送如下的 9 个请求头：
Accept、Accept-Language、Content-Language、DPR、Downlink、Save-Data、Viewport-Width、Width 、Content-Type （值仅限于 text/plain、multipart/form-data、application/x-www-form-urlencoded 三者之一）
如果客户端向服务器发送了额外的请求头信息，则需要在服务器端，通过 Access-Control-Allow-Headers 对额外的请求头进行声明，否则这次请求会失败！

// 允许客户端额外向服务器发送 Content-Type 请求头和 X-Custom-Header 请求头
// 注意: 多个请求头之间使用英文的逗号进行分割
res.setHeader('Access-Control-Allow-Headers ''Content-Type X-Custom-Header')

7. CORS 响应头部 - Access-Control-Allow-Methods
默认情况下，CORS 仅支持客户端发起 GET、POST、HEAD 请求。
如果客户端希望通过 PUT、DELETE 等方式请求服务器的资源，则需要在服务器端，通过 Access-Control-Alow-Methods来指明实际请求所允许使用的 HTTP 方法。示例代码如下:

// 只允许 POST、GET、DELETE、HEAD 请求方法
res,setHeader('Access-Control-A1low-Methods','POST，GET，DELETE，HEAD')
 // 允许所有的 HTTP 请求方法
 res,setHeader('Access-Control-A1low-Methods','*')

8. CORS请求的分类
客户端在请求 CORS 接口时，根据 请求方式和请求头的不同，可以将 CORS 的请求分为两大类，分别是：
① 简单请求
② 预检请求

9. 简单请求
同时满足以下两大条件的请求，就属于简单请求：
① 请求方式：GET、POST、HEAD 三者之一
② HTTP 头部信息不超过以下几种字段：无自定义头部字段、Accept、Accept-Language、Content-Language、DPR、Downlink、Save-Data、Viewport-Width、Width 、Content-Type（只有三个值application/x-www-form-urlencoded、multipart/form-data、text/plain）

10. 预检请求

只要符合以下任何一个条件的请求，都需要进行预检请求：
① 请求方式为 GET、POST、HEAD 之外的请求 Method 类型
② 请求头中包含自定义头部字段
③ 向服务器发送了 application/json 格式的数据

在浏览器与服务器正式通信之前，浏览器会先发送 OPTION 请求进行预检，以获知服务器是否允许该实际请求，所以这一次的 OPTION 请求称为“预检请求”。服务器成功响应预检请求后，才会发送真正的请求，并且携带真实数据。

11. 简单请求和预检请求的区别

简单请求的特点：客户端与服务器之间只会发生一次请求。
预检请求的特点：客户端与服务器之间会发生两次请求，OPTION 预检请求成功之后，才会发起真正的请求。

4.6 JSONP 接口

1. 回顾 JSONP 的概念与特点

概念：浏览器端通过 script 标签的 src 属性，请求服务器上的数据，同时，服务器返回一个函数的调用。这种请求数据
的方式叫做 JSONP。
特点：
① JSONP 不属于真正的 Ajax 请求，因为它没有使用 XMLHttpRequest 这个对象。
② JSONP 仅支持 GET 请求，不支持 POST、PUT、DELETE 等请求。

2. 创建 JSONP 接口的注意事项

如果项目中已经配置了 CORS 跨域资源共享，为了防止冲突，必须在配置 CORS 中间件之前声明 JSONP 的接口。否则JSONP 接口会被处理成开启了 CORS 的接口。示例代码如下:

// 优先创建 JSONP 接口[这个接口不会被处理成 CORS 接口]
 app.get('/api/jsonp',(req，res) => ( })
// 再配置 CORS 中间件[后续的所有接口，都会被处理成 CORS 接口]
 app.use(cors())
// 这是一个开启了 CORS 的接口
app.get('/api/get', (req, res) => [ })

3. 实现 JSONP 接口的步骤

① 获取客户端发送过来的回调函数的名字
② 得到要通过 JSONP 形式发送给客户端的数据
③ 根据前两步得到的数据，拼接出一个函数调用的字符串
④ 把上一步拼接得到的字符串，响应给客户端的 script>标签进行解析执行

4. 实现 JSONP 接口的具体代码

app.get('/api/jsonp',(req,res)=>{
	//1.获取客户端发送过来的回调函数的名字
	const funName = req.query.callback
	//2.得到要通过JSON形式发送给客户端的数据
	const data = {name:'zs',age:22}
	//3.根据前两步得到的数据，拼接出一个函数调用的字符串
	const scriptStr= `${funName}(${JSON.stringify(data)})`
	//4.把上一步拼接得到的字符串，响应给客户端的<script>标签进行解析
	res.send(scriptStr)
})

5. 在网页中使用 jQuery 发起 JSONP 请求
调用 $.ajax() 函数，提供 JSONP 的配置选项，从而发起 JSONP 请求，示例代码如下：

$('#btnJSONP').on('click',function(){
	$.ajax({
		method:'GET',
		url:'http://127.0.0.1/api/jsonp',
		dataType:'jsonp',
		success:function(res){
			console.log(res)
		}
	})
})
简单Janeee
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何使用Express写接口，使用express中间件cors解决跨域问题，jsonp解决跨域
weixin_44437816的博客
06-18 287
如何使用Express写接口，使用express中间件cors解决跨域问题，jsonp解决跨域
node.js学习-----express：express路由，中间件，cors跨域
m0_63348818的博客
03-13 570
文章目录ExpressExpress 初体验基本使用托管静态资源Express 路由Express 中间件全局中间件局部中间件中间件分类`CORS` 跨域资源共享`CORS` 中间件解决跨域`CORS`CORS 常见响应头CORS 请求分类简单请求预检请求 Express 官网传送门 基于 Node.js 平台，快速、开放、极简的 Web 开发框架 Express 是用于快速创建服务器的第三方模块。 Express 初体验 基本使用 安装 Express： npm install express 创建服
【Node.js】Express学习笔记（黑马）
最新发布
m0_59778008的博客
04-11 1437
什么是 Express？官方给出的概念：Express 是基于 Node.js 平台，快速、开放、极简的 Web 开发框架。通俗的理解：Express 的作用和 Node.js 内置的 http 模块类似，是专门用来创建 Web 服务器的。Express 的本质：就是一个 npm 上的第三方包，提供了快速创建 Web 服务器的便捷方法。Express 的中文官网进一步理解 Express：思考：不使用 Express 能否创建 Web 服务器？
Express写接口—接口的跨域问题-CORS中间件
weixin_47295886的博客
09-05 655
接口跨域问题：前面的POST和GET接口，存在一个不支持跨域问题使用在线版本的jqueryHTML+jquery ————>在这里的时候需要启动服务器from origin 'null' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.————————————说明接口存在跨域的问题。
express处理跨域问题，中间件 CORS
weixin_34378969的博客
05-24 770
CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）。 1、不用中间件的话可以这样写： app.all('*', function (req, res, next) { res.header("Access-Control-Allow-Origin", "*"); res.header("Access-Co...
Node.js进阶 --- Express常用跨域中间件cors
alexis7的博客
03-22 366
Node.js进阶 — Express常用跨域中间件cors 在项目开发中前后端项目往往部署在不同的端口号中，会导致跨域错误，需要在node服务中添加跨域中间件cors： 安装： npm i -S cors 在app.js中使用： const cors = require('cors') // ... app.use(cors()) ...
团结后端：团结项目-后端NodeJS-Express-MongoDB
02-15
团结后端 开发该项目的目的是向更多人宣布团结活动。...技术：NodeJS-Express-MongoDB 测试工具：摩卡-柴-柴-http-法克 Heroku服务器： : 样本json文档： : （不需要令牌） 项目管理委员会： :
cos-nodejs-sdk-v5:腾讯云 COS Nodejs SDK（XML API）
07-23
cos-nodejs-sdk-v5腾讯云 COS Nodejs SDK（）installnpm i cos-nodejs-sdk-v5 --savedemo// 引入模块var COS = require('cos-nodejs-sdk-v5');// 创建实例var cos = new COS({ SecretId: '...
databunker-nodejs-example:databunker-nodejs-示例
05-15
databunker-nodejs-示例这是使用以下技术构建的nodejs登录和注册页面的示例： Passport.js Magic.link Databunker 该项目最初基于Magic.Link Nodejs示例： 深入回顾Databunker的。先决条件1.启动Databunker服务： ...
conexion-nodejs-mysql:NodeJS与MySQL连接的实现
05-28
连接-nodejs-mysql NodeJS与MySQL连接的实现
nodejs-shopping-cart：NodeJS购物车-NodeJS，Express，Express-Session，Express车把（hbs）
02-04
克隆此存储库git clone https://github.com/gtsopour/nodejs-shopping-cart.git 安装依赖npm install 在启动NodeJS服务器npm start 供Nodemon使用nodemon ./bin/www技术领域NodeJS，Express，Express-Session，...
Express的路由、中间件、接口、CORS跨域解决
wang13679201813的博客
05-24 1508
介绍了web服务端Express的基本概念，路由、中间件、及怎么编写get、post接口、CORS跨域解决
node ，express框架后台设置跨域操作,路由中间件
weixin_34209851的博客
09-13 211
express项目入口文件下app.js 设置跨域操作 app.all('*', function(req, res, next) { res.header("Access-Control-Allow-Origin", "*"); res.header("Access-Control-Allow-Headers", "X-Requested-With,Content-Typ...
express中间件代理实现跨域
akavavp3896的博客
04-18 386
前端代码 var xhr = new XMLHttpRequest(); xhr.open('post', 'http://localhost:3000', true); xhr.onreadystatechange = function () { if (xhr.readyState == 4 && xhr.status == 200) { ...
express 跨域
kaixuanweb的博客
03-31 526
目标：express   实现跨域；前提：在服务端执行npm install cors；方法一：在app.js:var cors = require("cors");app.use(cors());app.all('*', function(req, res, next) { // res.header("Access-Control-Allow-Credentials","true")...
前端学习笔记：Node.js学习-Express创建服务器-路由-中间件-跨域处理
qq_57795776的博客
07-21 454
前端学习笔记：Node.js学习-Express创建服务器-路由-中间件-跨域处理
解决nodejs跨域的一个中间件
anmo5372的博客
07-18 493
https://www.npmjs.com/package/cors 转载于:https://www.cnblogs.com/davidpan/p/5681049.html
解决对ExpressJS搭建服务的跨域问题
Hello World
08-10 528
重启Express项目，前端访问正常。
Node.js的接口跨域的问题与解决方案，使用 CORS中间件解决跨域问题
No1banana的博客
06-11 1181
CORS 是由一系列HTTP响应头组成，由这些HTTP响应头决定浏览器是否阻止前端JS代码跨域获取资源。浏览器的同源安全策略会阻止网页跨域获取资源，但如果接口服务器配置了CORS相关的HTTP响应头，就可以接触浏览器端的跨域访问限制。**注意：**CORS主要在服务器端进行配置，浏览器无需做额外的配置，即可请求开启了CORS的接口。CORS在浏览器中有兼容性，ie10+ 、chrome4+、firefox3.5+。...
nodejs-legacy nodejs
08-19
nodejs-legacy和nodejs是用于在Ubuntu系统上安装Node.js的包。nodejs-legacy是一个过渡性的软件包，用于确保在旧版本Ubuntu系统上的向后兼容性。而nodejs则是正式的Node.js软件包。在安装Node.js时，可以选择使用apt...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值