原生Ajax使用详解(ES5)

Posted 2021-09-28 逆风微笑的代码狗

Ajax的实现

// 1. 创建 Ajax 对象
 let xhr = new XMLHttpRequest();
​
// 2. 指定 Ajax 发送请求的方式与路径。参数 1: 请求方法；参数 2: 请求路径。
 xhr.open(\'get\', \'http://localhost:3000/first\');
​
// 3. 发送请求
 xhr.send();
​
// 4. 获取服务器响应到客户端的数据
 xhr.onload = function(){
 console.log(xhr.responseText);
 }

Ajax的实现(服务器端)

// 引入express框架
const express = require(\'express\');
// 路径处理模块
const path = require(\'path\');
// 创建web服务器
const app = express();
// 静态资源访问服务功能
app.use(express.static(path.join(__dirname, \'public\')));
​
// 监听端口
app.listen(3000);
// 控制台提示输出
console.log(\'服务器启动成功\');

处理服务端响应的JSON数据

客户端

// 1. 创建 Ajax 对象

 let xhr = new XMLHttpRequest();
​
// 2. 指定 Ajax 发送请求的方式与路径。参数 1: 请求方法；参数 2: 请求路径。
 xhr.open(\'get\', \'http://localhost:3000/jsonGet\');
​
// 3. 发送请求
 xhr.send();
​
// 4. 获取服务器响应到客户端的数据
 xhr.onload = function(){
 // 将 JSON 字符串转换为 JSON 对象
 console.log(JSON.parse(xhr.responseText));
 }

服务器端

app.get(\'/jsonGet\', (req, res)=>{
 res.send({\'name\': \'Jeff\'});
})

JSON字符串 转换为 JSON对象

JSON.parse(str)

JSON对象 转化为 JSON字符串

JSON.stringify(obj)

GET 请求

// 1. 创建 Ajax 对象
 let xhr = new XMLHttpRequest();
​
// 2. 指定 Ajax 发送请求的方式与路径。参数 1: 请求方法；参数 2: 请求路径。
//xhr.open(\'get\', \'http://localhost:3000/get?name=Jeff&age=20\');
 let params = `http://localhost:3000/get?username=${nameValue}&age=${ageValue}`;
 xhr.open(\'get\', params);
​
// 3. 发送请求
 xhr.send();
​
// 4. 获取服务器响应到客户端的数据
 xhr.onload = function(){
 console.log(xhr.responseText);
 }

**服务器端**

get请求参数获取 **req.query**

app.get(\'/get\', (req, res)=>{
 res.send(req.query);
})

POST请求

// 1. 创建 Ajax 对象
 let xhr = new XMLHttpRequest();
​
// 2. 指定 Ajax 发送请求的方式与路径。参数 1: 请求方法；参数 2: 请求路径。
 xhr.open(\'post\', \'http://localhost:3000/post\');
​
// 3. 设置请求参数格式的类型（POST 请求必须要设置）
 xhr.setRequestHeader(\'Content-Type\', \'application/x-www-form-urlencoded\');
​
// 4. 发送请求
 xhr.send(`username=${nameValue}&age=${ageValue}`);
​
// 5. 获取服务器响应到客户端的数据
 xhr.onload = function(){
 console.log(xhr.responseText);
 }

服务器端

const bodyParser = require(\'body-parser\'); //用于接收客户端传递的参数（req.body）
app.use(bodyParser.urlencoded()); //用于解析application/x-www-form-urlencoded格式的参数
​
app.post(\'/post\', (req, res)=>{
 res.send(req.body);
})

请求参数传递

GET 请求方式

xhr.open(\'get\', \'http://www.example.com?name=zhangsan&age=20\');

POST 请求方式

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

POST请求参数的格式

1. application/x-www-form-urlencoded
2. application/json

// 在请求头中指定 Content-Type 属性的值是 application/json，告诉服务器端当前请求参数的格式是 json
xhr.send({name: \'zhangsan\', age: \'20\', sex: \'男\'});
xhr.send(JSON.stringify({name: \'Jeff\', age: \'20\'}));

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

服务器端

const bodyParser = require(\'body-parser\');        //用于接收客户端传递的参数（req.body）
app.use(bodyParser.json());        //用于解析application/json格式的参数

app.post(\'/post\', (req, res)=>{
    res.send(req.body);
})

Ajax 状态码

• 0：请求未初始化(还没有调用open())
• 1：请求已经建立，但是还没有发送(还没有调用send())
• 2：请求已经发送
• 3：请求正在处理中，通常响应中已经有部分数据可以用了
• 4：响应已经完成，可以获取并使用服务器的响应了

    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();

两种获取服务器端响应方式的区别

区别描述	onload事件	onreadystatechange事件
是否兼容IE低版本	不兼容	兼容
是否需要判断Ajax状态码	不需要	需要
被调用次数	一次	多次

推荐使用 onload事件

Ajax 错误处理

1. 网络畅通，服务器端能接收到请求，服务器端返回的结果不是预期结果。

可以判断服务器端返回的状态码，分别进行处理。xhr.status 获取http状态码

服务器端设置错误状态码

res.status(400).send();        //使用status()

客服端

// xhr.status 获取 http 状态码
    if(xhr.status == 400) {
        console.log(\'请求出错\')
    }

2.网络畅通，服务器端没有接收到请求，返回404状态码。

检查请求地址是否错误。

3.网络畅通，服务器端能接收到请求，服务器端返回500状态码。

服务器端错误，找后端程序员进行沟通。

4.网络中断，请求无法发送到服务器端。

会触发xhr对象下面的onerror事件，在onerror事件处理函数中对错误进行处理。

// 当网络中断时会触发 onerror 事件
    xhr.onerror = function() {
        console.log(\'网络中断，无法发送请求\')
    }

Ajax状态码:

表示Ajax请求的过程状态 ajax对象返回的

Http状态码:

表示请求的处理结果 是服务器端返回的

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

问题：在低版本的 IE 浏览器中，Ajax 请求有严重的缓存问题，即在请求地址不发生变化的情况下，只有第一次请求会真正发送到服务器端，后续的请求都会从浏览器的缓存中获取结果。即使服务器端的数据更新了，客户端依然拿到的是缓存中的旧数据。

解决方案：在请求地址的后面加请求参数，保证每一次请求中的请求参数的值不相同。

xhr.open(\'get\', \'http://www.example.com?t=\' + Math.random());

服务器端

const fs = require(\'fs\');        //引入系统模块，用于读取文件

app.get(\'/cache\', (req, res)=>{
    fs.readFile(\'./test.txt\', (err, result)=>{
        res.send(result);
    }) 
})

FormData对象

FormData 对象的作用

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

<!-- 创建普通的html表单 -->
    <form id="form">
        <input type="text" name="username">
        <input type="password" name="password">
        <input type="button" id="btn" value="提交">
    </form>

    <script type="text/javascript">
        // 获取按钮
        var btn = document.getElementById(\'btn\');
        // 获取表单
        var form = document.getElementById(\'form\');
        // 为按钮添加点击事件
        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);
                }
            }
        }
    </script>

服务器端

// 引入express框架
const express = require(\'express\');
// 路径处理模块
const path = require(\'path\');
//formidable表单解析模块
const formidable = require(\'formidable\');
// 创建web服务器
const app = express();

// 静态资源访问服务功能
app.use(express.static(path.join(__dirname, \'public\')));

app.post(\'/formData\', (req, res) => {
    // 创建formidable表单解析对象
    const form = new formidable.IncomingForm();
    // 解析客户端传递过来的FormData对象
    form.parse(req, (err, fields, files) => {
        res.send(fields);        //fields解析客户端传递过来的FormData对象的数据
    });
});

// 监听端口
app.listen(3000);
// 控制台提示输出
console.log(\'服务器启动成功\');

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

FormData 对象的实例方法

获取表单对象中属性的值

formData.get(\'key\');

设置表单对象中属性的值

formData.set(\'key\', \'value\');
    //如果设置的表单属性存在 将会覆盖属性原有的值
    //如果设置的表单属性不存在 将会创建这个表单属性

删除表单对象中属性的值

formData.delete(\'key\');

向表单对象中追加属性值

formData.append(\'key\', \'value\');

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

// 获取表单
var form = document.getElementById(\'form\');
// 将普通的html表单转换为表单对象
var formData = new FormData(form);

//获取表单对象属性的值
    console.log(formData.get(\'username\'));
//设置的表单属性存在 将会覆盖属性原有的值
    formData.set(\'username\', \'aaa\');
    formData.append(\'username\', \'bbb\');
// 删除用户输入的密码
    formData.delete(\'password\');

FormData 二进制文件上传

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

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

服务器端

// 实现文件上传的路由
app.post(\'/upload\', (req, res) => {
    // 创建formidable表单解析对象
    const form = new formidable.IncomingForm();
    // 设置客户端上传文件的存储路径
    form.uploadDir = path.join(__dirname, \'public\', \'uploads\');
    // 保留上传文件的后缀名字
    form.keepExtensions = true;
    // 解析客户端传递过来的FormData对象
    form.parse(req, (err, fields, files) => {
        // 将客户端传递过来的文件地址响应到客户端
        res.send({
            path: files.attrName.path.split(\'public\')[1]
        });
    });
});

FormData 文件上传进度展示

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

Art-template模板引擎

官方地址： https://aui.github.io/art-template/zh-cn/index.html

使用步骤

下载 art-template 模板引擎库文件并在 HTML 页面中引入库文件

<script src="./js/template-web.js"></script>

准备 art-template 模板

<script id="tpl" type="text/html">
    <div class="box"></div>
</script>

告诉模板引擎将哪一个模板和哪个数据进行拼接

var html = template(\'tpl\', {username: \'zhangsan\', age: \'20\'});

将拼接好的html字符串添加到页面中

document.getElementById(\'container\').innerHTML = html;

通过模板语法告诉模板引擎，数据和html字符串要如何拼接

<script id="tpl" type="text/html">
    <div class="box"> {{ username }} </div>
</script>

使用 JSONP 解决同源限制问题

jsonp 是 json with padding 的缩写，它不属于 Ajax 请求，但它可以模拟 Ajax 请求

将不同源的服务器端请求地址写在 script 标签的 src 属性中

<script src="www.example.com"></script>

服务器端

服务器端响应数据必须是一个函数的调用，真正要发送给客户端的数据需要作为函数调用的参数。

const data = \'fn({name: "张三", age: "20"})\';
res.send(data);

app.get(\'/better\', (req, res) => {
    // 接收客户端传递过来的函数的名称
    //const fnName = req.query.callback;
    // 将函数名称对应的函数调用代码返回给客户端
    //const data = JSON.stringify({name: "张三"});
    //const result = fnName + \'(\'+ data +\')\';
    // setTimeout(() => {
    //     res.send(result);
    // }, 1000)
    res.jsonp({name: \'lisi\', age: 20});
});

客户端

在客户端全局作用域下定义函数 fn

在 fn 函数内部对服务器端返回的数据进行处理

function fn (data) { }

function fn (data) { console.log(data); }

<script>
    function fn(data) {
        console.log("客户端的fn函数被调用了");
        console.log(data);
    }
</script>

<!-- 1.将非同源服务器端的请求地址写在script标签的src属性中 -->

<script src="http://localhost:3001/test"></script>

CORS 跨域资源共享

Node 服务器端设置响应头示例代码

拦截所有请求
    app.use((req, res, next) => {
    // 1.允许哪些客户端访问我
    // * 代表允许所有的客户端访问我
        res.header(\'Access-Control-Allow-Origin\', \'*\')
    // 2.允许客户端使用哪些请求方法访问我
            res.header(\'Access-Control-Allow-Methods\', \'get,post\')
    // 允许客户端发送跨域请求时携带cookie信息
        res.header(\'Access-Control-Allow-Credentials\', true);
        next();
    });

withCredentials属性

在使用Ajax技术发送跨域请求时，默认情况下不会在请求中携带cookie信息。

withCredentials：指定在涉及到跨域请求时，是否携带cookie信息，默认值为false

Access-Control-Allow-Credentials：true 允许客户端发送请求时携带cookie