An article explaining routing switching in Vue to terminate asynchronous requests (with code)

In the previous article "In-depth analysis of the implementation of queues in js (code sharing)", we learned about the implementation of queues in js. The following article will help you understand how routing switching terminates asynchronous requests in Vue. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Question:

In the development of SPA mode, such as VUE, how to terminate the asynchronous request that is occurring when the current route is switched.

Result:

If the request times out and there is a set timeout. There are a bunch of asynchronous requests being executed. When the user switches to another page, these requests have not been terminated, and when the server responds, the feedback result is not what the current page expects. Ultimately, it will mislead users and cause unnecessary results. It also causes performance problems for web.

Solution:

Store the executed request in the queue, and terminate the queue when the route is switched. Asynchronous requests.

First make a tree to store requestsQueue

import Vue from "vue";
import Vuex from "vuex";
Vue.use(Vuex);
let store = new Vuex.Store({
  state: {
    requests: [],
  },
});

new Vue({
  el: "#app",
  router: router,
  render: (h) => h(App),
  store,
});

UseajaxRequest and termination

var xhr = $.ajax({
  type: "POST",
  url: "xxxsx",
  data: "",
  success: function () {
    alert("ok");
  },
});
//xhr.abort()  终止请求
this.$store.state.requests.push(xhr);

ExploitsuperagentRequest and Terminate

const request = require('superagent')
var xhr = request('post','/api/xxxx/xxxx')
xhr.send(data)
//xhr.query(data) //get 传参
xhr.end((err,res)=>{
    ...todo...
})
//xhr.abort() 终止请求
this.$store.state.requests.push(xhr)

ExploitaxiosRequest

import axios from "axios";
var CancelToken = axios.CancelToken;
var source = CancelToken.source();
axios
  .get("/api/xxxxx/xxxxx", {
    cancelToken: source.token,
  })
  .catch(function (thrown) {
    if (axios.isCancel(thrown)) {
      console.log("Request canceled", thrown.message);
    } else {
      // 处理错误
    }
  });

// 取消请求（message 参数是可选的）
//source.cancel('Operation canceled by the user.');

this.$store.state.requests.push(source);

Use vue-resourceRequest

import Vue from "vue";
import req from "vue-resource";
Vue.use(req);

this.$http
  .get("/someUrl", {
    before(request) {
      this.$store.state.requests.push(request);
      //request.abort(); 终止请求
    },
  })
  .then(
    (response) => {
      // success callback
    },
    (response) => {
      // error callback
    }
  );

UsefetchRequest

fetch seems to be unable to be monitored Read progress and terminal requests, it has no timeout mechanism, no progress prompt, but you can use Promise to achieve termination

var _fetch = (function (fetch) {
  return function (url, options) {
    var abort = null;
    var abort_promise = new Promise((resolve, reject) => {
      abort = () => {
        reject("abort.");
        console.info("abort done.");
      };
    });
    var promise = Promise.race([fetch(url, options), abort_promise]);
    promise.abort = abort;
    return promise;
  };
})(fetch);

var xhr = _fetch("/api/xxx/xxxx", { methods: "POST", body: data });
xhr.then(
  function (res) {
    console.log("response:", res);
  },
  function (e) {
    console.log("error:", e);
  }
);
xhr.abort(); //终止

this.$store.state.requests.push(xhr);

Then you know how to terminate the request, and then also store the request instance, the rest is just Just listen to the route

let router = new Router({....})
//每次路由改变之前终止所有的请求实例
router.beforeEach(function (to, from, next) {
    this.$store.state.requests.forEach(xhr=>xhr.abort()) //终止所有的请求实例
    this.$store.state.requests =[] //执行完清空，等待下一次的页面的请求装载
    next()
})

This is just a hypothesis. After the natural request is completed, it is best to manually release the tree request example. For example, after the ajax request is completed, the instance in the splice store in complite.

[End]

Recommended learning: vue.js tutorial

The above is the detailed content of An article explaining routing switching in Vue to terminate asynchronous requests (with code). For more information, please follow other related articles on the PHP Chinese website!