深入浅出axios源码

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

axios('/user/12345');

axios.get('/user', {
    params: {
      ID: 12345
    }
  })
  .then(function (response) {
    console.log(response);
  })
  .catch(function (error) {
    console.log(error);
  })
  .then(function () {
    // always executed
  });

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

axios.request({
  method: 'get',
  url: 'http://bit.ly/2mTM3nY',
  responseType: 'stream'
})
  .then(function (response) {
    response.data.pipe(fs.createWriteStream('ada_lovelace.jpg'))
  });

// 添加实例默认参数
const instance = axios.create({
  baseURL: 'https://some-domain.com/api/',
  timeout: 1000,
  headers: {'X-Custom-Header': 'foobar'}
});

// 添加实例默认参数
instance.defaults.timeout = 2500;

// Add a request interceptor
axios.interceptors.request.use(function (config) {
    // Do something before request is sent
    return config;
  }, function (error) {
    // Do something with request error
    return Promise.reject(error);
  });

// Add a response interceptor
axios.interceptors.response.use(function (response) {
    // Do something with response data
    return response;
  }, function (error) {
    // Do something with response error
    return Promise.reject(error);
  });

axios.post('/user', {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }, {
    headers: {
       // 指定本次请求的头信息
       Content-Type: 'application/x-www-form-urlencoded; charset=utf-8'
    }
})
  .then(function (response) {
    console.log(response);
  })
  .catch(function (error) {
    console.log(error);
  });

client.setRequestHeader('X-Test', 'one');
client.setRequestHeader('X-Test', 'two');
// 最终request header中"X-Test"为: one, two

adapters
	http.js
                 支持node平台发送http请求
	xhr.js
                 支持浏览器端发送ajax请求
cancel
	Cancel.js
                 取消原因的类
	CancelToken.js
                 发起取消请求的类
	isCancel.js
core
	Axios.js
		defaults及interceptors两个实例属性
		request、getUri、delete、get、post等原型方法
	createError.js
		创建Error实例，并返回经过enhanceError方法处理后的Error实例
	dispatchRequest.js
		调用combineURLs方法，返回拼接后的请求URL
		调用transformData方法，通过传入的transformRequest方法处理传入的Data及header
		扁平化头信息、通过merge方法合并config.headers.common、config.headers[config.method]、config.headers的头信息
		通过adapter发起ajax请求
	enhanceError.js
		对传入的Error实例上添加报错时，能够获取到的属性与方法
	interceptorManager.js
                拦截器构造函数、包含use、eject、forEach方法
	mergeConfig.js
                合并config
	settle.js
		校验返回状态码，// 如果没有validateStatus方法，获取validateStatus方法返回true，则resolve返回值，否则reject
	transformData.js
                转化数据
hlepers
	bind.js
	bindURL.js
	combineURLS.js
		返回拼接baseURL+relativeURL后的URL
	cookies.js
	deprecatedMethod.js
	isAbsoluteURL.js
	isURLSameOrigin.js
	normalizeHeaderName.js
		判断传入的header头属性是否规范，如Accept、Content-Type，如果不规范，则添加规范属性，删除不规范属性key
	parseHeaders.js
	spread.js
axios.js
	通过createInstance创建一个axios实例，并暴露出去
	在axios这个实例上添加了Axios、create、Cancel、CancelToken、all、spread方法
defaults.js
	默认参数
utils.js 

// 函数绑定上下文
function bind(fn, thisArg) {
  return function wrap() {
    var args = new Array(arguments.length);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i];
    }
    return fn.apply(thisArg, args);
  };
};

/**
 * 自定义forEach，允许遍历数组跟对象
 */
function forEach(obj, fn) {
  // Don't bother if no value provided
  if (obj === null || typeof obj === 'undefined') {
    return;
  }

  // Force an array if not already something iterable
  if (typeof obj !== 'object') {
    /*eslint no-param-reassign:0*/
    obj = [obj];
  }

  if (isArray(obj)) {
    // Iterate over array values
    for (var i = 0, l = obj.length; i < l; i++) {
      fn.call(null, obj[i], i, obj);
    }
  } else {
    // Iterate over object keys
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        fn.call(null, obj[key], key, obj);
      }
    }
  }
}

/**
*  合并对象，将obj2, obj3...后面对象内的属性和方法复制到obj1内，后面覆盖前面的值
 */
function merge(/* obj1, obj2, obj3, ... */) {
  var result = {};
  function assignValue(val, key) {
    if (typeof result[key] === 'object' && typeof val === 'object') {
      result[key] = merge(result[key], val);
    } else {
      result[key] = val;
    }
  }

  for (var i = 0, l = arguments.length; i < l; i++) {
    forEach(arguments[i], assignValue);
  }
  return result;
}

/**
 * 深复制对象，即避免复制对象的引用，如obj1={a: 'a'},obj2={b: {name: 'jack'}},当obj2的b属性复制给obj1的时候，避免复制b属性的引用
 */
function deepMerge(/* obj1, obj2, obj3, ... */) {
  var result = {};
  function assignValue(val, key) {
    if (typeof result[key] === 'object' && typeof val === 'object') {
      result[key] = deepMerge(result[key], val);
    } else if (typeof val === 'object') {
      result[key] = deepMerge({}, val);
    } else {
      result[key] = val;
    }
  }

  for (var i = 0, l = arguments.length; i < l; i++) {
    forEach(arguments[i], assignValue);
  }
  return result;
}

/**
 * 将b上的属性跟方法复制到a上来，如果传入了第三个参数，那边还需要对b的方法绑定上下文关系
 */
function extend(a, b, thisArg) {
  forEach(b, function assignValue(val, key) {
    if (thisArg && typeof val === 'function') {
      a[key] = bind(val, thisArg);
    } else {
      a[key] = val;
    }
  });
  return a;
}

// 创建axios实例的方法
function createInstance(defaultConfig) {
  // 调用Axios构造函数创建实例
  var context = new Axios(defaultConfig);

  // 将Axios原型上的request方法，绑定上下文为context实例，并返回
  var instance = bind(Axios.prototype.request, context);

  // 将Axios原型上的方法，如get、post、delete等原型方法和属性拓展到上面的instance函数上，如果是
  // 函数则绑定上下文为context
  utils.extend(instance, Axios.prototype, context);

  // 将Axios实例属性copy到instance方法上，主要有两个，一个是defaults，一个是interceptors
  utils.extend(instance, context);

  // 最后在返回这个绑定了上下文关系的函数
  return instance;
}

// 传入默认的defaults参数，创建暴露出去的axios函数，默认配置项是defaults，我们可通过
// axios.defaults.xxx or instance.defaults.xxx来修改
var axios = createInstance(defaults);

// 将Axios构造函数暴露出去
axios.Axios = Axios;

// 暴露创建axios函数的create方法，便于创建自定义的axios函数
axios.create = function create(instanceConfig) {
  return createInstance(mergeConfig(axios.defaults, instanceConfig));
};

// 暴露取消请求的相关函数
axios.Cancel = require('./cancel/Cancel');
axios.CancelToken = require('./cancel/CancelToken');
axios.isCancel = require('./cancel/isCancel');

// 设置请求头'Content-Type'常量
var DEFAULT_CONTENT_TYPE = {
  'Content-Type': 'application/x-www-form-urlencoded'
};

// 当headers头信息不为空，且header头信息内没有设置Content-Type，设置为传入的value
function setContentTypeIfUnset(headers, value) {
  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
    headers['Content-Type'] = value;
  }
}

// 根据当前运行的环境获取默认的适配器
function getDefaultAdapter() {
  var adapter;
  // Only Node.JS has a process variable that is of [[Class]] process
  if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
    // For node use HTTP adapter
    adapter = require('./adapters/http');
  } else if (typeof XMLHttpRequest !== 'undefined') {
    // For browsers use XHR adapter
    adapter = require('./adapters/xhr');
  }
  return adapter;
}

var defaults = {
  adapter: getDefaultAdapter(),

  transformRequest: [function transformRequest(data, headers) {
    // 规范化Accept及Content-Type两个参数，如把传入的content-type删掉，并替换成Content-Type
    normalizeHeaderName(headers, 'Accept');
    normalizeHeaderName(headers, 'Content-Type');
 
    // 如果传入的data是formData等类型，则直接返回，且会删除header头内的Content-Type属性，让浏览 
    // 器自动设置
    if (utils.isFormData(data)
    ) {
      return data;
    }

    // 如果传入的data参数是URLSearchParams类型，则将请求头设置为表单请求头，即我们post如果需要发送表单请求，如果不主动设置Content-Type则需要传入的data参数是URLSearchParams类型，一般使用qs.stringify(data)
    if (utils.isURLSearchParams(data)) {
      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
      return data.toString();
    }

    // 如果传入的参数就是纯对象，则设置Content-Type为'application/json'，即之前说到的axios，post默 
    // 认json形式
    if (utils.isObject(data)) {
      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
      return JSON.stringify(data);
    }
    return data;
  }],

  transformResponse: [function transformResponse(data) {
    /*eslint no-param-reassign:0*/
    // 将字符串转换为json
    if (typeof data === 'string') {
      try {
        data = JSON.parse(data);
      } catch (e) { /* Ignore */ }
    }
    return data;
  }],

  timeout: 0,

  xsrfCookieName: 'XSRF-TOKEN',
  xsrfHeaderName: 'X-XSRF-TOKEN',

  maxContentLength: -1,

  validateStatus: function validateStatus(status) {
    return status >= 200 && status < 300;
  }
};

// 默认公共的接收格式为json数据
defaults.headers = {
  common: {
    'Accept': 'application/json, text/plain, */*'
  }
};

// 'delete', 'get', 'head'默认的方法头信息为空
utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
  defaults.headers[method] = {};
});

// 'post', 'put', 'patch'方法的头信息设置了一个'Content-Type': 'application/x-www-form-urlencoded'，
// 这里会有一个疑问，就是我这里都设置了表单头，为什么会是json请求内，因为在最终发送的时候，
// 做了一次头header信息合并，config.headers >> config.headers[config.method] >> config.headers.common

utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
});

/**
 * 定义Axiose构造函数，需要传入一个Config参数
 */
function Axios(instanceConfig) {
  // 添加defaults实例属性，存放config配置参数，所有我们可以通过axios.defaults.xxx = xxx来改变配置项
  this.defaults = instanceConfig;
  
  // 添加拦截器数组，即我们可以通过axios.interceptors.request.use(() => {}, () => {})添加拦截器
  this.interceptors = {
    request: new InterceptorManager(),
    response: new InterceptorManager()
  };
}

/**
 * createInstance内绑定了上下文关系的原型request方法
 */
Axios.prototype.request = function request(config) {
  // 支持axios(‘url'[, config]) 的形式
  if (typeof config === 'string') {
    config = arguments[1] || {};
    config.url = arguments[0];
  } else {
    config = config || {};
  }
 
  // 合并单个请求时传入的config与创建Axios实例时的config
  config = mergeConfig(this.defaults, config);
  
  // 默认get方法
  config.method = config.method ? config.method.toLowerCase() : 'get';

  // 定义一个chain数组，连接拦截器中间件，两个值的目的是，对应promise.then()方法的两个回调
  var chain = [dispatchRequest, undefined];

  // 返回一个状态为fullfiled的promise
  var promise = Promise.resolve(config);

  // 遍历添加的请求拦截器数组，并压入到chain数组前面
  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
    chain.unshift(interceptor.fulfilled, interceptor.rejected);
  });

  // 遍历添加的响应拦截器数组，并压入到chain数组后面
  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
    chain.push(interceptor.fulfilled, interceptor.rejected);
  });

  // 到这里时，chain数组可能的值为[request[1].fulfilled, request[1].rejected, request[0].fulfilled, 
 // request[0].rejected, dispatchRequest, undefined, response[0].fulfilled, response[0].rejected, 
 // response[1].fulfilled, response[1].rejected]

 // 遍历chain数组，直到数组为空为止
 // 最终生成的promise链为：
 // Promise.resolve(config)
 //     .then(request[1].fulfilled, request[1].rejected)
 //     .then(request[0].fulfilled, request[0].rejected)
 //     .then(dispatchRequest, undefined)
 //     .then(response[0].fulfilled, response[0].rejected)
 //     .then(response[1].fulfilled, response[1].rejected)
  while (chain.length) {
    promise = promise.then(chain.shift(), chain.shift());
  }
  返回最终的promise
  return promise;
};

// 更简单的实现
return chain.reduce((crr, promise) => {
      return crr.then(chain.shift(), chain.shift())
 }, Promise.resolve(config))

// 在Axios原型上定义'delete', 'get', 'head', 'options'方法，里面调用的还是request方法
utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
  /*eslint func-names:0*/
  Axios.prototype[method] = function(url, config) {
    return this.request(utils.merge(config || {}, {
      method: method,
      url: url
    }));
  };
});

// 在Axios原型上定义'post', 'put', 'patch'方法，里面调用的还是request方法
utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
  /*eslint func-names:0*/
  Axios.prototype[method] = function(url, data, config) {
    return this.request(utils.merge(config || {}, {
      method: method,
      url: url,
      data: data
    }));
  };
});

// 定义构造函数，添加handlers一个实例属性
function InterceptorManager() {
  this.handlers = [];
}

/**
 * 定义原型use方法，允许通过use方法来注册fulfilled及rejected回调函数，并返回一个number，同于注销添加的拦截器
 */
InterceptorManager.prototype.use = function use(fulfilled, rejected) {
  this.handlers.push({
    fulfilled: fulfilled,
    rejected: rejected
  });
  return this.handlers.length - 1;
};

/**
 * 定义原型eject方法，允许注销之前定义的某个拦截器，传入的参数就是调用use注册时，返回的number
 */
InterceptorManager.prototype.eject = function eject(id) {
  if (this.handlers[id]) {
    this.handlers[id] = null;
  }
};

/**
 * 遍历添加的拦截器数组，跳过注销了的拦截器，用在request方法内
 */
InterceptorManager.prototype.forEach = function forEach(fn) {
  utils.forEach(this.handlers, function forEachHandler(h) {
    if (h !== null) {
      fn(h);
    }
  });
};

/**
 *  判断是否执行了cancel操作
 */
function throwIfCancellationRequested(config) {
  if (config.cancelToken) {
    // 调用的是CancelToken原型上的throwIfRequested方法，判断this.reason是否有值来终止请求
    config.cancelToken.throwIfRequested();
  }
}

/**
 * 根据 adapter发起一个请求
 */
module.exports = function dispatchRequest(config) {
  // 如果xhr请求之前执行了cancel方法，则直接取消当前请求
  throwIfCancellationRequested(config);

  // 支持baseUrl的配置，拼接成决定路径
  if (config.baseURL && !isAbsoluteURL(config.url)) {
    config.url = combineURLs(config.baseURL, config.url);
  }

  // Transform request data
  config.data = transformData(
    config.data,
    config.headers,
    config.transformRequest
  );

  // Flatten headers，所以从这里可以看出header配置参数的优先级config.headers >> config.headers[config.method] >> config.headers.common
  config.headers = utils.merge(
    config.headers.common || {},
    config.headers[config.method] || {},
    config.headers || {}
  );

  // 删除方法header及common header头属性
  utils.forEach(
    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
    function cleanHeaderConfig(method) {
      delete config.headers[method];
    }
  );

  var adapter = config.adapter || defaults.adapter;

  return adapter(config).then(function onAdapterResolution(response) {
    // 如果cacel方法在xhr执行成功之后执行，则直接返回取消的原因
    throwIfCancellationRequested(config);

    // Transform response data
    response.data = transformData(
      response.data,
      response.headers,
      config.transformResponse
    );

    return response;
  }, function onAdapterRejection(reason) {
    if (!isCancel(reason)) {
      throwIfCancellationRequested(config);

      // Transform response data
      if (reason && reason.response) {
        reason.response.data = transformData(
          reason.response.data,
          reason.response.headers,
          config.transformResponse
        );
      }
    }

    return Promise.reject(reason);
  });
};

function xhrAdapter(config) {
  return new Promise(function dispatchXhrRequest(resolve, reject) {

    // 如果传入的data是FormData类型，则删除Content-Type属性，让浏览器自行设置
    if (utils.isFormData(requestData)) {
      delete requestHeaders['Content-Type']; 
    }
    // new 一个能够发起ajax的XMLHttpRequest实例，XMLHttpRequest方法支持ie11+
    var request = new XMLHttpRequest();

    // 调用buildURL去拼接url上的query参数
    request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);

    // 设置请求超时时间
    request.timeout = config.timeout;

    // 监听state状态
    request.onreadystatechange = function handleLoad() {
      if (!request || request.readyState !== 4) {
        return;
      }

      // 如果支持getAllResponseHeaders方法就使用getAllResponseHeaders方法解析header属性
      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
     // 取接口返回值
      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
      var response = {
        data: responseData,
        status: request.status,
        statusText: request.statusText,
        headers: responseHeaders,
        config: config,
        request: request
      };
     
     // 根据validate方法来决定是执行resolve还是reject
      settle(resolve, reject, response);

      // 清掉本次request
      request = null;
    };

    // 监听请求取消onabort事件
    request.onabort = function handleAbort() {
      if (!request) {
        return;
      }

      reject(createError('Request aborted', config, 'ECONNABORTED', request));

      // Clean up request
      request = null;
    };

    // 监听请求错误onerror事件
    request.onerror = function handleError() {
      // 通常浏览器会隐藏真正的错误只有在网络错误时才会触发错误事件
      reject(createError('Network Error', config, null, request));

      // Clean up request
      request = null;
    };

    // 监听请求超时ontimeout事件
    request.ontimeout = function handleTimeout() {
      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED',
        request));

      // Clean up request
      request = null;
    };

    // 标准浏览器下添加 xsrf header
    if (utils.isStandardBrowserEnv()) {
      var cookies = require('./../helpers/cookies');

      // Add xsrf header
      var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?
        cookies.read(config.xsrfCookieName) :
        undefined;

      if (xsrfValue) {
        requestHeaders[config.xsrfHeaderName] = xsrfValue;
      }
    }

    // 通过setRequestHeader方法设置头信息
    if ('setRequestHeader' in request) {
      utils.forEach(requestHeaders, function setRequestHeader(val, key) {
        // 处理不需要Content-Type头属性的get等请求
        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
          // Remove Content-Type if data is undefined
          delete requestHeaders[key];
        } else {
          // Otherwise add header to the request
          request.setRequestHeader(key, val);
        }
      });
    }

    // 是否允许添加跨域cookie
    if (config.withCredentials) {
      request.withCredentials = true;
    }

    // 监听下载进度onDownloadProgress事件
    if (typeof config.onDownloadProgress === 'function') {
      request.addEventListener('progress', config.onDownloadProgress);
    }

    // 监听上传onUploadProgress 事件，注意下载事件是在xhr对象上，上传事件在xhr.upload对象上
    if (typeof config.onUploadProgress === 'function' && request.upload) {
      request.upload.addEventListener('progress', config.onUploadProgress);
    }
    
    // 是否开启了取消token操作
    if (config.cancelToken) {
      // 等待cancel方法执行，保证发出请求之后，可以通过abort方法终止本次请求
      config.cancelToken.promise.then(function onCanceled(cancel) {
        if (!request) {
          return;
        }

        request.abort();
        reject(cancel);
        // Clean up request
        request = null;
      });
    }
    // 兼容get请求
    if (requestData === undefined) {
      requestData = null;
    }

    // 添加data参数
    request.send(requestData);
  });
};

/**
 * 定义一个CancelToken构造函数，该构造函数会有promise，及reason两个属性，一个用于xhr发起前取消请求，一个用于xhr进行的时候取消操作
 */
function CancelToken(executor) {
  // 确保传入的参数一定是一个函数
  if (typeof executor !== 'function') {
    throw new TypeError('executor must be a function.');
  }

  var resolvePromise;
  // 创建一个promise，并把resolve方法赋值给一个变量
  this.promise = new Promise(function promiseExecutor(resolve) {
    resolvePromise = resolve;
  });

  var token = this;
  // 传入的回调函数执行的时候，传入cancel这个方法，取消实现的核心就是这个cancel函数，cancel函数什么时候执行，则什么时候取消
  executor(function cancel(message) {
    if (token.reason) {
      // Cancellation has already been requested
      return;
    }
    // 设置实例属性reason
    token.reason = new Cancel(message);
    // 将上面创建的promise状态，由pedding改为fulfilled,并可以将token.reason传给后面的then方法
    resolvePromise(token.reason);
  });
}

/**
 * 判断this.reason是否有值来判断是否执行来取消操作
 */
CancelToken.prototype.throwIfRequested = function throwIfRequested() {
  if (this.reason) {
    throw this.reason;
  }
};

/**
 * 返回一个包含了CancelToken实例及执行函数cancel的对象，用于开启及执行取消操作
 */
CancelToken.source = function source() {
  var cancel;
  var token = new CancelToken(function executor(c) {
    cancel = c;
  });
  // 即我们通过CancelToken.source().token来开启取消操作
  // 通过CancelToken.source().cancel来执行取消操作
  return {
    token: token,
    cancel: cancel
  };
};

let cancel
axios({
    method:'get',
    url:'/api/test',
    params: {
        pageIndex: 1,
    },
    cancelToken: new CancelToken(function executor(c) {
        cancel = c
    })
})
.then(function (response) {
    console.log('response', response)
}).catch((err) => {
    console.log('err', err);
});
setTimeout(() => {
    cancel('Operation canceled by the xiaoming')
}, 0)

  // Transform request data
  config.data = transformData(
    config.data,
    config.headers,
    config.transformRequest
  );

  // Flatten headers
  config.headers = utils.merge(
    config.headers.common || {},
    config.headers[config.method] || {},
    config.headers || {}
  );

var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?
        cookies.read(config.xsrfCookieName) :
        undefined;
if (xsrfValue) {
        // 设置头信息'X-XSRF-TOKEN': XSRF-TOKEN
        requestHeaders[config.xsrfHeaderName] = xsrfValue;
      }

// 第一步收集取消触发器
let allCancels = []
const CancelToken = axios.CancelToken;
axios.interceptors.request.use(config=>{
   // 每个请求都添加一个cancelToken，并把cancel函数维护到一个数组内
  config.cancelToken = new CancelToken((cancel) => {     
     allCancels.push(cancel);
  });
  return config;
});
axios.interceptors.response.use(res=>{
  // do something...
  },error=>{
   if (axios.isCancel(error)) {
   // 为了终结promise链 就是实际请求 不会走到.catch(rej=>{});这样就不会触发错误提示之类了。
        return new Promise(() => {});     
   }else{
       return Promise.reject(error)
    }});

第二步在路由守卫内触发，所有的cancel触发器
router.beforeEach((to, from, next) => {
  allCancels.forEach(e=>{
      e && e()
   });
   allCancels= [];
})

// 定义请求数组
const requestList = []
const CancelToken = axios.CancelToken
let sources = {}
axios.interceptors.request.use((config) => {
  //将请求地址及参数作为一个完整的请求
  const request = JSON.stringify(config.url) + JSON.stringify(config.data)
  config.cancelToken = new CancelToken((cancel) => {
    sources[request] = cancel
  })
  //判断请求是否已存在请求列表，避免重复请求，将当前请求添加进请求列表数组；
  if(requestList.includes(request)){
    sources[request]('取消重复请求')
  }else{
    requestList.push(request)
  }
  return config
}, function (error) {
  return Promise.reject(error)
})

axios.interceptors.response.use(function (response) {
  // 将当前请求中请求列表中删除
  const request = JSON.stringify(response.config.url) + JSON.stringify(response.config.data)
  requestList.splice(requestList.findIndex(item => item === request), 1)
  return response
}, function (error) {
  // 4.处理取消请求
  if (axios.isCancel(error)) {
    requestList.length = 0
    throw new axios.Cancel('cancel request')
  } else {
    console.error('网络请求失败', 1000)
  }
  return Promise.reject(error)
})

// 多来一层无用的promise封装
function get(url, params) {
    return new Promise((resolve, reject) => {
          axios.get(url, params).then((res) => {
                resolve(res)
          }).catch((e) => {
                reject(e)
          })
    })
}

function get(url, params) {
    return axios.get(url, params))
}