JavaScript 中断请求几种方案详解

1 promise

promise有一个缺点是一旦创建无法取消,所以本质上promise是无法被终止的.

但是我们可以通过中断调用链或中断promise来模拟请求的中断.

中断调用链

中断调用链就是在某一个then/catch执行之后,后续的链式调用(包括then,catch,finally)不再继续执行.

方法是在then/catch返回一个新的promise实例,并保持pending状态:

new promise((resolve, reject) => {
    settimeout(() => {
        resolve('result');
    });
}).then(res => {
    // 达到某种条件,return一个pending状态的promise实例,以中断调用链
    if (res === 'result') {
        return new promise(() => {});
    }
    console.log(res); // 不打印
}).then(() => {
    console.log('then不执行'); // 不打印
}).catch(() => {
    console.log('catch不执行'); // 不打印
}).finally(() => {
    console.log('finally不执行'); // 不打印
});

中断promise

中断promise不等同于中止promise,因为promise是无法被终止的.

这里的中断指的是,在合适的时机,把pending状态的promise给reject掉.例如一个常见的应用场景就是给网络请求设置超时时间,一旦超时就中断.

老规矩,用settimeout来模拟网络请求.阀值设置为math.random() * 3000表示随机3秒之内返回结果.

const request = new promise((resolve, reject) => {
  settimeout(() => {
    resolve('收到服务端数据')
  }, math.random() * 3000)
})

假设超过2秒就是网络超时,我们可以封装一个超时处理函数.

由于网络请求所需的事件是随机的,因此可以利用promise.race方法,达到超时reject的目的.

const timeoutreject = (p1, timeout = 2000) => {
    const p2 = new promise((resolve, reject) => {
        settimeout(() => {
            reject('网络超时');
        }, timeout);
    });
    return promise.race([p1, p2]);
};

timeoutreject(request).then(res => {
    console.log(res);
}).catch(err => {
    console.log(err);
});

包装abort方法——仿照axios的canceltoken

上面实现的方式并不灵活,因为中断promise的方式有很多,不单单是网络超时.

我们可以仿照axios中canceltoken的核心源码,简单包装一个abort方法,供使用者随时调用.

function abortwrapper(p1) {
    let abort;
    const p2 = new promise((resolve, reject) => {
        abort = reject;
    });
    // 如果没有resolve或reject,p2的状态永远是pending
    const p = promise.race([p1, p2]);
    p.abort = abort;
    return p;
}

const req = abortwrapper(request);
req.then(res => {
    console.log(res);
}).catch(err => {
    console.log(err);
});

settimeout(() => {
    // 手动调用req.abort,将p2的状态改变为rejected
    req.abort('手动中断请求');
}, 2000);

如此封装的主要目的就是为了能够在promise外部控制其resolve或reject,让使用者可以随时手动调用resolve(触发.then)或reject(触发.catch).

需要注意的是,虽然promise请求被中断了,但是promise并没有终止,网络请求依然可能返回,只不过那时我们已经不关心请求结果了.

2 rxjs的unsubscribe方法

rxjs本身提供了取消订阅的方法,即unsubscribe.

let stream1$ = new observable(observer => {
    let timeout = settimeout(() => {
        observer.next('observable timeout');
    }, 2000);

    return () => {
        cleartimeout(timeout);
    }
});
let disposable = stream1$.subscribe(value => console.log(value));
settimeout(() => {
    disposable.unsubscribe();
}, 1000);

3 axios的canceltoken

axios的canceltoken有两种使用方法:

• 方法一

import axios from 'axios';
const canceltoken = axios.canceltoken;
const source = canceltoken.source();

axios.get('/user/12345', {
  canceltoken: source.token
}).catch(function (thrown) {
  if (axios.iscancel(thrown)) {
    console.log('request canceled', thrown.message);
  } else {
    // handle error
  } 
});

source.cancel('operation canceled by the user.');

• 方法二

import axios from 'axios';
const canceltoken = axios.canceltoken;

// 创建一个变量如 cancel 用于存储这个中断某个请求的方法
let cancel;

axios.get('/user/12345', {
  canceltoken: new canceltoken(function executor(c) {
    cancel = c; // 将参数 c 赋值给 cancel
  })
});

// 判断 cancel 是否为函数,确保 axios 已实例化一个canceltoken
if (typeof cancel === 'function') {
    cancel();
    cancel = null;
}

canceltoken的核心源码:(axios/lib/cancel/canceltoken.js)

'use strict';

var cancel = require('./cancel');

/**
 * a `canceltoken` is an object that can be used to request cancellation of an operation.
 *
 * @class
 * @param {function} executor the executor function.
 */
function canceltoken(executor) {
  if (typeof executor !== 'function') {
    throw new typeerror('executor must be a function.');
  }

  var resolvepromise;
  this.promise = new promise(function promiseexecutor(resolve) {
    resolvepromise = resolve;
  });

  var token = this;
  executor(function cancel(message) {
    if (token.reason) {
      // cancellation has already been requested
      return;
    }

    token.reason = new cancel(message);
    resolvepromise(token.reason);
  });
}

/**
 * throws a `cancel` if cancellation has been requested.
 */
canceltoken.prototype.throwifrequested = function throwifrequested() {
  if (this.reason) {
    throw this.reason;
  }
};

/**
 * returns an object that contains a new `canceltoken` and a function that, when called,
 * cancels the `canceltoken`.
 */
canceltoken.source = function source() {
  var cancel;
  var token = new canceltoken(function executor(c) {
    cancel = c;
  });
  return {
    token: token,
    cancel: cancel
  };
};

module.exports = canceltoken;

可以看到,在axios底层,canceltoken的核心源码所体现的思想,与上面中断promise包装abort方法的思想一致.

只不过axios在外部手动调用resolve(用户触发cancel方法),而resolve一旦调用,就会触发promise的then方法,来看这个promise.then的源码:(axios/lib/adapters/xhr.js)

if (config.canceltoken) {
  // handle cancellation
  config.canceltoken.promise.then(function oncanceled(cancel) {
    if (!request) {
      return;
    }

    request.abort();
    reject(cancel);
    // clean up request
    request = null;
  });
}

可以看到then方法中会执行abort方法取消请求,同时调用reject让外层的promise失败.

到此这篇关于javascript 中断请求几种方案详解的文章就介绍到这了,更多相关js中断请求内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！