前端技术(六)—— AJAX详解

news2024/11/14 18:01:39

一、原生 AJAX

1. AJAX 简介

AJAX 全称为 Asynchronous JavaScript And XML，就是异步的 JS 和 XML。
通过 AJAX 可以在浏览器中向服务器发送异步请求，最大的优势：无刷新获取数据。
AJAX 不是新的编程语言，而是一种将现有的标准组合在一起使用的新方式。

2.XML 简介

XML 可扩展标记语言。
XML 被设计用来传输和存储数据。
XML 和 HTML 类似，不同的是 HTML 中都是预定义标签，而 XML 中没有预定义标签，全都是自定义标签，用来表示一些数据。
比如说我有一个学生数据：name = “孙悟空” ; age = 18 ; gender = “男” ;

//用 XML 表示：
<student>
	<name>孙悟空</name>
	<age>18</age>
	<gender>男</gender>
</student>

现在已经被 JSON 取代了。

//用 JSON 表示：
{"name":"孙悟空","age":18,"gender":"男"}

3.AJAX 的特点

⑴ AJAX 的优点

  1. 可以无需刷新页面而与服务器端进行通信。
  2. 允许你根据用户事件来更新部分页面内容。

⑵ AJAX 的缺点

  1. 没有浏览历史，不能回退
  2. 存在跨域问题(同源)
  3. SEO 不友好

4. AJAX 的使用

⑴ 前期准备

1) 安装node.js

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2) 查看已安装的 Node.js 的版本号
# 打开终端，在终端输入命令 node –v 后，按下回车键，即可查看已安装的 Node.js 的版本号。
C:\Users\12137>node -v

在这里插入图片描述

Windows 系统快速打开终端的方式：
使用快捷键（Windows徽标键 + R）打开运行面板，输入 cmd 后直接回车，即可打开终端。
在这里插入图片描述

3) 使用express创建项目

使用命令初始化项目

npm init --yes

在这里插入图片描述
引入express包

npm i express

在这里插入图片描述

⑵ 核心对象

XMLHttpRequest，AJAX 的所有操作都是通过该对象进行的。

/*
  响应报文
  行     
     HTTP/1.1 200 ok
  头 
     Content-Type:text/html;charset=utf-8
     Content-length:2048
     Content-encoding:gzip
  体
     <html>
         <head>
         </head>
         <body>
             <h1>柯基侦探</h1>
         </body>
     </html>
 */

⑶ 使用步骤

1) 创建 XMLHttpRequest 对象
var xhr = new XMLHttpRequest();
2) 设置请求信息
xhr.open(method, url);
//可以设置请求头，一般不设置
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
3) 发送请求
xhr.send(body) //get 请求不传 body 参数，只有 post 请求使用
4) 接收响应
//xhr.responseXML 接收 xml 格式的响应数据
//xhr.responseText 接收文本格式的响应数据
xhr.onreadystatechange = function (){
	if(xhr.readyState == 4 && xhr.status == 200){
		var text = xhr.responseText;
		console.log(text);
	}
}

⑷ 解决 IE 缓存问题

问题：在一些浏览器中(IE),由于缓存机制的存在，ajax 只会发送的第一次请求，剩余多次请求不会在发送给浏览器而是直接加载缓存中的数据。
解决方式：浏览器的缓存是根据 url 地址来记录的，所以我们只需要修改 url 地址即可避免缓存问题

xhr.open("get","/testAJAX?t="+Date.now());

⑸ AJAX 请求状态

xhr.readyState 可以用来查看请求当前的状态
https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest/readyState
0: 表示 XMLHttpRequest 实例已经生成，但是 open()方法还没有被调用。
1: 表示 send()方法还没有被调用，仍然可以使用 setRequestHeader()，设定 HTTP请求的头信息。
2: 表示 send()方法已经执行，并且头信息和状态码已经收到。
3: 表示正在接收服务器传来的 body 部分的数据。
4: 表示服务器数据已经完全接收，或者本次接收已经失败了

⑹ AJAX基本的请求案例一 ——发起不带参的get请求

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX GET 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border:solid 1px #90b;
        }
    </style>
</head>
<body>
    <button>点击发送请求</button>
    <div id="result"></div>
    <script>
        //获取button元素
        const btn = document.getElementsByTagName('button')[0];
        const result = document.getElementById("result");
        //绑定点击事件
        btn.onclick = function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //2.初始化 设置请求方法和url
            xhr.open('GET','http://127.0.0.1:8000/server');
            //3.发送
            xhr.send();
            //4.事件绑定，处理服务器返回的结果
            //on when 当...时候
            //readystate 是xhr对象中的属性，表示状态0 1 2 3 4
            /*
            readyState属性是XMLHttpRequest对象的一个重要属性，用于标识当前请求的状态。这个属性有5个可能的值，它们分别代表请求的不同阶段：
                ‌0 - 未初始化‌：表示对象尚未调用send()方法。
                ‌1 - 载入‌：已调用send()方法，正在发送请求。
                ‌2 - 载入完成‌：send()方法执行完成，已经接收到全部响应内容。
                ‌3 - 交互‌：正在解析响应内容。
                ‌4 - 完成‌：响应内容解析完成，可以在客户端调用了。
                这五个状态值提供了对HTTP请求从发送到接收响应整个过程的详细跟踪，使得开发者能够更好地控制和管理异步请求。
            */
           //change 改变
           xhr.onreadystatechange = function(){
                //判断(服务端返回了所有的结果)
                if(xhr.readyState === 4){
                    //判断响应状态码 200 404 403 401 500
                    //2XX 表示成功
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理结果 行 头 空行 体
                       //1.响应头
                       console.log(xhr.status);//状态码
                       console.log(xhr.statusText);//状态字符串
                       console.log(xhr.getAllResponseHeaders());//所有的响应头
                       console.log(xhr.response);//响应体
                       //设置result文本
                       result.innerHTML = xhr.response;
                    }else{

                    }
                }
           }
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

⑺ AJAX基本的请求案例二 —— 发起带参的get请求

ajax get请求传参可以直接在url后面拼接

url?参数1=参数1值&参数2=参数2值

在这里插入图片描述
在这里插入图片描述

server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX GET 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border:solid 1px #90b;
        }
    </style>
</head>
<body>
    <button>点击发送请求</button>
    <div id="result"></div>
    <script>
        //获取button元素
        const btn = document.getElementsByTagName('button')[0];
        const result = document.getElementById("result");
        //绑定点击事件
        btn.onclick = function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //2.初始化 设置请求方法和url
            xhr.open('GET','http://127.0.0.1:8000/server?userName=zs&age=18');
            //3.发送
            xhr.send();
            //4.事件绑定，处理服务器返回的结果
            //on when 当...时候
            //readystate 是xhr对象中的属性，表示状态0 1 2 3 4
            /*
            readyState属性是XMLHttpRequest对象的一个重要属性，用于标识当前请求的状态。这个属性有5个可能的值，它们分别代表请求的不同阶段：
                ‌0 - 未初始化‌：表示对象尚未调用send()方法。
                ‌1 - 载入‌：已调用send()方法，正在发送请求。
                ‌2 - 载入完成‌：send()方法执行完成，已经接收到全部响应内容。
                ‌3 - 交互‌：正在解析响应内容。
                ‌4 - 完成‌：响应内容解析完成，可以在客户端调用了。
                这五个状态值提供了对HTTP请求从发送到接收响应整个过程的详细跟踪，使得开发者能够更好地控制和管理异步请求。
            */
           //change 改变
           xhr.onreadystatechange = function(){
                //判断(服务端返回了所有的结果)
                if(xhr.readyState === 4){
                    //判断响应状态码 200 404 403 401 500
                    //2XX 表示成功
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理结果 行 头 空行 体
                       //1.响应头
                       console.log(xhr.status);//状态码
                       console.log(xhr.statusText);//状态字符串
                       console.log(xhr.getAllResponseHeaders());//所有的响应头
                       console.log(xhr.response);//响应体
                       //设置result文本
                       result.innerHTML = xhr.response;
                    }else{

                    }
                }
           }
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

⑻ AJAX基本的请求案例三——发起不带参的post请求

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX POST 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border: solid 1px #903;
        }
    </style>
</head>
<body>
    <div id="result"></div>
    <script>
        //获取元素对象
        const result = document.getElementById("result");
        //绑定事件
        result.addEventListener('mouseover',function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //2.初始化，设置类型与url
            xhr.open('POST','http://127.0.0.1:8000/server');
            //3.发送请求
            xhr.send();
            //4.事件绑定
            xhr.onreadystatechange = function(){
                //判断
                if(xhr.readyState === 4){
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理服务器端返回的结果
                        result.innerHTML = xhr.response;
                    }
                }
            }
        });
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

⑼ AJAX基本的请求案例四 —— 发起带参的post请求

1) 发起带有请求体的post请求

在这里插入图片描述
在这里插入图片描述

server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX POST 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border: solid 1px #903;
        }
    </style>
</head>
<body>
    <div id="result"></div>
    <script>
        //获取元素对象
        const result = document.getElementById("result");
        //绑定事件
        result.addEventListener('mouseover',function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //2.初始化，设置类型与url
            xhr.open('POST','http://127.0.0.1:8000/server');
            //3.发送请求
            // xhr.send('username=zs&age=19');
            //xhr.send('username:zs&age:19');
            xhr.send('柯基侦探微信公众号');
            //4.事件绑定
            xhr.onreadystatechange = function(){
                //判断
                if(xhr.readyState === 4){
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理服务器端返回的结果
                        result.innerHTML = xhr.response;
                    }
                }
            }
        });
    </script>
</body>
</html>

测试：
启动服务

在这里插入图片描述

在这里插入图片描述

2) 发起带有请求头的post请求

请求报文的格式

行：
	POST /s?ie=uft-8 HTTP/1.1
头:
	Host:kejizhentan.com
	Cookie:name=kejizhentan
	Content-type:application/x-www-form-urlencoded
	User-Agent:chrome 83
空行：
体：
	username=admin&password=123456

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX POST 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border: solid 1px #903;
        }
    </style>
</head>
<body>
    <div id="result"></div>
    <script>
        //获取元素对象
        const result = document.getElementById("result");
        //绑定事件
        result.addEventListener('mouseover',function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //2.初始化，设置类型与url
            xhr.open('POST','http://127.0.0.1:8000/server');
            //设置请求头
            xhr.setRequestHeader('Content-Type','application/x-www-form-urlencoded');
            //3.发送请求
            // xhr.send('username=zs&age=19');
            //xhr.send('username:zs&age:19');
            xhr.send('柯基侦探微信公众号');
            //4.事件绑定
            xhr.onreadystatechange = function(){
                //判断
                if(xhr.readyState === 4){
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理服务器端返回的结果
                        result.innerHTML = xhr.response;
                    }
                }
            }
        });
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述

在这里插入图片描述

⑽ AJAX基本的请求案例五 ——服务端响应json数据

1) 手动转换json数据

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});

app.post('/json-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //响应一个数据
    const data = {
        name:"柯基侦探"
    };
    //对对象进行字符串转换
    let str = JSON.stringify(data);
    //设置响应体
    response.send(str);
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX POST 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border: solid 1px #89b;
        }
    </style>
</head>
<body>
    <div id="result"></div>
    <script>
        //获取元素对象
        const result = document.getElementById("result");
        //绑定事件
        window.onkeydown = function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //2.初始化，设置类型与url
            xhr.open('POST','http://127.0.0.1:8000/json-server');
            //3.发送请求
            xhr.send();
            //4.事件绑定
            xhr.onreadystatechange = function(){
                //判断
                if(xhr.readyState === 4){
                    if(xhr.status >= 200 && xhr.status < 300){
                        //手动对数据进行转换
                        let data =  JSON.parse(xhr.response);
                        //处理服务器端返回的结果
                        result.innerHTML = data.name;
                    }
                }
            }
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

2) 自动转换json数据

在这里插入图片描述

在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});

app.post('/json-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //响应一个数据
    const data = {
        name:"柯基侦探"
    };
    //对对象进行字符串转换
    let str = JSON.stringify(data);
    //设置响应体
    response.send(str);
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX POST 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border: solid 1px #89b;
        }
    </style>
</head>
<body>
    <div id="result"></div>
    <script>
        //获取元素对象
        const result = document.getElementById("result");
        //绑定事件
        window.onkeydown = function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //设置响应体数据的类型
            xhr.responseType = 'json';
            //2.初始化，设置类型与url
            xhr.open('POST','http://127.0.0.1:8000/json-server');
            //3.发送请求
            xhr.send();
            //4.事件绑定
            xhr.onreadystatechange = function(){
                //判断
                if(xhr.readyState === 4){
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理服务器端返回的结果,自动转换json格式
                        result.innerHTML = xhr.response.name;
                    }
                }
            }
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述

在这里插入图片描述

⑾ nodemon自动重启工具安装

nodemon工具介绍: https://www.npmjs.com/package/nodemon

安装命令：

npm install -g nodemon

在这里插入图片描述

⑿ AJAX请求超时和网络异常

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});

app.post('/json-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //响应一个数据
    const data = {
        name:"柯基侦探"
    };
    //对对象进行字符串转换
    let str = JSON.stringify(data);
    //设置响应体
    response.send(str);
});

app.get('/delay',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    setTimeout(()=>{
        //设置响应体
        response.send('延迟响应~');
    },3000);
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX GET 请求</title>
    <style>
        #result{
            width: 200px;
            height: 100px;
            border:solid 1px #90b;
        }
    </style>
</head>
<body>
    <button>点击发送请求</button>
    <div id="result"></div>
    <script>
        //获取button元素
        const btn = document.getElementsByTagName('button')[0];
        const result = document.getElementById("result");
        //绑定点击事件
        btn.onclick = function(){
            //1.创建对象
            const xhr = new XMLHttpRequest();
            //超时设置2s
            xhr.timeout=2000;
            //超时回调
            xhr.ontimeout = function(){
                alert("请求超时，请稍后重试");
            }
            //网络异常
            xhr.onerror = function(){
                alert("网络异常，家里断网啦~");
            }
            //2.初始化 设置请求方法和url
            xhr.open('GET','http://127.0.0.1:8000/delay');
            //3.发送
            xhr.send();
           //change 改变
           xhr.onreadystatechange = function(){
                //判断(服务端返回了所有的结果)
                if(xhr.readyState === 4){
                    //判断响应状态码 200 404 403 401 500
                    //2XX 表示成功
                    if(xhr.status >= 200 && xhr.status < 300){
                        //处理结果 行 头 空行 体
                       //1.响应头
                       //设置result文本
                       result.innerHTML = xhr.response;
                    }else{

                    }
                }
           }
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

⒀ AJAX取消请求

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});

app.post('/json-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //响应一个数据
    const data = {
        name:"柯基侦探"
    };
    //对对象进行字符串转换
    let str = JSON.stringify(data);
    //设置响应体
    response.send(str);
});

app.get('/delay',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    setTimeout(()=>{
        //设置响应体
        response.send('延迟响应~');
    },3000);
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX 请求取消</title>
</head>
<body>
    <button>点击发送</button>
    <button>点击取消</button>
    <script>
        //获取元素对象
        const btns =  document.querySelectorAll('button');
        let x = null;
        //发起请求
        btns[0].onclick = function(){
            x = new XMLHttpRequest();
            x.open("GET",'http://127.0.0.1:8000/delay');
            x.send();
        }
        //取消请求
        btns[1].onclick = function(){
            x.abort();
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

⒁ AJAX请求重复发送问题

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});

app.post('/json-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //响应一个数据
    const data = {
        name:"柯基侦探"
    };
    //对对象进行字符串转换
    let str = JSON.stringify(data);
    //设置响应体
    response.send(str);
});

app.get('/delay',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    setTimeout(()=>{
        //设置响应体
        response.send('延迟响应~');
    },3000);
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX 请求取消</title>
</head>
<body>
    <button>点击发送</button>
    <script>
        //获取元素对象
        const btns =  document.querySelectorAll('button');
        let x = null;
        //标识变量
        let isSending  = false;//是否正在发送ajax请求 
        //发起请求
        btns[0].onclick = function(){
            //判断标识变量
            if(isSending) x.abort();//如果正在发送请求，则取消该请求，创建一个新的请求
            x = new XMLHttpRequest();
            //修改标识变量的值
            isSending = true;
            x.open("GET",'http://127.0.0.1:8000/delay');
            x.send();
            x.onreadystatechange = function(){
                if(x.readyState === 4){
                    //修改标识变量
                    isSending = false;
                }
            }
        }
    </script>
</body>
</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

二、jQuery 中的 AJAX

1. jQuery 中 使用ajax 发送get 请求

$.get(url, [data], [callback], [type])
url:请求的 URL 地址。
data:请求携带的参数。
callback:载入成功时回调函数。
type:设置返回内容格式，xml, html, script, json, text, _default。

2. jQuery 中 使用ajax 发送 post 请求

$.post(url, [data], [callback], [type])
url:请求的 URL 地址。
data:请求携带的参数。
callback:载入成功时回调函数。
type:设置返回内容格式，xml, html, script, json, text, _default。

3.jQuery 中 使用ajax 发送请求的通用格式

$.ajax({
    url: 'your-endpoint-url', // 目标URL
    type: 'GET', // 请求类型，可以是GET、POST、PUT、DELETE等
    dataType: 'json', // 预期服务器返回的数据类型
    data: {param1: 'value1', param2: 'value2'}, // 发送到服务器的数据
    beforeSend: function(xhr) {
        // 发送请求前可以在这里做些什么，例如设置自定义HTTP头部
    },
    success: function(response) {
        // 请求成功时的回调函数
        console.log(response);
    },
    error: function(xhr, status, error) {
        // 请求失败时的回调函数
        console.log(error);
    },
    complete: function(xhr, status) {
        // 请求完成时的回调函数（无论成功或失败）
    }
});

3. jQuery发送AJAX请求案例

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
//2.创建应用对象
const app = express();
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX');
});

app.post('/server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //设置响应体
    response.send('HELLO AJAX POST');
});

app.post('/json-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    //响应一个数据
    const data = {
        name:"柯基侦探"
    };
    //对对象进行字符串转换
    let str = JSON.stringify(data);
    //设置响应体
    response.send(str);
});

app.get('/delay',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    setTimeout(()=>{
        //设置响应体
        response.send('延迟响应~');
    },3000);
});


app.all('/jquery-server',(request,response)=>{
    //设置响应
    //设置响应头，设置允许跨域
    response.setHeader('Access-Control-Allow-Origin','*');
    let data = {"usename":"柯基侦探"}
    response.send(JSON.stringify(data));
});
//4.监听端口启动服务
app.listen(8000,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header">jQuery发送AJAX请求</h2>
        <button class="btn btn-primary">GET</button>
        <button class="btn btn-danger">POST</button>
        <button class="btn btn-info">通用型方法</button>
    </div>
    <script>
        $('button').eq(0).click(function () {
            $.get("http://127.0.0.1:8000/jquery-server", { "username": "zs", "age": 18 }, function (data) {
                console.log(data);
            }, 'json');
        });
        $('button').eq(1).click(function () {
            $.post("http://127.0.0.1:8000/jquery-server", { "username": "zs", "age": 18 }, function (data) {
                console.log(data);
            });
        });
        $('button').eq(2).click(function () {
            $.ajax({
                url: 'http://127.0.0.1:8000/jquery-server', // 目标URL
                type: 'GET', // 请求类型，可以是GET、POST、PUT、DELETE等
                dataType: 'json', // 预期服务器返回的数据类型
                data: { username: 'zhangsan', age: 18 }, // 发送到服务器的数据
                beforeSend: function (xhr) {
                    // 发送请求前可以在这里做些什么，例如设置自定义HTTP头部
                    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                },
                success: function (data) {
                    // 请求成功时的回调函数
                    console.log("通用ajax请求响应的结果:",data);
                },
                error: function (xhr, status, error) {
                    // 请求失败时的回调函数
                    console.log("出错了~");
                },
                complete: function (xhr, status) {
                    // 请求完成时的回调函数（无论成功或失败）
                    console.log("请求完成了~");
                }
            });
        });
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

三、Axios发送AJAX请求

点击连接访问 https://www.bootcdn.cn/
在这里插入图片描述

1. axios 的理解和使用

⑴ axios 是什么?

  1. 前端最流行的 ajax 请求库
  2. react/vue 官方都推荐使用 axios 发 ajax 请求
  3. 文档: https://github.com/axios/axios

⑵ axios 特点

  1. 基于 xhr + promise 的异步 ajax 请求库
  2. 浏览器端/node 端都可以使用
  3. 支持请求／响应拦截器
  4. 支持请求取消
  5. 请求/响应数据转换
  6. 批量发送多个请求

⑶ axios 常用语法

axios(config): 通用/最本质的发任意类型请求的方式
axios(url[, config]): 可以只指定 url 发 get 请求
axios.request(config): 等同于 axios(config)
axios.get(url[, config]): 发 get 请求
axios.delete(url[, config]): 发 delete 请求
axios.post(url[, data, config]): 发 post 请求
axios.put(url[, data, config]): 发 put 请求
axios.defaults.xxx: 请求的默认全局配置
axios.interceptors.request.use(): 添加请求拦截器
axios.interceptors.response.use(): 添加响应拦截器
axios.create([config]): 创建一个新的 axios(它没有下面的功能)
axios.Cancel(): 用于创建取消请求的错误对象
axios.CancelToken(): 用于创建取消请求的 token 对象
axios.isCancel(): 是否是一个取消请求的错误
axios.all(promises): 用于批量执行多个异步请求
axios.spread(): 用来指定接收所有成功数据的回调函数的方法

在这里插入图片描述

2. axios 基本使用

axios(config): 通用/最本质的发任意类型请求的方式

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
const cors = require('cors');
//2.创建应用对象
const app = express();
// 使用cors中间件
app.use(cors())
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应体
    response.send('HELLO AXIOS GET');
});

app.post('/server',(request,response)=>{
    //设置响应体
    response.send('HELLO AXIOS POST');
});

app.put('/server',(request,response)=>{
    //设置响应体
    response.send('HELLO AXIOS PUT');
});

app.delete('/server',(request,response)=>{
    //设置响应体
    response.send('HELLO AXIOS DELETE');
});
//4.监听端口启动服务
app.listen(8888,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/axios/1.7.5/axios.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header">axios基本使用</h2>
        <button class="btn btn-primary">发送GET请求</button>
        <button class="btn btn-danger">发送POST请求</button>
        <button class="btn btn-info">发送PUT请求</button>
        <button class="btn btn-info">发送DELETE请求</button>
    </div>
    <script>
        //获取按钮
        const btns = document.querySelectorAll('button');

        //模拟发送GET请求
        //发送GET的按钮
        btns[0].onclick = function(){
            //发送AXIOS请求
            axios({
                //请求类型
                method:'GET',
                //请求的URL
                url:'http://127.0.0.1:8888/server?username=kejizhentan',
            }).then(response=>{
                console.log(response);
            });
        }

        //模拟发送POST请求
        //发送POST请求的按钮
        btns[1].onclick = function(){
            //发送axios请求
            axios({
                //请求类型
                method:'POST',
                //请求的URL
                url:'http://127.0.0.1:8888/server',
                //设置请求体
                data:{
                    username:"柯基侦探",
                    age:7
                }
            }).then(response=>{
                console.log(response);
            });
        }

        //模拟发送PUT请求
        //发送PUT请求的按钮
        btns[2].onclick = function(){
            //发送axios请求
            axios({
                //请求类型
                method:'PUT',
                //请求的URL
                url:'http://127.0.0.1:8888/server',
                //设置请求体
                data:{
                    username:"张三",
                    age:18
                }
            }).then(response=>{
                console.log(response);
            });
        }

        //模拟发送DELETE请求
        //发送DELETE请求的按钮
        btns[3].onclick = function(){
            //发送axios请求
            axios({
                //请求类型
                method:'DELETE',
                //请求的URL
                url:'http://127.0.0.1:8888/server'
            }).then(response=>{
                console.log(response);
            });
        }
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

3. axios.request请求方式介绍

axios.request(config): 等同于 axios(config)
axios.get(url[, config]): 发 get 请求
axios.delete(url[, config]): 发 delete 请求
axios.post(url[, data, config]): 发 post 请求
axios.put(url[, data, config]): 发 put 请求

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
const cors = require('cors');
//2.创建应用对象
const app = express();
// 使用cors中间件
app.use(cors())
//3.创建路由规则
//request 是对请求报文的封装
//response 是对响应报文的封装
app.get('/server',(request,response)=>{
    //设置响应
    //设置响应体
    response.send('HELLO AXIOS GET');
});

app.post('/server',(request,response)=>{
    //设置响应体
    response.send('HELLO AXIOS POST');
});

app.put('/server',(request,response)=>{
    //设置响应体
    response.send('HELLO AXIOS PUT');
});

app.delete('/server',(request,response)=>{
    //设置响应体
    response.send('HELLO AXIOS DELETE');
});
//4.监听端口启动服务
app.listen(8888,()=>{
    console.log('服务已启动,8000端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/axios/1.7.5/axios.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header">axios基本使用</h2>
        <button class="btn btn-primary">发送GET请求</button>
        <button class="btn btn-danger">发送POST请求</button>
        <button class="btn btn-info">发送PUT请求</button>
        <button class="btn btn-info">发送DELETE请求</button>
    </div>
    <script>
        //获取按钮
        const btns = document.querySelectorAll('button');

        //模拟发送GET请求
        //发送GET的按钮
        btns[0].onclick = function(){
            //发送AXIOS请求
            axios.request({
                //请求类型
                method:'GET',
                //请求的URL
                url:'http://127.0.0.1:8888/server?username=kejizhentan',
            }).then(response=>{
                console.log(response);
            });
        }

        //模拟发送POST请求
        //发送POST请求的按钮
        btns[1].onclick = function(){
            //发送axios请求
            axios.post(
                //请求的URL
                'http://127.0.0.1:8888/server',
                //设置请求体
                {
                    username:"柯基侦探",
                    age:7
                }
            ).then(response=>{
                console.log(response);
            });
        }

        //模拟发送PUT请求
        //发送PUT请求的按钮
        btns[2].onclick = function(){
            //发送axios请求
            axios({
                //请求类型
                method:'PUT',
                //请求的URL
                url:'http://127.0.0.1:8888/server',
                //设置请求体
                data:{
                    username:"张三",
                    age:18
                }
            }).then(response=>{
                console.log(response);
            });
        }

        //模拟发送DELETE请求
        //发送DELETE请求的按钮
        btns[3].onclick = function(){
            //发送axios请求
            axios({
                //请求类型
                method:'DELETE',
                //请求的URL
                url:'http://127.0.0.1:8888/server'
            }).then(response=>{
                console.log(response);
            });
        }
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

4. axios 配置对象说明

{
  // 请求的url
  url: '/user',

  //请求方法，如GET, POST, PUT, DELETE等
  method: 'get', // default

  // 设置请求的基础URL
  baseURL: 'https://some-domain.com/api/',

  // 请求数据转换函数（可选）
  transformRequest: [function (data, headers) {
    return data;
  }],

  //响应数据转换函数（可选）
  transformResponse: [function (data) {
    return data;
  }],

  // 请求头（对象形式）
  headers: {'X-Requested-With': 'XMLHttpRequest'},

  //请求参数对象
  params: {
    ID: 12345
  },
  
  // 自定义参数序列化函数（可选）
  paramsSerializer: {

    //Custom encoder function which sends key/value pairs in an iterative fashion.
    encode?: (param: string): string => { /* Do custom operations here and return transformed string */ }, 
    
    // Custom serializer function for the entire parameter. Allows user to mimic pre 1.x behaviour.
    serialize?: (params: Record<string, any>, options?: ParamsSerializerOptions ), 
    
    //Configuration for formatting array indexes in the params. 
    indexes: false // Three available options: (1) indexes: null (leads to no brackets), (2) (default) indexes: false (leads to empty brackets), (3) indexes: true (leads to brackets with indexes).    
  },

  //请求体数据
  data: {
    firstName: 'Fred'
  },

  // 请求超时时间（毫秒）
  timeout: 1000, // default is `0` (no timeout)

  //  是否携带凭证（如cookies）进行跨域请求（可选）
  withCredentials: false, // default

  // 自定义请求适配器（可选）
  adapter: function (config) {
    /* ... */
  },

  //基本认证凭据（用户名和密码）
  auth: {
    username: 'janedoe',
    password: 's00pers3cret'
  },

  //  响应数据类型，如json、arraybuffer、blob、document、text等
  responseType: 'json', // default

  // 响应数据编码,如 'utf8', 'UTF8', 'utf16le', 'UTF16LE'
  responseEncoding: 'utf8', // default

  // 用作CSRF令牌的cookie的名称
  xsrfCookieName: 'XSRF-TOKEN', // default

  // 用于放置CSRF令牌的HTTP头的名称
  xsrfHeaderName: 'X-XSRF-TOKEN', // default

  // 上传进度事件（可选）
  onUploadProgress: function ({loaded, total, progress, bytes, estimated, rate, upload = true}) {
    // Do whatever you want with the Axios progress event
  },

  // 下载进度事件（可选）
  onDownloadProgress: function ({loaded, total, progress, bytes, estimated, rate, download = true}) {
    // Do whatever you want with the Axios progress event
  },

  // 允许的最大http内容长度
  maxContentLength: 2000,

 //自定义HTTP响应状态码验证函数（可选）
  validateStatus: function (status) {
    return status >= 200 && status < 300; // default
  },

  // 最大重定向次数
  maxRedirects: 21, // default
}

5. axios的默认配置

Axios Config Defaults 是指通过 axios.defaults.xxx 设置 axios 的默认配置

//axios.defaults.baseURL: 设置 axios 请求的基础 URL，在发送请求时如果 URL 不是绝对路径，就会使用 baseURL。
axios.defaults.baseURL = 'https://api.example.com';
//axios.defaults.headers.common: 设置通用的请求头。
axios.defaults.headers.common['Authorization'] = 'AUTH_TOKEN';
//axios.defaults.timeout: 设置请求超时时间。
axios.defaults.timeout = 1000;
//axios.defaults.adapter: 设置自定义的请求适配器。
axios.defaults.adapter = function (config) {
  /* 自定义适配器的逻辑 */
};
//axios.defaults.validateStatus: 设置判定请求响应状态码的函数。
axios.defaults.validateStatus = function (status) {
  return status >= 200 && status < 300; // 默认的判定逻辑
};
//axios.defaults.transformRequest: 设置请求数据的转换函数。
axios.defaults.transformRequest = [function (data) {
  /* 转换请求数据的逻辑 */
}];
//axios.defaults.transformResponse: 设置响应数据的转换函数。

axios.defaults.transformResponse = [function (data) {
  /* 转换响应数据的逻辑 */
}];

在这里插入图片描述
在这里插入图片描述

server.js

//1.引入express
const express = require('express');
const cors = require('cors');
//2.创建应用对象
const app = express();
// 使用cors中间件
app.use(cors())
//3.创建路由规则
//request 是对请求报文的封装
app.get('/server',(request,response)=>{
    console.log(request);
    //设置响应体
    response.send('HELLO AXIOS GET');
});
//4.监听端口启动服务
app.listen(8888,()=>{
    console.log('服务已启动,8888端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/axios/1.7.5/axios.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header"> axios的默认配置</h2>
        <button class="btn btn-primary">发送GET请求</button>
    </div>
    <script>
        //获取按钮
        const btns = document.querySelectorAll('button');
        //默认设置
        axios.defaults.method = 'GET';//设置默认的请求为get
        axios.defaults.baseURL = 'http://127.0.0.1:8888';//设置基础URL
        axios.defaults.params = {username:"柯基侦探"};
        axios.defaults.timeout=3000;
        //模拟发送POST请求
        //发送POST请求的按钮
        btns[0].onclick = function(){
            //发送axios请求
            axios({
                url:'/server'
            }
            ).then(response=>{
                console.log(response);
            });
        }
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

6. axios创建实例对象发送请求

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
const cors = require('cors');
//2.创建应用对象
const app = express();
// 使用cors中间件
app.use(cors())
//3.创建路由规则
//request 是对请求报文的封装
app.get('/server',(request,response)=>{
    console.log(request);
    //设置响应体
    response.send('HELLO AXIOS GET');
});
//4.监听端口启动服务
app.listen(8888,()=>{
    console.log('服务已启动,8888端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet"
        integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/axios/1.7.5/axios.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header"> axios创建实例对象发送请求</h2>
        <button class="btn btn-primary">发送GET请求</button>
    </div>
    <script>
        //获取按钮
        const btns = document.querySelectorAll('button');
        //创建实例对象
        const kjzt = axios.create({
            baseURL: 'http://127.0.0.1:8888',
            timeout: 2000
        });
        //这里的kjzt对象跟axios对象几乎是一样的功能
        btns[0].onclick = function () {
            kjzt({
                //请求类型
                method:'GET',
                url: '/server'
            }).then(response => {
                console.log(response);
            });
        } 
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

7. axios拦截器

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
const cors = require('cors');
//2.创建应用对象
const app = express();
// 使用cors中间件
app.use(cors())
//3.创建路由规则
//request 是对请求报文的封装
app.get('/server',(request,response)=>{
    console.log(request);
    //设置响应体
    response.send('HELLO AXIOS GET');
});
//4.监听端口启动服务
app.listen(8888,()=>{
    console.log('服务已启动,8888端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet"
        integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/axios/1.7.5/axios.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header"> axios创建实例对象发送请求</h2>
        <button class="btn btn-primary">发送GET请求</button>
    </div>
    <script>
        //设置请求拦截器
        axios.interceptors.request.use(function (config) {
            console.log('请求拦截器 成功 -1！');
            return config;
        }, function (error) {
            console.log('请求拦截器 失败-1!');
            return Promise.reject(error);
        });
        //设置请求拦截器
        axios.interceptors.request.use(function (config) {
            console.log('请求拦截器 成功-2！');
            return config;
        }, function (error) {
            console.log('请求拦截器 失败-2!');
            return Promise.reject(error);
        });

        // 设置响应拦截器
        axios.interceptors.response.use(function (response) {
            console.log('响应拦截器 成功-1!');
            return response;
        }, function (error) {
            console.log('响应拦截器 失败-1!');
            return Promise.reject(error);
        });
        // 设置响应拦截器
        axios.interceptors.response.use(function (response) {
            console.log('响应拦截器 成功-2!');
            return response;
        }, function (error) {
            console.log('响应拦截器 失败-2!');
            return Promise.reject(error);
        });


        //发送请求
        //获取按钮
        const btns = document.querySelectorAll('button');

        //模拟发送GET请求
        //发送GET的按钮
        btns[0].onclick = function(){
            //发送AXIOS请求
            axios({
                //请求类型
                method:'GET',
                //请求的URL
                url:'http://127.0.0.1:8888/server',
            }).then(response=>{
                console.log('自定义回调处理成功的结果!');
            }).catch(response=>{
                console.log('自定义回调处理失败的结果');
            });
        }
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

  1. 说明: 调用 axios()并不是立即发送 ajax 请求, 而是需要经历一个较长的流程
  2. 流程: 请求拦截器2 => 请求拦截器1 => 发ajax请求 => 响应拦截器1 => 响
    应拦截器 2 => 请求的回调
  3. 注意: 此流程是通过 promise 串连起来的, 请求拦截器传递的是 config, 响应
    拦截器传递的是 response

8. axios取消请求

⑴ 基本流程

配置 cancelToken 对象
缓存用于取消请求的 cancel 函数
在后面特定时机调用 cancel 函数取消请求
在错误回调中判断如果 error 是 cancel, 做相应处理

⑵ 实现功能

点击按钮, 取消某个正在请求中的请求,在请求一个接口前, 取消前面一个未完成的请求

⑶ axios取消请求和防止重复请求的案例

在这里插入图片描述
在这里插入图片描述
server.js

//1.引入express
const express = require('express');
const cors = require('cors');
//2.创建应用对象
const app = express();
// 使用cors中间件
app.use(cors())
//3.创建路由规则
//request 是对请求报文的封装
app.get('/server',(request,response)=>{
    console.log(request);
    //设置延迟三秒后响应
    setTimeout(()=>{
        //设置响应体
        response.send('HELLO AXIOS GET');
    },3000);
});
//4.监听端口启动服务
app.listen(8888,()=>{
    console.log('服务已启动,8888端口监听中...');
});

test.html

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>jQuery 发送 AJAX 请求</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet"
        integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
    <script src="https://cdn.bootcdn.net/ajax/libs/axios/1.7.5/axios.js"></script>
</head>

<body>
    <div class="container">
        <h2 class="page-header"> axios创建实例对象发送请求</h2>
        <button class="btn btn-primary">发送GET请求</button>
        <button class="btn btn-danger">取消请求</button>
    </div>
    <script>
        //获取按钮
        const btns = document.querySelectorAll('button');
        //2.声明全局变量
        let cancel = null;
        //发送请求
        btns[0].onclick = function () {
            //检测上一次请求是否已完成
            if(cancel !== null){
                //取消上一次的请求
                cancel();
            }
            axios({
                method: 'GET',
                url: 'http://127.0.0.1:8888/server',
                //1.添加配置对象的属性
                cancelToken: new axios.CancelToken(c => {
                    //3.将参数赋值给全局变量cancel
                    cancel = c;
                })
            }).then(response => {
                console.log(response);
                //将cancel 的值初始化
                cancel = null;
            });
        }

        //给第二个按钮 绑定取消请求
        btns[1].onclick = function () {
            cancel();
        }
    </script>
</body>

</html>

测试：
启动服务
在这里插入图片描述
在这里插入图片描述

四、跨域

1. 同源策略

同源策略(Same-Origin Policy)最早由 Netscape 公司提出，是浏览器的一种安全策略。
同源： 协议、域名、端口号 必须完全相同。
违背同源策略就是跨域。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2096164.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【练习3】点击消除

【练习3】点击消除

地址&#xff1a;点击消除_牛客题霸_牛客网 (nowcoder.com) 分析&#xff1a; 消除的是“相邻且相等”的数&#xff0c;可以考虑用栈。这里使用StringBuilder来代替栈&#xff0c;好处是StringBuilder可以实现尾插和尾删的操作。 public class Main {public static void main(S…
阅读更多...
Caching介绍

Caching介绍

缓存&#xff08;Caching&#xff09;是计算机系统中一个非常关键且常用的技术&#xff0c;用于提高数据访问速度和系统性能。在Java编程中&#xff0c;缓存同样扮演着重要角色&#xff0c;特别是在处理大量数据、频繁访问数据库或远程服务时。 缓存的基本原理 缓存的基本原理是…
阅读更多...
雅特力AT-START-F423开发板

雅特力AT-START-F423开发板

文章目录 1、开箱2、硬件设计3、点灯初试4、gpio输入和中断5、定时器基本定时6、定时器输出PWM7、串口使用8、ADC和DAC测试9、IIC驱动OLED测试10、SPI驱动测试11、总结 1、开箱 最近官方给寄了板子&#xff0c;顺便测评一下吧&#xff0c;首先是开箱环节 板子是调试器开发板的…
阅读更多...
栈与队列，优先队列与双端队列(C++)

栈与队列，优先队列与双端队列(C++)

在C语言阶段&#xff0c;我们学过两种数据结构&#xff0c;栈与队列&#xff0c;一种是先进后出&#xff0c;一种是先进先出。 在C阶段&#xff0c;我们有新容器来方便快捷的使用栈和队列而不需要我们手动来编写 即stack与queue 我们直接来看对应接口 stack 同时放上对应的…
阅读更多...
9.标准化与软件知识产权基础知识

9.标准化与软件知识产权基础知识

大纲 标准的分类 标准的编号 保护期限 知识产权的确定 侵权判断 补充 真题 1
阅读更多...
全国大学生数据建模比赛——深度学习

全国大学生数据建模比赛——深度学习

全国大学生数学建模比赛中&#xff0c;深度学习可以成为解决复杂问题的有力手段。 一、深度学习的优势在比赛中的体现 强大的模式识别能力&#xff1a;深度学习模型&#xff0c;如卷积神经网络&#xff08;CNN&#xff09;和循环神经网络&#xff08;RNN&#xff09;&#xff0…
阅读更多...
Linux 系统进程管理实战

Linux 系统进程管理实战

今天给伙伴们分享一下Linux 系统进程管理&#xff0c;希望看了有所收获。 我是公众号「想吃西红柿」「云原生运维实战派」作者&#xff0c;对云原生运维感兴趣&#xff0c;也保持时刻学习&#xff0c;后续会分享工作中用到的运维技术&#xff0c;在运维的路上得到支持和共同进步…
阅读更多...
系统分析师6：计算机网络

系统分析师6：计算机网络

文章目录 1 OSI/RM七层模型2 TCP/IP协议族2.1 常见TCP/IP协议基础2.2 DNS 3 IP地址4 网络规划与设计4.1 网络规划与设计的阶段4.2 层次化网络设计 5 综合布线6 网络存储技术-Raid7 网络接入技术 1 OSI/RM七层模型 集线器多个端口属于同一个冲突域&#xff1b; 交换机多个端口属…
阅读更多...
nexus 清理 docker 镜像

nexus 清理 docker 镜像

下载配置 nexus-cli 看网上文档都用如下地址&#xff0c;但现在已经不能下载&#xff1a; wget https://s3.eu-west-2.amazonaws.com/nexus-cli/1.0.0-beta/linux/nexus-cli chmod x nexus-cli 在 github 上下载&#xff1a; wget https://github.com/heyonggs/nexus-cli/r…
阅读更多...
【202408最新】Anaconda+VSCode+CUDA+Pytorch安装配置保姆级教程

【202408最新】Anaconda+VSCode+CUDA+Pytorch安装配置保姆级教程

最近新换了电脑&#xff0c;又开始从头配置代码环境&#xff0c;到处看教程真的一个头两个大&#xff0c;干脆自己整理了一下&#xff0c;方便以后一站式重装。也提供给大家参考。 1.Anaconda下载安装 Anaconda和Python是替代品&#xff08;也不是&#xff09;&#xff0c;下…
阅读更多...
uniapp引入最新版Animate.css及使用示例

uniapp引入最新版Animate.css及使用示例

亲测可用，不好用请移至评论区揍我 动画库官网：https://animate.style/ cdn地址：https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css（截至目前最新版为：v4.1.1） 1. 将css下载后导入项目static目录中 2. 重要！修改下载的css文件内容 文件内容如…
阅读更多...
Audi TT MK1保险丝盒布局说明书

Audi TT MK1保险丝盒布局说明书

Audi TT MK1保险丝盒布局说明书 保险丝序号额定最大电流(A)对应功能描述110加热式洗涤器喷嘴、加热式后视镜210转向灯35车牌灯45通用电气&#xff0c;导航57.5停车辅助65中控锁系统710倒车灯85电话95防抱死制动系统/ESP1015发动机正时:汽油机115仪表盘、换档锁、自动&#xff0…
阅读更多...
了解内网穿透以及简单应用

了解内网穿透以及简单应用

因特网概述 节点&#xff08;Node&#xff09;&#xff1a;网络中的节点可以是计算机&#xff08;笔记本电脑、台式电脑&#xff0c;服务器等&#xff09;、网络互联设备&#xff08;集线器、交换机&#xff0c;路由器等&#xff09;、其他具有联网功能的设备 &#xff08;网络…
阅读更多...
TCP 之 三次握手 (面经计网篇)

TCP 之 三次握手 (面经计网篇)

这是tcp 简历连接的三次握手方式 , 其中的特殊符号 , 我解释下 , SYN 是 同步的这个单词(synchronization), ACK 是回执,承认的单词(acknowledgement), SYN-ACK 服务器收到SYN报文后&#xff0c;回复一个带有SYN和ACK标志的报文段&#xff0c;这表示服务器已经收到了客户端的SY…
阅读更多...
【C++ Primer Plus习题】8.7

【C++ Primer Plus习题】8.7

问题: 解答: #include <iostream>using namespace std;template <typename T> T SumArray(T arr[], int n) {T sum arr[0] - arr[0];for (int i 0; i < n; i){sum arr[i];}return sum; }template <typename T> T SumArray(T *arr[], int n) {T sum *…
阅读更多...
sqli-libs第四关详解

sqli-libs第四关详解

首先判断是数字型注入还是字符型注入 正常显示&#xff0c;说明是字符型注入&#xff0c;那么尝试单引号闭合 还是正常显示&#xff0c;尝试双引号闭合 有报错信息&#xff0c;含有括号&#xff0c;这时就应该想到&#xff0c;sql代码是("$id")这样写的了。直接采取闭…
阅读更多...
强化学习——马尔可夫决策过程的理解

强化学习——马尔可夫决策过程的理解

目录 一、马尔可夫决策过程1.策略2.状态价值函数3.动作价值函数4.贝尔曼期望方程 参考文献 一、马尔可夫决策过程 马尔可夫决策过程&#xff08;MDP&#xff09;是马尔可夫奖励过程&#xff08;MRP&#xff09;的扩展&#xff0c;它引入了“动作”这一外界的影响因素&#xff0…
阅读更多...
翻译新选择！除了在线翻译百度，还有这三款宝藏工具等你发现

翻译新选择！除了在线翻译百度，还有这三款宝藏工具等你发现

咱们来聊聊现在世界变成一个“大家庭”的事儿。现在&#xff0c;世界各地的人们交流越来越多&#xff0c;语言不通不再是障碍了&#xff01;翻译工具就像超级护照&#xff0c;帮我们轻松跨越语言障碍。说到翻译&#xff0c;百度翻译真的很有名&#xff0c;速度快&#xff0c;翻…
阅读更多...
JAVA中的线程池说明一

JAVA中的线程池说明一

系列文章 JAVA中的线程池说明一 JAVA中的线程池说明二 目录 1.为什么需要线程池? 2.什么是线程池? 3.标准库中的线程池 4.实现自定义线程池 1.为什么需要线程池? 线程的存在意义在于解决并发编程中进程开销过大的问题&#xff0c;因此引入了线程&#xff0c;也被称为…
阅读更多...
【Hot100】LeetCode—74. 搜索二维矩阵

【Hot100】LeetCode—74. 搜索二维矩阵

原题链接&#xff1a; 74. 搜索二维矩阵 1- 思路 二分 ① 实现一个二分函数② 对每行数组进行二分 2- 实现 ⭐74. 搜索二维矩阵——题解思路 class Solution {public boolean searchMatrix(int[][] matrix, int target) {for(int[] m:matrix){if(binarySearch(m,target)){re…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023