前端学习笔记二十-Ajax编程

一、Ajax 基础

传统网站中存在的问题

网速慢的情况下，页面加载时间长，用户只能等待
表单提交后，如果一项内容不合格，需要重新填写所有表单内容
页面跳转，重新加载页面，造成资源浪费，增加用户等待时间

Ajax：标准读音 [ˈeɪˌdʒæks] ，中文音译：阿贾克斯
它是浏览器提供的一套方法，可以实现页面无刷新更新数据（在页面不刷新的情况下向服务器发送请求），提高用户浏览网站应用的体验。

Ajax 的应用场景

页面上拉加载更多数据
列表数据无刷新分页
表单项离开焦点数据验证，避免表单整体提交时才发现错误
搜索框输入实时提示文字下拉列表

Ajax 的运行环境

Ajax 技术需要运行在网站环境中才能生效，当前课程会使用Node创建的服务器作为网站服务器。

二、Ajax 运行原理及实现

Ajax 运行原理

传统方式是浏览器端直接向服务器端发起请求，浏览器在发送请求和接收响应期间不能再响应用户的其他操作（比如继续浏览并拉动当前页面）。
而Ajax 相当于浏览器发送请求与接收响应的代理人，帮助浏览器发送请求和接收响应。浏览器就能空闲下来响应用户的其他操作了。以实现在不影响用户浏览页面的情况下，局部更新页面数据，从而提高用户体验。

Ajax 的实现步骤

创建 Ajax 对象

 var xhr = new XMLHttpRequest();

告诉 Ajax 路由请求地址以及请求方式

 xhr.open('get', 'http://www.example.com');

发送请求

 xhr.send();

获取服务器端给与客户端的响应数据，xhr对象接收完服务器端响应的时候，onload事件自动被触发

  xhr.onload = function () {
     console.log(xhr.responseText);
 }

服务器端响应的数据格式

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

 JSON.parse() // 将 json 字符串转换为json对象

请求参数传递

传统网站表单提交

 <form method="get" action="http://www.example.com">
     <input type="text" name="username"/>
     <input type="password" name="password">
 </form>
 <!– http://www.example.com?username=zhangsan&password=123456 -->

GET 请求方式

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

POST 请求方式
POST请求必须明确设置请求参数内容的类型，即Content-Type

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

请求报文

在 HTTP 请求和响应的过程中传递的数据块就叫报文，包括要传送的数据和一些附加信息，这些数据和信息要遵守规定好的格式。

请求参数的格式

application/x-www-form-urlencoded
name=zhangsan&age=20&sex=男
application/json
{name: 'zhangsan', age: '20', sex: '男'}
在请求头中指定 Content-Type 属性的值是 application/json，告诉服务器端当前请求参数的格式是 json。
JSON.stringify() // 将json对象转换为json字符串

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

获取服务器端的响应

Ajax 状态码
在创建ajax对象，配置ajax对象，发送请求，以及接收完服务器端响应数据，这个过程中的每一个步骤都会对应一个数值，这个数值就是ajax状态码。

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

 xhr.readyState // 获取Ajax状态码

onreadystatechange 事件
当 Ajax 状态码发生变化时将自动触发该事件。
因为在请求已经发送后，状态码是不断变化的，因此2、3、4状态都是在这个事件中触发的
在事件处理函数中可以获取 Ajax 状态码并对其进行判断，当状态码为 4 时就可以通过 xhr.responseText 获取服务器端的响应数据了。

 // 当Ajax状态码发生变化时
 xhr.onreadystatechange = function () {
     // 判断当Ajax状态码为4时
     if (xhr.readyState == 4) {
         // 获取服务器端的响应数据
         console.log(xhr.responseText);
     }
 }

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

Ajax 错误处理

网络畅通，服务器端能接收到请求，服务器端返回的结果不是预期结果。
可以判断服务器端返回的状态码，分别进行处理。xhr.status 获取http状态码
网络畅通，服务器端没有接收到请求，返回404状态码(Not Found)。
检查请求地址是否错误。
网络畅通，服务器端能接收到请求，服务器端返回500状态码(Internal Server Error)。
服务器端错误，找后端程序员进行沟通。
网络中断，请求无法发送到服务器端。（可以谷歌调试工具中network中Online改成Offline模拟）
会触发xhr对象下面的onerror事件，在onerror事件处理函数中对错误进行处理。

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

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

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

三、Ajax 异步编程

同步异步概述

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

 console.log('before'); 
 console.log('after');

异步
一个人一件事情做了一半，转而去做其他事情，当其他事情做完以后，再回过头来继续做之前未完成的事情。
落实到代码上，就是异步代码虽然需要花费时间去执行，但程序不会等待异步代码执行完成后再继续执行后续代码，而是直接执行后续代码，当后续代码执行完成后再回头看异步代码是否返回结果，如果已有返回结果，再调用事先准备好的回调函数处理异步代码执行的结果。

 console.log('before');
 setTimeout(
    () => { console.log('last');
 }, 2000);
 console.log('after');

Ajax 封装

问题：发送一次请求代码过多，发送多次请求代码冗余且重复。
解决方案：将请求代码封装到函数中，发请求时调用函数即可。

function ajax (options) {
    // 存储的是默认值
    var defaults = {
        type: 'get',
        url: '',
        data: {},
        header: {
            'Content-Type': 'application/x-www-form-urlencoded'
        },
        success: function () {},
        error: function () {}
    };

    // 使用options对象中的属性覆盖defaults对象中的属性
    Object.assign(defaults, options);

    // 创建ajax对象
    var xhr = new XMLHttpRequest();
    // 拼接请求参数的变量
    var params = '';
    // 循环用户传递进来的对象格式参数
    for (var attr in defaults.data) {
        // 将参数转换为字符串格式
        params += attr + '=' + defaults.data[attr] + '&';
    }
    // 将参数最后面的&截取掉 
    // 将截取的结果重新赋值给params变量
    params = params.substr(0, params.length - 1);

    // 判断请求方式
    if (defaults.type == 'get') {
        defaults.url = defaults.url + '?' + params;
    }

    /*
        {
            name: 'zhangsan',
            age: 20
        }

        name=zhangsan&age=20

     */

    // 配置ajax对象
    xhr.open(defaults.type, defaults.url);
    // 如果请求方式为post
    if (defaults.type == 'post') {
        // 用户希望的向服务器端传递的请求参数的类型
        var contentType = defaults.header['Content-Type']
        // 设置请求参数格式的类型
        xhr.setRequestHeader('Content-Type', contentType);
        // 判断用户希望的请求参数格式的类型
        // 如果类型为json
        if (contentType == 'application/json') {
            // 向服务器端传递json数据格式的参数
            xhr.send(JSON.stringify(defaults.data))
        }else {
            // 向服务器端传递普通类型的请求参数
            xhr.send(params);
        }

    }else {
        // 发送请求
        xhr.send();
    }
    // 监听xhr对象下面的onload事件
    // 当xhr对象接收完响应数据后触发
    xhr.onload = function () {

        // xhr.getResponseHeader()
        // 获取响应头中的数据
        var contentType = xhr.getResponseHeader('Content-Type');
        // 服务器端返回的数据
        var responseText = xhr.responseText;

        // 如果响应类型中包含applicaition/json
        if (contentType.includes('application/json')) {
            // 将json字符串转换为json对象
            responseText = JSON.parse(responseText)
        }

        // 当http状态码等于200的时候
        if (xhr.status == 200) {
            // 请求成功 调用处理成功情况的函数
            defaults.success(responseText, xhr);
        }else {
            // 请求失败 调用处理失败情况的函数
            defaults.error(responseText, xhr);
        }
    }
}

 ajax({ 
     type: 'get',
     url: 'http://www.example.com',
     success: function (data) { 
         console.log(data);
     }
 })

四、客户端使用模板引擎

作用：使用模板引擎提供的模板语法，可以将数据和 HTML 拼接起来。
官方地址： http://aui.github.io/art-template/docs/installation.html

使用步骤

下载 art-template 模板引擎库文件并在 HTML 页面中引入库文件
<script src="./js/template-web.js"></script>
准备 art-template 模板，在script标签内写上type="text/html"，编辑器就会将内部代码当作html来解析，而不是js

 <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>

五、FormData

FormData 对象的作用

模拟传统HTML表单，相当于将HTML表单映射成表单对象，自动将表单对象中的数据拼接成请求参数的格式。（因为ajax请求需要自己拼接请求参数，比较繁琐）
异步上传二进制文件

FormData 对象的使用

准备 HTML 表单

 <form id="form">
     <input type="text" name="username" />
     <input type="password" name="password" />
     <input type="button"/>
</form>

将 HTML 表单转化为 formData 对象，将获取到的表单DOM对象传递到FormData构造函数中

var form = document.getElementById('form'); 
var formData = new FormData(form);

提交表单对象

  xhr.send(formData);

注意：

Formdata 对象不能用于 get 请求，因为对象需要被传递到 send 方法中，而 get 请求方式的请求参数只能放在请求地址的后面。

服务器端 bodyParser 模块不能解析 formData 对象表单数据（它是用来获取传统表单发送post请求的），我们需要使用 formidable 模块进行解析。

FormData 对象的实例方法

获取表单对象中属性的值
formData.get('key');
设置表单对象中属性的值，如果该属性原表单存在，则替换原本提交的值，如该属性表单中不存在则创建并追加到formData对象里。应用举例：追加发布时间为当前时间；修改提交内容的格式
formData.set('key', 'value');
删除表单对象中属性的值，应用举例：用户注册时需要输入两次密码以保证一致，实际只需要一个密码。
formData.delete('key');
向表单对象中追加属性值。应用举例：创建formData空对象时（不传入表单DOM对象），直接追加值。
formData.append('key', 'value');

注意：set 方法与 append 方法的区别是，在属性名已存在的情况下，set 会覆盖已有键名的值，append会保留两个值（但是服务器相同键名只会接收最后一个值）。

FormData 二进制文件上传

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

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

FormData 文件上传进度展示

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

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

六、同源政策

Ajax请求限制

Ajax 只能向自己的服务器发送请求。比如现在有一个A网站、有一个B网站，A网站中的 HTML 文件只能向A网站服务器中发送 Ajax 请求，B网站中的 HTML 文件只能向 B 网站中发送 Ajax 请求，但是 A 网站是不能向 B 网站发送 Ajax请求的，同理，B 网站也不能向 A 网站发送 Ajax请求。

如果两个页面拥有相同的协议、域名和端口，那么这两个页面就属于同一个源，其中只要有一个不相同，就是不同源。
http://www.example.com/dir/page.html
http://www.example.com/dir2/other.html：同源
http://example.com/dir/other.html：不同源（域名不同）
http://v2.www.example.com/dir/other.html：不同源（域名不同）
http://www.example.com:81/dir/other.html：不同源（端口不同）
https://www.example.com/dir/page.html：不同源（协议不同）

同源政策是为了保证用户信息的安全，防止恶意的网站窃取数据。最初的同源政策是指 A 网站在客户端设置的 Cookie，B网站是不能访问的。不然B网站也能通过这个cookie获取该用户在A网站的信息了。
随着互联网的发展，同源政策也越来越严格，在不同源的情况下，其中有一项规定就是无法向非同源地址发送Ajax 请求，如果请求，浏览器就会报错。

使用 JSONP 解决同源限制问题

jsonp 是 json with padding （将json数据填充到函数中）的缩写，它不属于 Ajax 请求，但它可以模拟 Ajax 请求。

将不同源的服务器端请求地址写在 script 标签的 src 属性中，该资源请求返回的必须是合法的JavaScript代码。href、src属于get请求，但因为不是Ajax请求不受同源政策限制。JSON正是利用了这一性质实现跨域。
<script src="www.example.com/test"></script>
比如以下对jQuery的引入，就是典型的向非同源地址请求资源的案例，因此jsonp方案就是利用script标签的这个特性。
<script src=“https://cdn.bootcss.com/jquery/3.3.1/jquery.min.js"></script>
服务器端响应的数据必须是一个函数的调用，真正要发送给客户端的数据需要作为函数调用的参数。script标签请求到后返回的（请求响应内容）就是字符串中的js代码，即函数的调用会立即执行。

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

在客户端全局作用域下定义函数 fn，并且一定要把定义的函数放在引用非同源请求地址的script标签上面。同时在 fn 函数内部对服务器端返回的数据进行处理。
function fn (data) { console.log(data); }

JSONP 代码优化

客户端需要将函数名称传递到服务器端。

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

将 script 请求的发送变成动态请求，即需要发送请求时在页面动态添加script标签。

<script>
    function fn2 (data) {
        console.log('客户端的fn函数被调用了')
        console.log(data);
    }
</script>
<script type="text/javascript">
    // 获取按钮
    var btn = document.getElementById('btn');
    // 为按钮添加点击事件
    btn.onclick = function () {
        // 创建script标签
        var script = document.createElement('script');
        // 设置src属性
        script.src = 'http://localhost:3001/better?callback=fn2';
        // 将script标签追加到页面中
        document.body.appendChild(script);
        // 为script标签添加onload事件
        script.onload = function () {
            // 将body中的script标签删除掉
            document.body.removeChild(script);
        }
    }
</script>

封装 jsonp 函数，方便请求发送。

function jsonp (options) {
    // 动态创建script标签
    var script = document.createElement('script');
    // 拼接字符串的变量
    var params = '';

    for (var attr in options.data) {
        params += '&' + attr + '=' + options.data[attr];
    }
    
    // myJsonp0124741
    var fnName = 'myJsonp' + Math.random().toString().replace('.', '');
    // 它已经不是一个全局函数了
    // 我们要想办法将它变成全局函数
    window[fnName] = options.success;
    // 为script标签添加src属性
    script.src = options.url + '?callback=' + fnName + params;
    // 将script标签追加到页面中
    document.body.appendChild(script);
    // 为script标签添加onload事件
    script.onload = function () {
        document.body.removeChild(script);
    }
}

jsonp({
    // 请求地址
    url: 'http://localhost:3001/better',
    data: {
        name: 'lisi',
        age: 30
    },
    success: function (data) {
        console.log(data)
    }
})

服务器端代码优化之 res.jsonp 方法。

app.get('/better', (req, res) => {
    res.jsonp({name: 'lisi', age: 20});
});

CORS 跨域资源共享

CORS：全称为 Cross-origin resource sharing，即跨域资源共享，它允许浏览器向跨域服务器发送 Ajax 请求，克服了 Ajax 只能同源使用的限制。

如果浏览器检测到发送的请求是跨域的，或自动在请求头加上origin字段，值为当前发送的请求的域信息（当前网站的页面地址：协议域名和端口号）
origin: http://localhost:3000
无论服务器是否同意这次请求，都会返回一个响应头。
这时浏览器会自动判断请求响应头中是否有Access-Control-Allow-Origin字段来得知服务器是否同意这次请求（有则表示同意），这个字段的值通常是当前访问服务器的客户端的原信息或者*（表示允许所有客户端访问这个服务器端），可以理解为这个服务器的白名单。

Access-Control-Allow-Origin: 'http://localhost:3000'
Access-Control-Allow-Origin: '*'

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

 app.use((req, res, next) => {
     res.header('Access-Control-Allow-Origin', '*');
     res.header('Access-Control-Allow-Methods', 'GET, POST');
     next();
 })

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

同源政策是浏览器给予Ajax技术的限制，服务器端是不存在同源政策限制。

所以是用A服务器端向跨域的服务器端B请求数据再响应给A客户端

// 向其他服务器端请求数据的模块，需先下载
const request = require('request');

app.get('/server', (req, res) => {
    request('http://localhost:3001/cross', (err, response, body) => {
        res.send(body);
    })
});

cookie复习

withCredentials属性

在使用Ajax技术发送跨域请求时，默认情况下不会在请求中携带cookie信息。
withCredentials：指定在涉及到跨域请求时，是否携带cookie信息，默认值为false
因此客户端在发送请求前需设置xhr.withCredentials = true;
被跨域服务器端需设置Access-Control-Allow-Credentials：true 来允许客户端发送请求时携带cookie