掘金阅读 ( ) • 2023-05-26 17:07

浏览器事件模型

DOM事件

DOM(文档对象模型)是针对HTML文档和XML文档的一个API。DOM描绘了一个层次化的节点树，允许开发人员添加、移出和修改页面的某一部分。

我们平时打开的一个窗口里面任何一个元素都是所谓的DOM元素。DOM元素上有它定义的各种各样的规范、属性、事件。

const a =<span className="test">{test}</span> //JSX
//如果用对象的方式来表达这样一个元素该如何表达：
const a={
    type:'span',
    props:{
        class:'test'
    },
    children:{
        test
    }
} //AST 抽象语法树
//DOM元素上有它定义的各种各样的规范、属性、事件。
//但是我们不需要关注那么多，我们只需要知道当前的类型、属性是什么

DOM其实是分为三层的：DOM0、DOM1、DOM2

DOM0级事件

假设页面中存在一个 btn 的按钮，并且给 btn 添加一个点击事件：

btn.onclick = function(){
   console.log('this is a click event')
}

事件就是用户或浏览器自身执行的某种操作，如click、load、mouseover等，都是事件的名字，而响应某个事件的函数就被称为事件处理程序。

click事件过程

在上述的例子中，click 事件并没有像其他函数一样，必须要调用才可以执行，click 事件并不确定什么时候发生，而当浏览器发现用户点击该按钮时，浏览器就检测btn.onclick是否有值，如果有，就会执行btn.onclick.call(btn,event)，类似于一个这样的判断：

if(btn.onclick && btn.onclick())
//btn后面就算没有.onclick，直接btn，它也不会报错
//所以此时的.onclick就类似于hook的一个钩子

此时函数执行，call() 方法接收两个参数，第一个指向调用当前方法的对象，也就是this。
需要注意的是，指定的 this 值并不一定是该函数执行时真正的this值，如果这个函数处于非严格模式下，则指定为 null 和 undefined 的 this 值会自动指向全局对象(浏览器中就是window对象)，同时值为原始值(数字，字符串，布尔值)的 this 会指向该原始值的自动包装对象。
另一个参数则是事件对象 event，该对象也可以通过 arguments[0] 来访问，它包含了事件相关的所有信息，如本例子中，则包含了点击事件的全部信息。可以通过给函数传参来获取事件信息。

btn.onclick = function(e){
   console.log('this is a click event');
   console.log(e);  //  事件对象
    
}

但是在 IE 中，在使用 DOM0 级方法添加事件处理程序时，event 是作 window 对象的一个属性而存在的。此时访问事件对象需要通过 window.event。

btn.onclick = function(){
   console.log(window.event);  //  IE中事件对象
}

在 DOM0级中，如果想要实现一个对象绑定多个函数，可以这样实现：

function fn1(){
    // do something
}
function fn2(){
    // do something
}
btn.onclick = function(e){
  fn1.call(this.xxx);
  fn2.call(this.yyy);
}

DOM1级事件

1级DOM标准中并没有定义事件相关的内容，所以没有所谓的1级DOM事件模型。在2级DOM中除了定义了一些DOM相关的操作之外还定义了一个事件模型，这个标准下的事件模型就是我们所说的2级DOM事件模型。

DOM2级事件

我们默认的DOM事件其实就是DOM2事件
W3C 后来将 DOM1 升级为 DOM2，DOM2级规范开始尝试以一种符合逻辑的方式来标准化 DOM事件。DOM0级可以认为 onclick 是 btn 的一个属性，DOM2级则将属性升级为队列。
DOM2级事件定义了两个方法，用于处理指定和删除事件处理程序的操作，addEventListener()和removeEventListener()，所有的 DOM 节点中都包含这两个方法，它们都接收 3 个参数。

要处理的事件名；
作为事件处理程序的函数；
布尔值，true 代表在捕获阶段调用事件处理程序，false 表示在冒泡阶段调用事件处理程序，默认为 false；

btn.addEventListener('click',function(){
    //应用逻辑
},false)

事件的三个阶段：捕获阶段目标阶段冒泡阶段

当点击鼠标后，会先发生事件的捕获

捕获阶段：
事件从根节点流向目标节点，途中流经各个DOM节点，在各个节点上触发捕获事件，直到达到目标节点。
捕获阶段的主要任务是建立传播路径，在冒泡阶段根据这个路经回溯到文档根节点
目标阶段
事件到达目标节点时，就到了目标阶段，事件在目标节点上被触发
冒泡阶段
事件在目标节点上触发后，不会终止，一层层向上冒，回溯到根节点。

btn.addEventListener('click',function(){
  //  do something
})
btn.addEventListener('click',function(){
  //  do something else
})

由上述代码段可知：addEventListener()将事件加入到监听队列中，当浏览器发现用户点击按钮时，click 队列中依次执行匿名函数1、匿名函数2。

function fn1(){
  consol.log(1)
}
function fn2(){
  consol.log(2)
}
btn.addEventListener('click',fn1)
btn.addEventListener('click',fn2)
//1 2

如果这样写，click 队列中依次fn1.call(btn,event)，fn2.call(btn,event)。

通过addEventListener()添加的事件只能由removeEventListener()来移除，并且removeEventListener()只能移除具名函数，不能移除匿名函数。

//具名函数，故名思意就是有名字的函数，具名函数一般是我们定义的最多的一种
function fn() {
    console.log('我是具名函数')
}
//匿名函数，没有名字的函数
setTimeout(function () {
  console.log('我是匿名函数，我被用于定时器参数传递')
}, 1000)

let arr = [1, 2, 3]
arr.forEach(function (item) {
  console.log('我是匿名函数，我被用于回调函数参数')
})

let box = document.querySelector('#box')
box.onclick = function () {
  console.log('我是匿名函数，我被用于绑定事件')
}
//匿名函数一般被用作: 回调函数参数，事件绑定
//匿名函数不会创建变量，所以说在内存上就不会造成不必要的浪费，并且代码看上去会更加简洁
//但是匿名函数不能重复调用

IE 中 DOM2级事件

IE8 及之前，实现类似addEventListener()和removeEventListener()的两个方法是attachEvent()和detachEvent()，这两个方法接受相同的两个参数。

要处理的事件名；
作为事件处理程序的函数；

IE8 之前的只支持事件冒泡，所以通过attachEvent()添加的事件处理程序只能添加到冒泡阶段。

btn.attachEvent('click',fn1)
btn.attachEvent('click',fn2)

当用户点击时，click 队列依次fn1.call(undefined,undefined)，fn2.call(undefined,undefined)。

类似的 detachEvent()也只能移除具名函数，不能移除匿名函数。

function eventHandler() {
  console.log('xianzao);
}

btn.attachEvent('onClick', eventHandler);
btn.detachEvent('onClick, eventHandler);

兼容处理

我们知道addEventListener()和removeEventListener()是有三个参数的，可以自己定义是在捕获阶段还是冒泡阶段调用事件处理程序。但是在IE8版本里却只能添加到冒泡阶段。
那如果我们需要做到一个标准的处理，可以用到降级：

if(typeof btn.addEventListener === 'function'){
  btn.addEventListener('click',fn);
}else if(typeof btn.attachEvent === 'function'){
  btn.attachEvent('onclick',fn)
}else{
  btn.onclick=function(){
    // do something
  }
}

如果我们要实现一个完整的跨浏览器的一个事件处理的标志，要如何实现：

const EventUtils={ 
    // element是当前元素，可以通过getElementById(id)获取
    // type 是事件类型，一般是click ,也有可能是鼠标、焦点、滚轮事件等等
    // handle 事件处理函数
    addHandler:(element,type,handler) =>{//添加一个事件
        //兼容性处理
        if(element.addEventListener){
          element.addEventListener(type,handler);//click
        }else if(element.attachEvent){
          element.attachEvent(type,handler);
        }else{
            //btn.onclick=function(){}
            element[`on${type}`]=handler
          }
        }
    },
    removeHandler:(element,type,handler) =>{//添加一个事件
        //兼容性处理
        if(element.removeEventListener){
          element.removeEventListener(type,handler);//click
        }else if(element.detachEvent){
          element.detachEvent(type,handler);
        }else{
            //btn.onclick=function(){}
            element[`on${type}`]=null;
          }
        }
    },
}；

// 获取元素
var btn = document.getElementById('btn');
// 定义handler
var handler = function(e) {
  console.log('我被点击了');
}
// 监听事件
EventUtil.addHandler(btn, 'click', handler);
// 移除事件监听
EventUtil.removeHandler(btn, 'click', handler);

//export default EventUtils;

总结

var btn = document.getElementById('btn');

btn.onClick = () => {
  console.log('我是DOM0级事件处理程序');
}
btn.onClick = null;

btn.addEventListener('click', () => {
  console.log('我是DOM2级事件处理程序');
}, false);//匿名函数，通过DOM2添加的匿名函数无法移除
btn.removeEventListener('click', handler, false)//移除失败，addEventListener和removeEventListener的handler必须同名

btn.attachEvent('onclick', () => {
  console.log('我是IE事件处理程序')
})
btn.detachEvent('onclicn', handler);

DOM2级的好处是可以添加多个事件处理程序；DOM0对每个事件只支持一个事件处理程序；
通过DOM2添加的匿名函数无法移除，上面写的例子就移除不了，addEventListener和removeEventListener的handler必须同名；
作用域：DOM0的handler会在所属元素的作用域内运行，IE的handler会在全局作用域运行，this === window；
触发顺序：添加多个事件时，DOM2会按照添加顺序执行，IE会以相反的顺序执行；
跨浏览器的事件处理程序

事件捕获&事件冒泡

事件流描述的是从页面中接收事件的顺序
IE 的事件流是事件冒泡流
而 Netscape Communicator 的事件流是事件捕获流
DOM2级事件规定的事件流包括三个阶段：

事件捕获阶段；
处于目标阶段；
事件冒泡阶段；

首先发生的是事件捕获，为截获事件提供了机会。然后是实际的目标接收到事件。最后一个阶段是冒泡阶段，可以在这个阶段对事件做出响应

<!DOCTYPE html> 
<html> 
    <head> 
        <title>Event Bubbling Example</title> 
    </head> 
    <body> 
        <div id="myDiv">Click Me</div> 
    </body> 
</html>

以此代码段为例，事件捕获时，则点击<div>元素会以下列顺序触发 click 事件：document - > <html> -> <body> -> <div>；
当事件冒泡时，在点击页面中的<div>元素后，click 事件会以如下顺序发生：<div> -> <body> -> <html> -> document；

<div>元素，即被点击的元素，最先触发 click 事件。然后，click 事件沿 DOM 树一路向上，在经过的每个节点上依次触发，直至到达 document 对象。

当处于目标阶段，没有捕获与冒泡之分，执行顺序会按照addEventListener的添加顺序决定，先添加先执行；
使用stopPropagation()取消事件传播 (停止冒泡) 时，事件不会被传播给下一个节点，但是，同一节点上的其他listener还是会被执行；如果想要同一层级的listener也不执行，可以使用stopImmediatePropagation()；

// list 的捕获
$list.addEventListener('click', (e) => {
  console.log('1');
  e.stopPropagation();
}, true)
  
// list 捕获 2
$list.addEventListener('click', (e) => {
  console.log('2');
}, true)

// 1
// 2
//因为绑定的是同一个元素节点：list
//如果将 e.stopPropagation() 改为 e.stopImmediatePropagation()
//输出结果只有1
//因为Event 接口的 stopImmediatePropagation() 方法阻止监听同一事件的其他事件监听器被调用。 
//如果多个事件监听器被附加到相同元素的相同事件类型上，当此事件触发时，它们会按其被添加的顺序被调用。如果在其中一个事件监听器中执行 stopImmediatePropagation() ，那么剩下的事件监听器都不会被调用。

3. preventDefault()只是阻止默认行为，跟JS的事件传播一点关系都没有； 4. 一旦发起了preventDefault()，在之后传递下去的事件里面也会有效果

事件对象

DOM0和DOM2的事件处理程序都会自动传入event对象
IE中的event对象取决于指定的事件处理程序的方法。
IE的handler会在全局作用域运行，this === window，所以在IE中会有window.event、event两种情况，只有在事件处理程序期间，event对象才会存在，一旦事件处理程序执行完成，event对象就会被销毁

event对象里需要关心的两个属性：

target：target永远是被添加了事件的那个元素；
eventPhase：调用事件处理程序的阶段，有三个值
捕获阶段；
处于目标；
冒泡阶段

preventDefault 与 stopPropagation

preventDefault：比如链接被点击会导航到其href指定的URL，这个就是默认行为；
stopPropagation：立即停止事件在DOM层次中的传播，包括捕获和冒泡事件；

IE中对应的属性：

srcElement => target
returnValue => preventDefault()
cancelBubble => stopPropagation()

IE 不支持事件捕获，因而只能取消事件冒泡，但stopPropagation可以同时取消事件捕获和冒泡。
那么我们要怎么通过工具类，实现stopPropagation()和preventDafult，并实现兼容呢？eg:

var EventUtil = {
  addHandler: (element, type, handler) => {
    //详情见 DOM事件 的 兼容处理 部分
  },
  removeHandler: (element, type, handler) => {
    //详情见 DOM事件 的兼容处理部分
  },
  
  // 获取event对象
  getEvent: (event) => {
    return event ? event : window.event;
  },
  // 获取当前目标
  getTarget: (event) => {
    return event.target ? event.target : event.srcElement;
  },
  // 阻止默认行为
  preventDefault: (event) => {
    if (event.preventDefault) {
      event.preventDefault();
    } else {
      event.returnValue = false;
    }
  },
  // 停止传播事件
  stopPropagation: (event) => {
    if (event,stopPropagation) {
      event.stopPropagation()
    } else {
      event.cancelBubble = true;
    }
  }
}

其实这样的内容可以用来解决事件委托问题.

事件委托

事件委托：用来解决事件处理程序过多的问题,把事件委托给别人.
页面结构如下

<ul id="myLinks">
  <li id="goSomewhere">Go somewhere</li>
  <li id="doSomething">Do something</li>
  <li id="sayHi">Say hi</li>
</ul>

按照传统的做法，需要像下面这样为它们添加 3 个事件处理程序。

var item1 = document.getElementById("goSomewhere");
var item2 = document.getElementById("doSomething");
var item3 = document.getElementById("sayHi");
EventUtil.addHandler(item1, "click", function(event){
    location.href = "http://www.xianzao.com";
});
EventUtil.addHandler(item2, "click", function(event){
    document.title = "I changed the document's title";
});
EventUtil.addHandler(item3, "click", function(event){
    alert("hi");
});

如果在一个复杂的 Web 应用程序中，对所有可单击的元素都采用这种方式，那么结果就会有数不清的代码用于添加事件处理程序。此时，可以利用事件委托技术解决这个问题。使用事件委托，只需在 DOM 树中尽量最高的层次上添加一个事件处理程序
如下例所示: 用上述提及的兼容处理EventUtil来实现事件委托操作

import EventUtils from'./xxxx.js';//xxxx.js 工具类

var list = document.getElementById("myLinks");//获取当前父元素
//我们 绑定元素 不再是绑定到 item 上了,而是绑定到父元素 此处ul 上
EventUtil.addHandler(list, "click", function(event) {//绑定事件方法
  //捕获子元素 li
  event = EventUtil.getEvent(event);获取当前事件
  var target = EventUtil.getTarget(event);//获取当前元素
  
  switch(target.id) {
      case "doSomething":
          document.title = "I changed the document's title";
          break;
      case "goSomewhere":
          location.href = "http://www.wrox.com";
          break;
      case "sayHi": 9 alert("hi");
        break; 
  }
}

子节点的点击事件会冒泡到父节点，并被这个注册事件处理

最适合采用事件委托技术的事件包括 click、mousedown、mouseup、keydown、keyup 和 keypress。
虽然 mouseover 和 mouseout 事件也冒泡，但要适当处理它们并不容易，而且经常需要计算元素的位置。可以考虑为 document 对象添加一个事件处理程序，用以处理页面上发生的某种特定类型的事件，需要跟踪的事件处理程序越少，移除它们就越容易（移除事件处理程序关乎内存和性能）。
只要是通过 onload 事件处理程序添加的东西，最后都要通过 onunload 事件处理程序将它们移除。

浏览器请求

在浏览器端发送网络请求的常见方式：
1.ajax；
2.fetch；
3.axios；

ajax

“异步(async)的 Js 和 XML”,ajax是js异步技术的术语。
Ajax 是一个技术统称，是一个概念模型，它囊括了很多技术，并不特指某一技术，它很重要的特性之一就是让页面实现局部刷新。
特点：局部刷新页面，无需重载整个页面。
简单来说，Ajax 是一种思想，XMLHttpRequest 只是实现 Ajax 的一种方式。其中 XMLHttpRequest 模块就是实现 Ajax 的一种很好的方式。

手写ajax

建议先阅读MDN利用 XMLHttpRequest 模块实现 Ajax。

创建异步对象

let xmlHttp;
if (window.XMLHttpRequest) {
  // code for IE7+, Firefox, Chrome, Opera, Safari
  xmlHttp = new XMLHttpRequest();
} else {
  // code for IE6, IE5
  xmlHttp = new ActiveXObject('Microsoft.XMLHTTP');
}

通过XMLHttpRequest构造函数创建一个异步对象xmlhttp, IE6, IE5 使用ActiveXObject创建，创建的这个异步对象上有很多属性和方法，常用的有：

onreadystatechange：监听异步对象请求状态码readyState的改变，每当readyState改变时，就会触发onreadystatechange事件；
readyState：请求状态码
readyState表示异步对象目前的状态，状态码从0到4：
0: 表示请求未初始化(还未创建请求)，还没有调用 open()；
1: 服务器连接已建立，但是还没有调用 send()(传输数据)；
2: 请求已接收，正在处理中（通常现在可以从响应中获取内容头）；
3: 请求处理中，通常响应中已有部分数据可用了(部分请求可以接收到)，没有全部完成；
4: 当readyState状态码为4时，表示请求已完成；此阶段确认全部数据都已经解析完毕，可以通过异步对象的属性获取对应数据；
status：http状态码
http状态码表示成功的http状态码有:

xmlHttp.status >= 200 && xmlHttp.status < 300 || xmlHttp.status == 304

responseText：后台返回的字符串形式的响应数据；
responseXML：后台返回的XML形式的响应数据；

设置请求方式和请求地址

创建异步对象之后，通过open()方法设置ajax请求方式和请求地址格式： xmlHttp.open("GET/POST","ajax-get.txt",true)
第一个参数：请求的类型；GET 还是 POST；
第二个参数：表示请求的文件的地址url；
第三个参数：设置请求方法是不是异步async，true为异步， false为同步。AJAX存在的意义就是发异步请求，所以第三个参数永远传true；

注意：有个问题，就是IE中的缓存问题
在IE浏览器中，如果通过Ajax发送GET请求，那么IE浏览器认为，同一个URL只有一个结果，如果地址没有发生变化，它就会把上一次返回的结果，直接返回。这样我们不能实时的拿到变化后的数据。如果要想我们拿到实时数据，必须保证每次的URL都是不一样的，有两种方式：

Math.random()；
new Date().getTime()；

即在请求地址后面拼接上?t=随机数或者1970.01.01至当前的毫秒数 所以在IE中通过ajax发送get请求时，可以设置请求地址为：

xmlHttp.open("GET","ajax-get.txt?t=" + (new Date().getTime()),true);
//或
xmlHttp.open("GET","ajax-get.txt?t=" + Math.random(),true);

发送请求

直接通过异步对象的send()发送请求

xmlHttp.send();

特别注意的是：如果发送POST请求，使用setRequestHeader()来添加HTTP请求头，并在send()方法中传递要发送的数据：

xmlHttp.open("POST","ajax_test.html",true); 
xmlHttp.setRequestHeader("Content-type","application/x-www-form-urlencoded"); 
xmlHttp.send("fname=Henry&lname=Ford");

通过onreadystatechange监听状态变化

当异步对象的readyState发生改变，会触发onreadystatechange函数，当readyState变成为4时，表示当前状态是请求完毕的状态，同时当http的响应码status为200到300之间（包括200和300）或为304时，表示ajax请求成功;当http状态码不是200到300之间的数也不是304时，表示请求不成功

//监听状态变化
xmlHttp.onreadystatechange = () => {
 // 判断当前状态改变是请求完毕的状态吗
 if (xmlHttp.readyState === 4) {
    if (xmlHttp.status >= 200 && xmlHttp.status < 300 || xmlHttp.status == 304) {
        console.log("成功的接收到服务器返回的数据");
    }else{
        console.log("不成功！");
    }   
 }
}

手写示例

ajax((
    type: 'GET',
    url: 'http://localhost:3000/poets',
    timeout:1000,
    success:data =>{
        console.log('success',data);
    },
    data:{//参数
        test:1,
        name:2
    }
    error:err => {
        console.log('error',err);
    },
));

如果上述部分是我们最后期望得到的请求,那我们要如何实现呢?

const ajax=option => {
    //type, url, data, timeout, success, error将所有参数换成一个对象{}

    //  0.将对象转换成字符串
    
    //传递多个参数，需要保持传递顺序。
    //可以改写成传递的是一个对象；因为对象里面的值，传递的是一个对象.就不用考虑先后顺序
    //里面用的参数通过对象名.属性名的形式获取；
    const objToString =data => {
        data.t =new Date().getTime();
        let res=[];
        for(let key in data){ 
             //URL当中只能出现字母 数字 下划线和ASCII码，不能出现中文，
             //所以需要将key和value转成非中文的形式
             //可以使用encodeURIComponent()转码；
            res.push(encodeURIComponent(key) + '=' + encodeURIComponent(data[key]));
        }
        return res.join('&'); //test=1&name=2
    };

    let str = objToString(option.data || {});

    var xmlHttp,timer;
    
    // 1.创建异步对象
    if(window.XMLHttpRequest){
        xmlHttp=new XMLHttpRequest();
    }else if(xmlHttp){
        xmlHttp =new ActiveXObject('Microsoft.xmlHTTP');//IE5 IE6
    }
    
    // 2.设置请求方式和请求地址；
    //判断类型 get 还是 post
    if(option.type.toLowerCase() === 'get'){//传递请求类型的区分大小写，jQuery官方的是大小写都可以；解决方案是可以使用`toLowerCase()`或者`toUpperCase()`将类型转成大写或小写再对比
        xmlHttp.open(option.type,option.url + '?t=' + str,true);
        xmlHttp.send();// 3.发送请求
    }else{
        xmlHttp.open(option.type,option.url + '?t=' + str,true);
        xmlHttp.setRequestHeader('Content-type','application.x-www-form-urlencoded');
        //在post请求中，必须在open和send之间添加HTTP请求头:setRequestHeader(header,value);
        xmlHttp.send(str);
    }
    
    // 4.监听状态的变化；
    xmlHttp.onreadystatechange=function(){
        clearInterval(timer);
        if(xmlHttp.status >=200 && xmlHttp.status<300 || xmlHttp.status== 304){//  5.处理返回的结果；
            option.success(xmlHttp.responseText);//成功后回调；
        }else{
            option.error(xmlHttp.responseText);//失败后回调；
        }
    };
    //超时处理
    if(option.timer){
        timer = setInterval(function(){
            xmlHttp.abort();
            clearInterval(time);//中断请求 清空
        },option.timeout);
    }
}

-> 为什么需要设置超时时间
当我们利用我们的ajax发送一个请求到远处服务器时，我们需要等待远程服务器去响应我们的请求，等待远程服务器将响应的结果返回给我们，但是这个响应的速度是不确定的，因为响应的速度是由本地网络和远程服务器的网速等共同决定的，所以我们不可能一直等待服务器的响应。

实现Upload的request封装

针对fusion中 Upload组件，实现自定义请求的封装。

function customRequest(option) {
    /* coding here */
    return {abort() {/* coding here */}};
}

<Upload request={customRequest}/>

其中，customRequest的实现如下：

/**
 * clone from https://github.com/react-component/upload/blob/master/src/request.js
 */

function getError(option, xhr, msg) {
    msg = msg || `cannot post ${option.action} ${xhr.status}'`;
    const err = new Error(msg);
    err.status = xhr.status;
    err.method = option.method;
    err.url = option.action;
    return err;
}

function getBody(xhr) {
    const text = xhr.responseText || xhr.response;
    if (!text) {
        return text;
    }

    try {
        return JSON.parse(text);
    } catch (e) {
        return text;
    }
}

// option {
//  onProgress: (event: { percent: number }): void,
//  onError: (event: Error, body?: Object): void,
//  onSuccess: (body: Object): void,
//  data: Object,
//  filename: String,
//  file: File,
//  withCredentials: Boolean,
//  action: String,
//  headers: Object,
//  method: String
//  timeout: Number
// }
export default function upload(option) {
    const xhr = new XMLHttpRequest();

    if (option.onProgress && xhr.upload) {
        xhr.upload.onprogress = function progress(e) {
            if (e.total > 0) {
                e.percent = (e.loaded / e.total) * 100;
            }
            option.onProgress(e);
        };
    }

    const formData = new FormData();

    if (option.data) {
        Object.keys(option.data).forEach(key => {
            formData.append(key, option.data[key]);
        });
    }
    if (option.file instanceof Blob) {
        formData.append(option.filename, option.file, option.file.name);
    } else {
        formData.append(option.filename, option.file);
    }

    xhr.onerror = function error(e) {
        option.onError(e);
    };

    xhr.onload = function onload() {
        // allow success when 2xx status
        // see https://github.com/react-component/upload/issues/34
        if (xhr.status < 200 || xhr.status >= 300) {
            return option.onError(getError(option, xhr), getBody(xhr));
        }

        option.onSuccess(getBody(xhr), xhr);
    };

    option.method = option.method || 'POST';
    xhr.open(option.method, option.action, true);

    // In Internet Explorer, the timeout property may be set only after calling the open() method and before calling the send() method.
    // see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/timeout
    const { timeout } = option;

    if (typeof timeout === 'number' && timeout > 0) {
        xhr.timeout = timeout;
        xhr.ontimeout = () => {
            const msg = `Upload abort for exceeding time (timeout: ${timeout}ms)`;
            option.onError(getError(option, xhr, msg), getBody(xhr));
        };
    }

    // Has to be after `.open()`. See https://github.com/enyo/dropzone/issues/179
    if (option.withCredentials && 'withCredentials' in xhr) {
        xhr.withCredentials = true;
    }

    const headers = option.headers || {};

    // when set headers['X-Requested-With'] = null , can close default XHR header
    // see https://github.com/react-component/upload/issues/33
    if (headers['X-Requested-With'] !== null) {
        xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
    }

    for (const h in headers) {
        if (headers.hasOwnProperty(h) && headers[h] !== null) {
            xhr.setRequestHeader(h, headers[h]);
        }
    }
    xhr.send(formData);

    return {
        abort() {
            xhr.abort();
        },
    };
}

总结

可以发现，ajax只是一种异步请求的方式，并不特指某一种具体的实现方式，但随着使用这种方式实现网络请求时内部又包含请求的情况，就会出现回调地狱，这也是XHR的诟病之一，因此，后来才催生了更加优雅的请求方式。

fetch

Fetch 是在 ES6 出现的，它使用了 ES6 提出的 Promise 对象。它是 XMLHttpRequest 的替代品。
有人把它与 Ajax 作比较，其实这是不对的，我们通常所说的 Ajax 是指使用 XMLHttpRequest 实现的 Ajax，所以真正应该和 XMLHttpRequest 作比较。
Fetch 是一个 API，它是真实存在的，它是基于 Promise 的。

建议阅读：MDN
以下内容摘选自：fetch教学

fetch()的功能与 XMLHttpRequest 基本相同，但有三个差异：

fetch使用 Promise，不使用回调函数，因此大大简化了写法，写起来更简洁；
fetch采用模块化设计，API 分散在多个对象上（Response 对象、Request 对象、Headers 对象），更合理一些；相比之下，XMLHttpRequest 的 API 设计并不是很好，输入、输出、状态都在同一个接口管理，容易写出非常混乱的代码；
fetch通过数据流（Stream 对象）处理数据，可以分块读取，有利于提高网站性能表现，减少内存占用，对于请求大文件或者网速慢的场景相当有用。XMLHTTPRequest 对象不支持数据流，所有的数据必须放在缓存里，不支持分块读取，必须等待全部拿到后，再一次性吐出来；

在用法上，fetch()接受一个 URL 字符串作为参数，默认向该网址发出 GET 请求，返回一个 Promise 对象。 它的基本用法如下。

fetch(url).then(...).catch(...)

下面是一个demo，从服务器获取 JSON 数据。

fetch('https://api.github.com/users/ruanyf')
  .then(res => res.json())//转成json
  .then(data => {
      console.log(data);
  )}
  .catch(err => {
      console.log(err);
  )}; 
  //返回的是一个promise 因为fetch本质上是一个promise的执行.

fetch()接收到的res是一个 Stream 对象，res.json()是一个异步操作，取出所有内容，并将其转为 JSON 对象
Promise 可以使用 await 语法改写，使得语义更清晰。

async function getJSON() {
  let url = 'https://api.github.com/users/ruanyf';
  try {
     let res = await fetch(url);
     return await res.json();
  } catch (error) {
     console.log(error);
  }
}

上面示例中，await语句必须放在try...catch里面，这样才能捕捉异步操作中可能发生的错误。

Response (res)

Response 对象的同步属性
fetch()请求成功以后，得到的是一个Response 对象。它对应服务器的 HTTP 回应。

const response = await fetch(url);

Response 包含的数据通过 Stream 接口异步读取，但是它还包含一些同步属性，对应 HTTP 回应的标头信息（Headers），可以立即读取。

async function fetchText() {
  let response = await fetch('/readme.txt');
  console.log(response.status); //HTTP 回应的状态码; 例如200，表示成功请求
  console.log(response.statusText);//HTTP 回应的状态信息; 例如请求成功以后，服务器返回"OK"
}

response.status和response.statusText就是 Response 的同步属性，可以立即读取。

标头信息

Response.ok
Response.ok属性返回一个布尔值，表示请求是否成功，true对应 HTTP 请求的状态码 200 到 299，false对应其他的状态码；
Response.status
Response.status属性返回一个数字，表示 HTTP 回应的状态码（例如200，表示成功请求）；
Response.statusText
Response.statusText属性返回一个字符串，表示HTTP 回应的状态信息（例如请求成功以后，服务器返回"OK"）；
Response.url
Response.url属性返回请求的 URL。如果 URL 存在跳转，该属性返回的是最终 URL；
Response.type
Response.type属性返回请求的类型。可能的值如下：
basic：普通请求，即同源请求；
cors：跨域请求；
error：网络错误，主要用于 Service Worker；
opaque：如果fetch()请求的type属性设为no-cors，就会返回这个值。表示发出的是简单的跨域请求，类似<form>表单的那种跨域请求；
opaqueredirect：如果fetch()请求的redirect属性设为manual，就会返回这个值；
Response.redirected
Response.redirected属性返回一个布尔值，表示请求是否发生过跳转。

判断请求是否成功

fetch()发出请求以后，有一个很重要的注意点：只有网络错误，或者无法连接时，fetch()才会报错，其他情况都不会报错，而是认为请求成功。这就是说，即使服务器返回的状态码是 4xx 或 5xx，fetch()也不会报错（即 Promise 不会变为 rejected状态）。

Response.status
Response.status属性，得到 HTTP 回应的真实状态码，才能判断请求是否成功。

async function fetchText() {
    let response = await fetch('/readme.txt');
    if (response.status >= 200 && response.status < 300) {
        return await response.text();//得到文本字符串
    } else {
        throw new Error(response.statusText);
    }
}

response.status属性只有等于 2xx （200~299），才能认定请求成功。这里不用考虑网址跳转（状态码为 3xx），因为fetch()会将跳转的状态码自动转为 200。

response.ok是否为true

if (response.ok) {
    // 请求成功
} else {
    // 请求失败
}

Response.headers

Response 对象还有一个Response.headers属性，指向一个 Headers 对象，对应 HTTP 回应的所有标头。 Headers 对象可以使用for...of循环进行遍历。

const response = await fetch(url);
for (let \[key, value] of response.headers) { 
    console.log(${key} : ${value});
}
// 或者
for (let \[key, value] of response.headers.entries()) { 
    console.log(${key} : ${value});
}

Headers 对象提供了以下方法，用来操作标头。

Headers.get()：根据指定的键名，返回键值。
Headers.has()：返回一个布尔值，表示是否包含某个标头。
Headers.set()：将指定的键名设置为新的键值，如果该键名不存在则会添加。
Headers.append()：添加标头。
Headers.delete()：删除标头。
Headers.keys()：返回一个遍历器，可以依次遍历所有键名。
Headers.values()：返回一个遍历器，可以依次遍历所有键值。
Headers.entries()：返回一个遍历器，可以依次遍历所有键值对（[key, value]）。
Headers.forEach()：依次遍历标头，每个标头都会执行一次参数函数。

这些方法中，最常用的是response.headers.get()，用于读取某个标头的值。

let response =  await  fetch(url);  
response.headers.get('Content-Type')
// application/json; charset=utf-8

Headers.keys()和Headers.values()方法用来分别遍历标头的键名和键值。

// 键名
for(let key of myHeaders.keys()) {
  console.log(key);
}

// 键值
for(let value of myHeaders.values()) {
  console.log(value);
}

Headers.forEach()方法也可以遍历所有的键值和键名。

let response = await fetch(url);
response.headers.forEach(
  (value, key) => console.log(key, ':', value)
);

读取内容的方法

Response对象根据服务器返回的不同类型的数据，提供了不同的读取方法。

response.text()：得到文本字符串；
response.json()：得到 JSON 对象；
response.blob()：得到二进制 Blob 对象；
response.formData()：得到 FormData 表单对象；
response.arrayBuffer()：得到二进制 ArrayBuffer 对象；

这5个读取方法都是异步的，返回的都是 Promise 对象。必须等到异步操作结束，才能得到服务器返回的完整数据。

response.text()
response.text()可以用于获取文本数据，比如 HTML 文件。

    const response = await fetch('/users.html');
    const body = await response.text();
    document.body.innerHTML = body

response.json()
response.json()主要用于获取服务器返回的 JSON 数据。
response.formData()
response.formData()主要用在 Service Worker 里面，拦截用户提交的表单，修改某些数据以后，再提交给服务器。
response.blob()
response.blob()用于获取二进制文件。

const response = await fetch('flower.jpg');
const myBlob = await response.blob();
const objectURL = URL.createObjectURL(myBlob);

const myImage = document.querySelector('img');
myImage.src = objectURL;

上面示例读取图片文件flower.jpg，显示在网页上。

response.arrayBuffer()
response.arrayBuffer()主要用于获取流媒体文件。

const audioCtx = new window.AudioContext();
const source = audioCtx.createBufferSource();

const response = await fetch('song.ogg');
const buffer = await response.arrayBuffer();

const decodeData = await audioCtx.decodeAudioData(buffer);
source.buffer = buffer;
source.connect(audioCtx.destination);
source.loop = true;

上面示例是response.arrayBuffer()获取音频文件song.ogg，然后在线播放的例子。

Response.clone

Stream 对象只能读取一次，读取完就没了。这意味着，前一节的五个读取方法，只能使用一个，否则会报错。

let text =  await response.text();
let json =  await response.json();  // 报错

上面示例先使用了response.text()，就把 Stream 读完了。后面再调用response.json()，就没有内容可读了，所以报错。
Response 对象提供Response.clone()方法，创建Response对象的副本，实现多次读取。

const response1 = await fetch('flowers.jpg');
const response2 = response1.clone();

const myBlob1 = await response1.blob();
const myBlob2 = await response2.blob();

image1.src = URL.createObjectURL(myBlob1);
image2.src = URL.createObjectURL(myBlob2);

上面示例中，response.clone()复制了一份 Response 对象，然后将同一张图片读取了两次。

Response.body

Response.body属性是 Response 对象暴露出的底层接口，返回一个 ReadableStream 对象，供用户操作。它可以用来分块读取内容，应用之一就是显示下载的进度。

const response = await fetch('flower.jpg');
const reader = response.body.getReader();

while(true) {
  const {done, value} = await reader.read();

  if (done) {
    break;
  }

  console.log(`Received ${value.length} bytes`)
}

response.body.getReader()方法返回一个遍历器。 这个遍历器的read()方法每次返回一个对象，表示本次读取的内容块。 这个对象的done属性是一个布尔值，用来判断有没有读完；value属性是一个 arrayBuffer 数组，表示内容块的内容，而value.length属性是当前块的大小。

定制 HTTP 请求

fetch()的第一个参数是 URL，还可以接受第二个参数，作为配置对象，定制发出的 HTTP 请求

fetch(url, optionObj)

HTTP 请求的方法、标头、数据体都在这个对象里面设置。

POST 请求

const response = await fetch(url, {
  method: 'POST',
  headers: {
    "Content-type": "application/x-www-form-urlencoded; charset=UTF-8",
  },
  body: 'foo=bar&lorem=ipsum',
});

const json = await response.json();

配置对象用到了三个属性。

method：HTTP 请求的方法，POST、DELETE、PUT都在这个属性设置。
headers：一个对象，用来定制 HTTP 请求的标头。
body：POST 请求的数据体。

注意，有些标头不能通过headers属性设置，比如Content-Length、Cookie、Host等等。它们是由浏览器自动生成，无法修改。

提交 JSON 数据

const user =  { name:  'John', surname:  'Smith'  };
const response = await fetch('/article/fetch/post/user', {
  method: 'POST',
  headers: {
   'Content-Type': 'application/json;charset=utf-8'
  }, 
  body: JSON.stringify(user) 
});

标头Content-Type要设成'application/json;charset=utf-8'。因为默认发送的是纯文本，Content-Type的默认值是'text/plain;charset=UTF-8'。

提交表单

const form = document.querySelector('form');

const response = await fetch('/users', {
  method: 'POST',
  body: new FormData(form)
})

文件上传

如果表单里面有文件选择器，可以用前一个例子的写法，上传的文件包含在整个表单里面，一起提交。 另一种方法是用脚本添加文件，构造出一个表单，进行上传， 请看下面的例子。

const input = document.querySelector('input[type="file"]');

const data = new FormData();
data.append('file', input.files[0]);
data.append('user', 'foo');

fetch('/avatars', {
  method: 'POST',
  body: data
});

直接上传二进制数据

fetch()也可以直接上传二进制数据，将 Blob 或 arrayBuffer 数据放在body属性里面。

let blob = await new Promise(resolve =>   
  canvasElem.toBlob(resolve,  'image/png')
);

let response = await fetch('/article/fetch/post/image', {
  method:  'POST',
  body: blob
});

option API

fetch()第二个参数的完整 API 如下：

const response = fetch(url, {
  method: "GET",
  headers: {
    "Content-Type": "text/plain;charset=UTF-8"
  },
  body: undefined,
  referrer: "about:client",
  referrerPolicy: "no-referrer-when-downgrade",
  mode: "cors", 
  credentials: "same-origin",
  cache: "default",
  redirect: "follow",
  integrity: "",
  keepalive: false,
  signal: undefined
});

fetch()请求的底层用的是 Request() 对象的接口，参数完全一样，因此上面的 API 也是Request()的 API。

cache

cache属性指定如何处理缓存。可能的取值如下：

default：默认值，先在缓存里面寻找匹配的请求；
no-store：直接请求远程服务器，并且不更新缓存；
reload：直接请求远程服务器，并且更新缓存；
no-cache：将服务器资源跟本地缓存进行比较，有新的版本才使用服务器资源，否则使用缓存；
force-cache：缓存优先，只有不存在缓存的情况下，才请求远程服务器；
only-if-cached：只检查缓存，如果缓存里面不存在，将返回504错误；

mode

mode属性指定请求的模式。可能的取值如下：

cors：默认值，允许跨域请求；
same-origin：只允许同源请求；
no-cors：请求方法只限于 GET、POST 和 HEAD，并且只能使用有限的几个简单标头，不能添加跨域的复杂标头，相当于提交表单所能发出的请求；

credentials

credentials属性指定是否发送 Cookie。 可能的取值如下：

same-origin：默认值，同源请求时发送 Cookie，跨域请求时不发送；
include：不管同源请求，还是跨域请求，一律发送 Cookie；
omit：一律不发送；

跨域请求发送 Cookie，需要将credentials属性设为include。

fetch('http://another.com', {
  credentials: "include"
});

signal

signal属性指定一个 AbortSignal 实例，用于取消fetch()请求。

keepalive

keepalive属性用于页面卸载时，告诉浏览器在后台保持连接，继续发送数据。一个典型的场景就是，用户离开网页时，脚本向服务器提交一些用户行为的统计信息。这时，如果不用keepalive属性，数据可能无法发送，因为浏览器已经把页面卸载了。

window.onunload = function() {
  fetch('/analytics', {
    method: 'POST',
    body: "statistics",
    keepalive: true
  });
};

redirect

redirect属性指定 HTTP 跳转的处理方法。可能的取值如下：

follow：默认值，fetch()跟随 HTTP 跳转；
error：如果发生跳转，fetch()就报错；
manual：fetch()不跟随 HTTP 跳转，但是response.url属性会指向新的 URL，response.redirected属性会变为true，由开发者自己决定后续如何处理跳转；

integrity

integrity属性指定一个哈希值，用于检查 HTTP 回应传回的数据是否等于这个预先设定的哈希值。比如，下载文件时，检查文件的 SHA-256 哈希值是否相符，确保没有被篡改。

fetch('http://site.com/file', {
integrity: 'sha256-abcdef'
});

referrer

referrer属性用于设定fetch()请求的referer标头。这个属性可以为任意字符串，也可以设为空字符串（即不发送referer标头）。

fetch('/page', {
referrer: ''
});

referrerPolicy

referrerPolicy属性用于设定Referer标头的规则。可能的取值如下：

no-referrer-when-downgrade：默认值，总是发送Referer标头，除非从 HTTPS 页面请求 HTTP 资源时不发送；
no-referrer：不发送Referer标头；
origin：Referer标头只包含域名，不包含完整的路径；
origin-when-cross-origin：同源请求Referer标头包含完整的路径，跨域请求只包含域名；
same-origin：跨域请求不发送Referer，同源请求发送；
strict-origin：Referer标头只包含域名，HTTPS 页面请求 HTTP 资源时不发送Referer标头；
strict-origin-when-cross-origin：同源请求时Referer标头包含完整路径，跨域请求时只包含域名，HTTPS 页面请求 HTTP 资源时不发送该标头；
unsafe-url：不管什么情况，总是发送Referer标头；

fetch cancel

fetch()请求发送以后，如果中途想要取消，需要使用AbortController对象。

let controller = new AbortController(); 
let signal = controller.signal;

fetch(url, { signal: controller.signal });

signal.addEventListener('abort', () => console.log('abort!') );

controller.abort(); // 取消

console.log(signal.aborted); // true

上面示例中，首先新建 AbortController 实例，然后发送fetch()请求，配置对象的signal属性必须指定接收 AbortController 实例发送的信号controller.signal。
controller.abort()方法用于发出取消信号。 这时会触发abort事件，这个事件可以监听，也可以通过controller.signal.aborted属性判断取消信号是否已经发出。下面是一个1秒后自动取消请求的例子。

let controller = new AbortController();
setTimeout(() => controller.abort(), 1000);

try {
  let response = await fetch('/long-operation', {
    signal: controller.signal
  });
} catch(err) {
  if (err.name == 'AbortError') {
    console.log('Aborted!');
  } else {
    throw err;
  }
}

测试

针对json-server服务，只需要执行：

fetch('http://localhost:3000/posts')
  .then(res => res.json())
  .then(data => {
    console.log(data);
  })
  .catch(err => {
    console.log(err);
  });

有兴趣的同学可以参考：fetch polyfill

axios

axios是一个用于网络请求的第三方库，是一个基于Promise 用于浏览器和 nodejs 的 HTTP 客户端，它本身具有以下特征：

从浏览器中创建 XMLHttpRequest；
从 node.js 发出 http 请求；
支持 Promise API；
拦截请求和响应；
转换请求和响应数据；
取消请求；
自动转换JSON数据；
客户端支持防止CSRF/XSRF；

基础使用

Axios 提供了两种不同的形式来发送 HTTP 请求：

方法

axios(config) 方法接收一个对象，这个对象包含了一些对请求的配置， axios 会根据这些配置来发送对应的 HTTP 请求最基本的配置项应该包括：

method 请求的方法（可选值： get , post 等）；
url 请求的地址（必须项）；
data 请求发送的数据（post等请求需要）；

默认的请求方法是get所以如果是get请求可以不设置method

// 发送 POST 请求
axios({
  method: 'post',
  url: '/user/12345',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
});

// 发送 GET 请求（默认的方法）
axios('/user/12345');

请求响应的处理在 then 和 catch 回调中，请求正常会进入 then ，请求异常则会进 catch

// 发送 POST 请求
axios({
  method: 'post',
  url: '/user/12345',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
}).then(res => {
    consloe.log(res)
}).catch(err => {
    console.log(err)
})

请求别名

// 发送GET请求
axios.get('/user?ID=12345')
.then(function (response) {
  console.log(response);
}).catch(function (error) {
  console.log(error);
});

// 发送POST请求
发送post请求
axios.post('/user', {
  firstName: 'Fred',
  lastName: 'Flintstone'
}).then(function (response) {
  console.log(response);
}).catch(function (error) {
  console.log(error);
});

响应数据

其中的 data 是后端返回的数据，一般只需要关注 response 中的 data 字段就行

{
  // `data` 由服务器提供的响应
  data: {},
  // `status` 来自服务器响应的 HTTP 状态码
  status: 200,
  // `statusText` 来自服务器响应的 HTTP 状态信息
  statusText: 'OK',
  // `headers` 服务器响应的头
  headers: {},
   // `config` 是为请求提供的配置信息
  config: {},
 // 'request'
  // `request` is the request that generated this response
  // It is the last ClientRequest instance in node.js (in redirects)
  // and an XMLHttpRequest instance the browser
  request: {}
}

创建实例

可以使用自定义配置新建一个 axios 实例 axios.create([config])：

const instance = axios.create({
  baseURL: 'https://some-domain.com/api/',
  timeout: 1000,
  headers: {'X-Custom-Header': 'foobar'}
});

创建的实例中的 axios() api 改为了 request() api，使用方式是一样的，其他如请求别名等函数，都没有改变以下是实例所拥有的方法

request(config)；
get(url[, config])；
delete(url[, config])；
head(url[, config])；
options(url[, config])；
post(url[, data[, config]])；
put(url[, data[, config]])；
patch(url[, data[, config]])；
axios会把这些方法中的config 会和创建实例时指定的 config 合并到一起使用

拦截器

axios.interceptors.request 请求拦截器 axios.interceptors.response 响应拦截器

// 添加请求拦截器 
axios.interceptors.request.use(
    function (config) {// 在发送请求之前做些什么 
        config.header["Token"] = "xxxx" 
        return config; 
    }, 
    function (error) {// 对请求错误做些什么
        return Promise.reject(error);
    }
);

// 添加响应拦截器 
axios.interceptors.response.use(
    function (response) { // 对响应数据做点什么
        if (response.status === 200){ 
            return response.data 
        } else { 
            return Promise.reject(new Error('error')) 
        } 
    }, 
    function (error) { // 对响应错误做点什么 
        return Promise.reject(error); 
    }
);

如果想要取消拦截器，可以通过使用一个变量来接收设置拦截器时返回的实例，然后使用 eject 来取消拦截器

const myInterceptor = axios.interceptors.request.use(function () {/*...*/});
axios.interceptors.request.eject(myInterceptor);

完整的请求配置

{
   // `url` 是用于请求的服务器 URL
  url: '/user',
  // `method` 是创建请求时使用的方法
  method: 'get', // default
  // `baseURL` 将自动加在 `url` 前面，除非 `url` 是一个绝对 URL。
  // 它可以通过设置一个 `baseURL` 便于为 axios 实例的方法传递相对 URL
  baseURL: 'https://some-domain.com/api/',
  // `transformRequest` 允许在向服务器发送前，修改请求数据
  // 只能用在 'PUT', 'POST' 和 'PATCH' 这几个请求方法
  // 后面数组中的函数必须返回一个字符串，或 ArrayBuffer，或 Stream
  transformRequest: [function (data, headers) {
    // 对 data 进行任意转换处理
    return data;
  }],
  // `transformResponse` 在传递给 then/catch 前，允许修改响应数据
  transformResponse: [function (data) {
    // 对 data 进行任意转换处理
    return data;
  }],
  // `headers` 是即将被发送的自定义请求头
  headers: {'X-Requested-With': 'XMLHttpRequest'},
  // `params` 是即将与请求一起发送的 URL 参数
  // 必须是一个无格式对象(plain object)或 URLSearchParams 对象
  params: {
    ID: 12345
  },
   // `paramsSerializer` 是一个负责 `params` 序列化的函数
  // (e.g. https://www.npmjs.com/package/qs, http://api.jquery.com/jquery.param/)
  paramsSerializer: function(params) {
    return Qs.stringify(params, {arrayFormat: 'brackets'})
  },
  // `data` 是作为请求主体被发送的数据
  // 只适用于这些请求方法 'PUT', 'POST', 和 'PATCH'
  // 在没有设置 `transformRequest` 时，必须是以下类型之一：
  // - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
  // - 浏览器专属：FormData, File, Blob
  // - Node 专属： Stream
  data: {
    firstName: 'Fred'
  },
  // `timeout` 指定请求超时的毫秒数(0 表示无超时时间)
  // 如果请求话费了超过 `timeout` 的时间，请求将被中断
  timeout: 1000,
   // `withCredentials` 表示跨域请求时是否需要使用凭证
  withCredentials: false, // default
  // `adapter` 允许自定义处理请求，以使测试更轻松
  // 返回一个 promise 并应用一个有效的响应 (查阅 [response docs](#response-api)).
  adapter: function (config) {
    /* ... */
  },
 // `auth` 表示应该使用 HTTP 基础验证，并提供凭据
  // 这将设置一个 `Authorization` 头，覆写掉现有的任意使用 `headers` 设置的自定义 `Authorization`头
  auth: {
    username: 'janedoe',
    password: 's00pers3cret'
  },
   // `responseType` 表示服务器响应的数据类型，可以是 'arraybuffer', 'blob', 'document', 'json', 'text', 'stream'
  responseType: 'json', // default
  // `responseEncoding` indicates encoding to use for decoding responses
  // Note: Ignored for `responseType` of 'stream' or client-side requests
  responseEncoding: 'utf8', // default
   // `xsrfCookieName` 是用作 xsrf token 的值的cookie的名称
  xsrfCookieName: 'XSRF-TOKEN', // default
  // `xsrfHeaderName` is the name of the http header that carries the xsrf token value
  xsrfHeaderName: 'X-XSRF-TOKEN', // default
   // `onUploadProgress` 允许为上传处理进度事件
  onUploadProgress: function (progressEvent) {
    // Do whatever you want with the native progress event
  },
  // `onDownloadProgress` 允许为下载处理进度事件
  onDownloadProgress: function (progressEvent) {
    // 对原生进度事件的处理
  },
   // `maxContentLength` 定义允许的响应内容的最大尺寸
  maxContentLength: 2000,
  // `validateStatus` 定义对于给定的HTTP 响应状态码是 resolve 或 reject  promise 。如果 `validateStatus` 返回 `true` (或者设置为 `null` 或 `undefined`)，promise 将被 resolve; 否则，promise 将被 rejecte
  validateStatus: function (status) {
    return status >= 200 && status < 300; // default
  },
  // `maxRedirects` 定义在 node.js 中 follow 的最大重定向数目
  // 如果设置为0，将不会 follow 任何重定向
  maxRedirects: 5, // default
  // `socketPath` defines a UNIX Socket to be used in node.js.
  // e.g. '/var/run/docker.sock' to send requests to the docker daemon.
  // Only either `socketPath` or `proxy` can be specified.
  // If both are specified, `socketPath` is used.
  socketPath: null, // default
  // `httpAgent` 和 `httpsAgent` 分别在 node.js 中用于定义在执行 http 和 https 时使用的自定义代理。允许像这样配置选项：
  // `keepAlive` 默认没有启用
  httpAgent: new http.Agent({ keepAlive: true }),
  httpsAgent: new https.Agent({ keepAlive: true }),
  // 'proxy' 定义代理服务器的主机名称和端口
  // `auth` 表示 HTTP 基础验证应当用于连接代理，并提供凭据
  // 这将会设置一个 `Proxy-Authorization` 头，覆写掉已有的通过使用 `header` 设置的自定义 `Proxy-Authorization` 头。
  proxy: {
    host: '127.0.0.1',
    port: 9000,
    auth: {
      username: 'mikeymike',
      password: 'rapunz3l'
    }
  },
  // `cancelToken` 指定用于取消请求的 cancel token
  // （查看后面的 Cancellation 这节了解更多）
  cancelToken: new CancelToken(function (cancel) {
  })
}

测试