• Ajax：万字总结精读笔记，学懂Ajax看这一篇就够了

    一、了解Ajax

    • Ajax 的全称是 Asynchronous Javascript And XML（异步 JavaScript 和 XML）
    • 通俗的理解：在网页中利用 XMLHttpRequest 对象和服务器进行数据交互的方式，就是Ajax
    • 如：
    1. 用户名检测：注册用户时，通过 ajax 的形式，动态检测用户名是否被占用
    2. 搜索提示：当输入搜索关键字时，通过 ajax 的形式，动态加载搜索提示列表
    3. 数据分页显示：当点击页码值的时候，通过 ajax 的形式，根据页码值动态刷新表格的数据
    4. 数据的增删改查：数据的添加、删除、修改、查询操作，都需要通过 ajax 的形式，来实现数据的交互

    Ajax 运行原理

    Ajax 相当于浏览器发送请求与接收响应的代理人，以实现在不影响用户浏览页面的情况下，局部更新页面数据，从而提高用户体验。

    在这里插入图片描述

    二、Ajax基础运用

    2.1 Ajax 的实现步骤

    1. 创建 Ajax 对象
    var xhr = new XMLHttpRequest();

    • 1
    1. 告诉 Ajax 请求地址以及请求方式
    // xhr.open('method', 'url')
xhr.open('get', 'http://www.example.com');

    • 1
    • 2
    1. 发送请求
    xhr.send();

    • 1
    1. 获取服务器端给与客户端的响应数据
     xhr.onload = function () {
     console.log(xhr.responseText);
 }

    • 1
    • 2
    • 3

    2.2 服务器端响应的数据格式

    • 在真实的项目中，服务器端大多数情况下会以 JSON 对象作为响应数据的格式
    • 当客户端拿到响应数据时，要将 JSON 数据和 HTML 字符串进行拼接，然后将拼接的结果展示在页面中
    • 在 http 请求与响应的过程中，无论是请求参数还是响应内容，如果是对象类型，最终都会被转换为对象字符串进行传输
    JSON.parse() 	// 将 json 字符串转换为json对象
xhr.onload = function () {
    var responseText = JSON.parse(xhr.responseText)
    console.log(responseText);
}

    • 1
    • 2
    • 3
    • 4
    • 5

    2.3 get请求/post请求带参数

    GET请求

    //get.html
btn.onclick = function () {	
   	// 创建ajax对象
   	var xhr = new XMLHttpRequest();
   	// 获取用户在文本框中输入的值
   	var nameValue = username.value;
   	var ageValue = age.value;
   	// 拼接请求参数
   	var params = 'username=' + nameValue + '&age=' + ageValue;
   	// 配置ajax对象
   	xhr.open('get', 'http://localhost:3000/test?' + params);
   	// 发送请求
   	xhr.send();
   	// 获取服务器端响应的数据
   	xhr.onload = function () {
   		console.log(xhr.responseText)
   	}
   }
//app.js
app.get('/test', (req, res) => {
   res.setHeader('Access-Control-Allow-Origin','*'); 
   res.send(req.query);
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    POST请求

    //post.html
btn.onclick = function () {	
		// 创建ajax对象
		var xhr = new XMLHttpRequest;
		//要加上`xhr.setRequestHeader('Content-Type', '可变');`
		xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
		// 获取用户在文本框中输入的值
		var nameValue = username.value;
		var ageValue = age.value;
		// 拼接请求参数
		var params = 'username=' + nameValue + '&age=' + ageValue;
		// 配置ajax对象
		xhr.open('get', 'http://localhost:3000/test');
		// 发送请求
		xhr.send();
		// 获取服务器端响应的数据
		xhr.onload = function () {
			console.log(xhr.responseText)
		}
	}
//app.js
app.post('/test', (req, res) => {
	//解决跨域问题
	res.setHeader('Access-Control-Allow-Origin','*');
	res.send(req.query);
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    2.4 设置请求参数格式的类型（post请求必须要设置）

    1. application/x-www-form-urlencoded
      name=zhangsan&age=20&sex=男
    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');

    • 1
    1. application/json
      {name: 'zhangsan', age: '20', sex: '男'}
    xhr.setRequestHeader('Content-Type', 'application/json');
// JSON.stringify() 将json对象转换为json字符串
// 发送请求格
xhr.send(JSON.stringify({name: 'lisi', age:50}));

//app.js
const bodyParser = require('body-parser');
app.use(bodyParser.json());
app.post('/post', (req, res) => {
	res.setHeader('Access-Control-Allow-Origin','*'); 
	res.send(req.body);
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    注意： get 请求是不能提交 json 对象数据格式的，传统网站的表单提交也是不支持 json 对象数据格式的。

    2.6* 获取服务器端的响应（现在很少使用）

    在创建ajax对象，配置ajax对象，发送请求，以及接收完服务器端响应数据，这个过程中的每一个步骤都会对应一个数值，这个数值就是ajax状态码。
    0：请求未初始化(还没有调用open())
    1：请求已经建立，但是还没有发送(还没有调用send())
    2：请求已经发送
    3：请求正在处理中，通常响应中已经有部分数据可以用了
    4：响应已经完成，可以获取并使用服务器的响应了

     xhr.readyState // 获取Ajax状态码

		var xhr = new XMLHttpRequest();

		// 0 已经创建了ajax对象 但是还没有对ajax对象进行配置
		console.log(xhr.readyState);
		xhr.open('get', 'http://localhost:3000/readystate');
		
		// 1 已经对ajax对象进行配置 但是还没有发送请求
		console.log(xhr.readyState);

		// 当ajax状态码发生变化的时候出发
		xhr.onreadystatechange = function() {
			// 2 请求已经发送了
			// 3 已经接收到服务器端的部分数据了
			// 4 服务器端的响应数据已经接收完成
			console.log(xhr.readyState);
			// 对ajax状态码进行判断 如果状态码的值为4就代表数据已经接收完成了
			if (xhr.readyState == 4) {
				console.log(xhr.responseText);
			}
		} 

		xhr.send();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    两种获取服务器端响应方式的区别
    在这里插入图片描述

    2.7 解决Ajax重复请求的问题（节流阀）

    //增加变量，用于判断是否正在发送Ajax请求
let isSending = false;
btn.onclick = function(){
	xhr = new XMLHttpRequest();
	//改为true，表示正在发送请求
	isSending = true;
	xhr.open("GET",'http://127.0.0.1:3000')
	xhr.send();
	xhr.onreadystatechange = function(){
		if(xhr.readyState === 4){
			isSending = false;;
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    2.8 Ajax 错误处理

    1. 网络畅通，服务器端能接收到请求，服务器端返回的结果不是预期结果。
      可以判断服务器端返回的状态码，分别进行处理。xhr.status 获取http状态码
    2. 网络畅通，服务器端没有接收到请求，返回404状态码。
      检查请求地址是否错误。
    3. 网络畅通，服务器端能接收到请求，服务器端返回500状态码。
      服务器端错误，找后端程序员进行沟通。
    4. 网络中断，请求无法发送到服务器端。
      会触发xhr对象下面的onerror事件，在onerror事件处理函数中对错误进行处理。

    2.9* 低版本 IE 浏览器的缓存问题

    • 问题：在低版本的 IE 浏览器中，Ajax 请求有严重的缓存问题，即在请求地址不发生变化的情况下，只有第一次请求会真正发送到服务器端，后续的请求都会从浏览器的缓存中获取结果。即使服务器端的数据更新了，客户端依然拿到的是缓存中的旧数据
    • 解决方案：在请求地址的后面加请求参数，保证每一次请求中的请求参数的值不相同。
     xhr.open('get', 'http://www.example.com?t=' + Math.random());

    • 1

    2.10 Ajax 异步编程

    同步

    • 一个人同一时间只能做一件事情，只有一件事情做完，才能做另外一件事情
    • 落实到代码中，就是上一行代码执行完成后，才能执行下一行代码，即代码逐行执行

    异步

    • 一个人一件事情做了一半，转而去做其他事情，当其他事情做完以后，再回过头来继续做之前未完成的事情。
    • 落实到代码上，就是异步代码虽然需要花费时间去执行，但程序不会等待异步代码执行完成后再继续执行后续代码，而是直接执行后续代码，当后续代码执行完成后再回头看异步代码是否返回结果，如果已有返回结果，再调用事先准备好的回调函数处理异步代码执行的结果
     console.log('before');
 setTimeout(
    () => { console.log('last');
 }, 2000);
 console.log('after');
 //先输出after，再输出last

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    三、*模板引擎

    作用： 使用模板引擎提供的模板语法，可以将数据和 HTML 拼接起来。
    官方地址： https://aui.github.io/art-template/zh-cn/index.html
    安装： npm install art-template --save
    下载： template-web.js
    打开网页复制源代码，保存到本地重名为template-web.js即可
    个人感觉： 没啥作用，用模板字符串效果一样

    <!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>Document</title>
	<!-- 1. 将模板引擎的库文件引入到当前页面 -->
	<script src="/template-web.js"></script>
</head>
<body>
	<div id="container"></div>
	
	<!-- 2.准备art-template模板 -->
	<script type="text/html" id="tpl">
	// 5. 通过模板语法告诉模板引擎，数据和html字符串要如何拼接 
		<h1>{{username}} {{age}}</h1>
	</script>
	
	<script type="text/javascript">
		// 3.告诉模板引擎将那个数据和哪个模板进行拼接
		// 1) 模板id 2)数据 对象类型
		// 方法的返回值就是拼接好的html字符串
		var html = template('tpl', {username: 'zhangsan', age: 30});
		// 4. 将拼接好的html字符串添加到页面中
		document.getElementById('container').innerHTML = html;
	</script>
</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    效果：
    在这里插入图片描述

    四、Format

    4.1 FormData 对象的作用

    • 模拟HTML表单，相当于将HTML表单映射成表单对象，自动将表单对象中的数据拼接成请求参数的格式
    • 异步上传二进制文件

    4.2 FormData 对象的使用

    1. 准备 HTML 表单
    <form id="form">
     <input type="text" name="username" />
     <input type="password" name="password" />
     <input type="button"/>
</form>

    • 1
    • 2
    • 3
    • 4
    • 5
    1. 将 HTML 表单转化为 formData 对象
    var form = document.getElementById('form'); 
var formData = new FormData(form);

    • 1
    • 2
    1. 提交表单对象
    xhr.send(formData);

    • 1
    //html
btn.onclick = function () {
			// 将普通的html表单转换为表单对象
			var formData = new FormData(form);
			// 创建ajax对象
			var xhr = new XMLHttpRequest();
			// 对ajax对象进行配置
			xhr.open('post', 'http://localhost:3000/formData');
			// 发送ajax请求
			xhr.send(formData);
			// 监听xhr对象下面的onload事件
			xhr.onload = function () {
				// 对象http状态码进行判断
				if (xhr.status == 200) {
					console.log(xhr.responseText);
				}
			}
		}
//app.js
app.post('/formData', (req, res) => {
	// 创建formidable表单解析对象
	const form = new formidable.IncomingForm();
	// 解析客户端传递过来的FormData对象
	form.parse(req, (err, fields, files) => {
		res.send(fields);
	});
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    注意：

    • Formdata 对象不能用于 get 请求，因为对象需要被传递到 send 方法中，而 get 请求方式的请求参数只能放在请求地址的后面
    • 服务器端 bodyParser 模块不能解析 formData 对象表单数据，我们需要使用 formidable 模块进行解析

    4.3 FormData 对象的实例方法

    1. 获取表单对象中属性的值
      formData.get(‘key’);
    2. 设置表单对象中属性的值
      formData.set(‘key’, ‘value’);
    3. 删除表单对象中属性的值
      formData.delete(‘key’);
    4. 向表单对象中追加属性值
      formData.append(‘key’, ‘value’);

    注意： set 方法与 append 方法的区别是，在属性名已存在的情况下，set 会覆盖已有键名的值，append会保留两个值

    btn.onclick = function () {
			// 将普通的html表单转换为表单对象
			var formData = new FormData(form);

			/*
				get('key') 获取表单对象属性的值
				set('key', 'value') 设置表单对象属性的值
				delete('key') 删除表单对象属性中的值
			*/
		
			console.log(formData.get('username'));

			// 如果设置的表单属性存在 将会覆盖属性原有的值
			formData.set('username', 'itcast');
			formData.append('username', 'itheima');
			// 如果设置的表单属性不存在 将会创建这个表单属性
			formData.set('age', 100);
			// 删除用户输入的密码
			formData.delete('password');

			// 创建ajax对象
			var xhr = new XMLHttpRequest();
			// 对ajax对象进行配置
			xhr.open('post', 'http://localhost:3000/formData');
			// 发送ajax请求
			xhr.send(formData);
			// 监听xhr对象下面的onload事件
			xhr.onload = function () {
				// 对象http状态码进行判断
				if (xhr.status == 200) {
					console.log(xhr.responseText);
				}
			}

			// 创建空的表单对象
			var f = new FormData();
			f.append('sex', '男');
			console.log(f.get('sex'));
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    4.4 FormData 二进制文件上传

    <input type="file" id="file"/>

    • 1
     var file = document.getElementById('file')
// 当用户选择文件的时候
 file.onchange = function () {
     // 创建空表单对象
     var formData = new FormData();
     // 将用户选择的二进制文件追加到表单对象中
     formData.append('attrName', this.files[0]);
     // 配置ajax对象，请求方式必须为post
     xhr.open('post', 'www.example.com');
     xhr.send(formData);
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    FormData 文件上传进度展示

     // 当用户选择文件的时候
 file.onchange = function () {
     // 文件上传过程中持续触发onprogress事件
     xhr.upload.onprogress = function (ev) {
         // 当前上传文件大小/文件总大小 再将结果转换为百分数
         // 将结果赋值给进度条的宽度属性 
         bar.style.width = (ev.loaded / ev.total) * 100 + '%';
     }
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    FormData 文件上传图片即时预览
    在我们将图片上传到服务器端以后，服务器端通常都会将图片地址做为响应数据传递到客户端，客户端可以从响应数据中获取图片地址，然后将图片再显示在页面中

    xhr.onload = function () {
    var result = JSON.parse(xhr.responseText);
    var img = document.createElement('img');
    img.src = result.src;
    img.onload = function () {
        document.body.appendChild(img);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    五、JSONP解决同源问题 以及 服务端解决方案

    • 是一个非官方的跨域解决方案，纯粹凭借程序员的聪明才智开发出来
    • 利用script 标签的跨域能力来发送请求
    • 只支持get请求不支持post请求

    5.1 JSONP的基本使用

    原理：

    1. script的src可以绑定不同源服务器的端口，绑定的对应端口所返回的内容会被传到script标签中作为js代码执行
    2. 在html中定义函数fn()，通过端口返回的结果’fn()'，即可在script中调用该函数
    3. 下例中，在html中定义了函数fn()，并将函数名fn作为回调函数callback的属性，赋到src上，进而作为参数传到端口中
    4. 端口接收到query对象，取出其中callback属性的值，赋到fnName上，并通过拼接字符串的方法拼接上json对象作为参数
    5. 这样传回html的是 ‘fn(({name: “做一只猫”}))’，输出如下：
      在这里插入图片描述
      注意： 记得启动nodemon app.js
    //html
btn.onclick = function(){
	// 动态创建script标签
     var script = document.createElement('script')
     // 对script的src属性赋值
     script.src = 'http://localhost:3000/diff?callback=fn'
     // 将该script添加到页面中
     document.body.appendChild(script)
     // 成功得到返回结果后，为script标签添加onload事件，去除script标签
	script.onload = function () {
		document.body.removeChild(script);
	}
}
function fn(data){
	console.log(data)
}
//js
app.get('/diff', (req,res)=>{
	// 方法1（这是为了讲清楚原理，实际开发中直接用第二种方法）
    // 接受客户端传过来的函数的名称
    const fnName = req.query.callback;
    // 将函数名称对应的函数调用代码返回个客户端
    const result = fnName + '({name: "做一只猫"})'
    // response.setHeader('Access-Control-Allow-Origin','*');
    res.send(result);
    
    // 方法2
    res.jsonp({name: "做一只猫"});
})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    5.2 封装并优化JSONP

    //html
btn.onclick = function () {
	// 将jsonp封装为一个方法，括号里赋一个json对象作为参数
	jsonp({
		// 请求地址
		url: 'http://localhost:3000/diff',
		// 新增1 增加了data属性作为参数传递
		data: {
			name: 'lisi',
			age: 30
		},
		// 新增3 匿名方法，外域访问不到，要修改为全局函数
		success: function (data) {
			console.log(456789)
			console.log(data)
		}
	})
}
		
function jsonp(options) {
	// 动态创建script标签
	var script = document.createElement('script');
	// 新增1 拼接字符串的变量，用于传递参数
	var params = '';
	for (var attr in options.data) {
		//遍历options.data属性，attr为键，options.data[attr]为值，遍历拼接到params上
		params += '&' + attr + '=' + options.data[attr];
	}
	
	// 新增2 每次点击按钮调用访问窗口的函数名都不同，防止因为运行速度的问题，后执行的函数覆盖掉先执行函数的结果
	// 比如：运行了两次函数，但是第一次运行还没结束，就开始了第二次运行，这样第一次运行的结果跟第二次是相同的
	// 用Math.random().获得类似0.124741这样的伪随机数
	// 用toString()方法将其变为字符串
	// 用replace方法将0.124741改为0.124741，再拼接上myJsonp
	// 最终得到 myJsonp0124741
	var fnName = 'myJsonp' + Math.random().toString().replace('.', '');
	
	// 新增3 用window的fnName属性接收sucess方法，使其变为全局函数
	// 注：1 fnName为变量所以不能用.的形式，而要用[]的形式
	// 2 fnName为自定义属性名，改为其他任何属性名都可以
	window[fnName] = options.success;
	
	// 为script标签添加src属性
	// 新增4 src属性多拼接上params字符串作为参数传递  
	script.src = options.url + '?callback=' + fnName + params;	
	
	// 将script标签追加到页面中
	document.body.appendChild(script);
	// 成功得到返回结果后，为script标签添加onload事件，去除script标签
	script.onload = function () {
		document.body.removeChild(script);
	}
}
//app.js
app.get('/diff', (req, res)=>{
	res.jsonp({name: "做一只猫"});
})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    5.3 访问非同源数据 服务器端解决方案

    • 同源政策是浏览器给予Ajax技术的限制，服务器端是不存在同源政策限制
    • 即通过A服务器访问B服务器，拿到数据后再通过A服务器向A浏览器端作响应
      在这里插入图片描述
    • 服务器之间的访问通过 request 模块实现
    npm i request

    • 1
    //html
btn.onclick = function(){
	ajax({
		type: 'get',
		url: 'http://localhost:3001/server',
		success: function(data){
			console.log(data)
		}
	})
}

//app.js
// 引入express框架
const express = require('express');
// 向其他服务器端请求数据的模块
const request = require('request');
// 创建web服务器
const app = express();
app.get('/server', (req, res) => {
	res.setHeader('Access-Control-Allow-Origin','*'); 
	request('http://localhost:3001/cross', (err, response, body) => {
		res.send(body);
	})
});

//我这里request用不了，报500的错误，应该又是什么跨域问题，以后再解决吧

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    六、$.ajax()

    6.1 $.ajax()的基础使用

    html

    <button id="btn">发送请求</button>
<script src="/js/jquery.min.js"></script>
<script>
var params = {name: 'wangwu', age: 300}
$('#btn').on('click', function () {
	$.ajax({
		// 请求方式
		type: 'post',
		// 请求地址
		url: '/user',
		//在发送请求前调用
		beforeSend: function () {
					alert('发送请求前调用')
					//如果用户操作不合规范或密码不正确等情况，则请求不会被发送
					//return false;
		},
		// 向服务器端发送的请求参数
		// name=zhangsan&age=100
		//1 json对线格式传参
		// data: {
		// 	name: 'zhangsan',
		// 	age: 100
		// },
		//2 指定json格式类型要用json字符串格式传参
		data: JSON.stringify(params),
		//2 指定参数的格式类型
		contentType: 'application/json',
		
		// 请求成功以后函数被调用
		success: function (response) {
			// response为服务器端返回的数据
			// 方法内部会自动将json字符串转换为json对象
			console.log(response);
		}
	})
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    6.2 serialize()方法

    <form id="form">
	<input type="text" name="username">
	<input type="password" name="password">
	<input type="submit" value="提交">
</form>
<script src="/js/jquery.min.js"></script>
<script type="text/javascript">
$('#form').on('submit', function () {
	// 将表单内容拼接成字符串类型的参数
	// var params = $('#form').serialize();
	// console.log(params)
	serializeObject($(this));
	//禁止页面自动提交刷新
	return false;
});

// 封装serialize方法，将表单中用户输入的内容转换为对象类型
function serializeObject (obj) {
	// 处理结果对象
	var result = {};
	// [{name: 'username', value: '用户输入的内容'}, {name: 'password', value: '123456'}]
	var params = obj.serializeArray();

	// 循环数组 将数组转换为对象类型
	$.each(params, function (index, value) {
		result[value.name] = value.value;
	})
	// 将处理的结果返回到函数外部
	return result;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    6.3 $.ajax发送JSON请求

    html

    <button id="btn">发送请求</button>
<script src="/jquery.min.js"></script>
<script>
	// 点2 需要事先定义
	function fn (response) {
		console.log(response)
	}
	$('#btn').on('click', function () {
		$.ajax({
			//要有jsonp这个接口名
			url: 'http://localhost:3000/jsonp',
			// 点1 jsonp默认有参数名，但可以进行自定义名称，即向服务器端传递函数名字的参数名称
			//jsonp: 'cb',
			
			// 点2 回调函数声明为自己先前定义的函数（一般不用，用sucess就好）
			//jsonpCallback: 'fn',
			
			// 表示现在要发送的是jsonp请求
			dataType: 'jsonp',
			
			// 点2 原写法
			success: function (response) {
				console.log(response)
			}
		})
	});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    js

    app.get('/jsonp', (req, res) => {
	// 点1 原写法
	res.jsonp({
		name: 'lisi',
		age:50
	})
	
	// 点1
	//onst cb = req.query.cb
	//const data = cb + "({name: 'zhaoliu'})"	
	//res.send(data);	
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    6.4 $.get、$.post的使用

    $('#btn').on('click', function () {
		$.get('/base', 'name=zhangsan&age=30', function (response) {
			console.log(response)
		})
});

    • 1
    • 2
    • 3
    • 4
    • 5
    $('#btn').on('click', function () {
		$.post('/base', function (response) {
			console.log(response)
		})
});

    • 1
    • 2
    • 3
    • 4
    • 5

    6.5 jQuery中Ajax的全局事件

    只要页面中有Ajax请求被发送，对应的全局事件就会被触发

    .ajaxStart()     // 当请求开始发送时触发
.ajaxComplete()  // 当请求完成时触发

    • 1
    • 2

    NProgress

    纳米级进度条，使用逼真的涓流动画来告诉用户正在发生的事情
    官网
    （官网要科学上网才能上的去）

    //引入
<link rel='stylesheet' href='nprogress.css'/>
<script src='nprogress.js'></script>
//使用
NProgress.start();  // 进度条开始运动 
NProgress.done();   // 进度条结束运动

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    实例

    $(document).on('ajaxStart', function(){
	console.log('start')
	NProgress.start()
})
$(document).on('ajaxComplete', function(){
	console.log('done')
	NProgress.done()
})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    七、RESTful风格的API 和 XML基础

    7.1 RESTful风格的API

    传统请求地址回顾

    GET http://www.example.com/getUsers         // 获取用户列表
GET http://www.example.com/getUser?id=1     // 比如获取某一个用户的信息
POST http://www.example.com/modifyUser      // 修改用户信息
GET http://www.example.com/deleteUser?id=1  // 删除用户信息

    • 1
    • 2
    • 3
    • 4

    可以看到没有一个统一的格式标准，接口名都是每个程序员自定义，如删除，有些是delete有些又写成remove

    RESTful API 概述

    一套关于设计请求的规范

    GET：      获取数据
POST：     添加数据
PUT：      更新数据
DELETE：   删除数据

    • 1
    • 2
    • 3
    • 4
    users     =>  /users
articles  =>  /articles 

    • 1
    • 2

    RESTful API 的实现

    GET：		http://www.example.com/users	获取用户列表数据
POST：		http://www.example.com/users	创建(添加)用户数据
GET：		http://www.example.com/users/1	获取用户ID为1的用户信息
PUT：		http://www.example.com/users/1	修改用户ID为1的用户信息
DELETE：	http://www.example.com/users/1 	删除用户ID为1的用户信息

    • 1
    • 2
    • 3
    • 4
    • 5

    7.2 XML基础

    • XML 的全称是 extensible markup language，代表可扩展标记语言
    • XML作用：传输和存储数据
    • HTML作用：展示数据，注重数据外观

    XML DOM 即 XML 文档对象模型，是 w3c 组织定义的一套操作 XML 文档对象的API
    浏览器会将 XML 文档解析成文档对象模型
    html

    <button id="btn">发送请求button>
<div id="container">div>
<script type="text/javascript">
	var btn = document.getElementById('btn');
	var container = document.getElementById('container');

	btn.onclick = function () {
		var xhr = new XMLHttpRequest();
		xhr.open('get', '/xml');
		xhr.send();
		xhr.onload = function () {
			// xhr.responseXML 获取服务器端返回的xml数据
			var xmlDocument = xhr.responseXML;
			//获取title标签中的数据（tilte标签在下方app.js中定义）
			var title = xmlDocument.getElementsByTagName('title')[0].innerHTML;
			container.innerHTML = title;
		}
	}
script>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    js

    app.get('/xml', (req, res) => {
	//指定请求头告诉请求xml文件，一定要加
	res.header('content-type', 'text/xml');
	res.send('消息标题消息内容')
});

    • 1
    • 2
    • 3
    • 4
    • 5

    八、axios 发送 AJAX 请求

    axios 官网

    8.1 GET 请求

    • axios.get(url[, config])
    • 函数返回结果是一个promise对象，用then回调处理
    //baseURL
axios.defaults.baseURL = 'http://127.0.0.1:3000/';
axios.get('axios', {
    // 请求参数
    params: {
        a: 100,
        b: 200
    },
    // 请求头
    headers: {
        name: 'zuoyizhimao',
        age: 200
    }
}).then(value => {
    console.log(value);
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    注：

    1. 请求头不能有中文
    2. 设置了跨域且在设置请求头后报错，可能是axios没能成功设置请求头的问题
      可以参考正确请求头的格式，看看正确设置的请求头应该是什么样子
      再看看解决方法看看能否解决
      目前笔者能力不够，无法重构代码，无法解决，只能先暂时删去headers

    8.2 POST 请求

    • axios.post(url[ ,data[, config]])
    axios.post('axios', {
    // 请求体
    e: 500,
    f: 600
}, {
    // 请求参数
    params: {
        a: 100,
        b: 200
    },
    // 请求头
    headers: {
        c: 300,
        d: 400
    }
}).then(value => {
    console.log(value);
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    8.3 通用方法

    • axios(url[, config])
    axios({
    method: 'POST',
    url: 'server-axios',
    // 请求参数
    params: {
        a: 100,
        b: 200
    },
    // 请求头
    headers: {
        c: 300,
        d: 400
    },
    // 请求体
    data: {
        e: 500,
        f: 600
    },
    // 响应体类型
    dataType: 'json'
}).then(response => {
    console.log(response.status); // 200
    console.log(response.statusText); // OK
    console.log(response.headers); // {content-length: "22", content-type: "text/html; charset=utf-8"}
    console.log(typeof response.data, response.data); // object {name: "Hello axios"}
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    8.4 fetch 函数 发送 AJAX 请求

    fetch('http://127.0.0.1:8000/server-fetch?a=100&b=100', {
    // 请求方法
    method: 'POST',
    // 请求头
    headers: {
        c: 300,
        d: 400
    },
    // 请求体
    body: 'e=500&f=600'
}).then(response => {
    console.log(response);
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    如果我们只想要响应体内容，可以修改then回调

    .then(response => {
    return response.text();
}).then(response => {
    console.log(typeof response, response); // string {"name":"Hello fetch"}
});

    • 1
    • 2
    • 3
    • 4
    • 5

    如果明确响应体内容为 json 字符串，可以按如下修改，将会返回一个 object 对象

    .then(response => {
	return response.json();
}).then(response => {
	console.log(typeof response, response); // object {"name":"Hello fetch"}
});

    • 1
    • 2
    • 3
    • 4
    • 5
  • 相关阅读:
    ESP8266_接入百度物联网核心套件、使用MQTT协议通信
    day06_循环
    第4章 配置集成第3方log4net日志中间件
    X86_64函数调用汇编程序分析
    Java并发基础
    vue面试题（1）
    现代_复习_第1章：行列式
    MVVM 和 MVVMLight简介
    DBA常用命令
    黑马JVM总结（二十六）
  • 原文地址：https://blog.csdn.net/m0_51487301/article/details/125992207