首页 > 网络编程 > JavaScript > vue中同步方法的实现

vue中同步方法的实现

福牛 5月 16, 2023 13 0

vue同步方法实现

有三种实现方式

1、axIOS本身属于Promise

利用函数式的then获取请求返回结果，也是最常用的，如下：

  1. request({
  2.      url: ‘/test/XXX/XXXX’,
  3.      method: ‘post’,
  4.      data: param
  5.      }).then(ret => {
  6.      if (ret.code === RESULT_CODE.SUCCESS) {
  7.          this.$message.success(‘保存成功’)
  8.      }
  9.      })

此处request对象是对axios做了一层封装，不用在意。此种方式的缺陷是：只能用于请求返回后只有简单操作的情形。

如果返回后的操作比较多，代码就会显得臃肿，可读性差，还有一种情况，即该请求被调用的情况，由于axios没有配置为同步请求的配置项，因此无法直接将上述代码封装后直接调用，因此，引申出第二种方法：

2、async结合await

  1. // api.js文件
  2. // test1方法作为被调用方，被test1方法调用
  3. export async function test1 (param) {
  4.      // 返回一个Promise对象，真正需要返回给调用方的数据，放在resolve中
  5.      return new Promise(resolve => {
  6.      // request对象是对axios的封装，不用在意
  7.      request({
  8.          url: ‘/emr/order/deleteOrder’,
  9.          method: ‘post’,
  10.          data: order
  11.      }).then(ret => {
  12.          resolve(ret.data)
  13.      }
  14.      })
  15.      })
  16. }
  1. // VUE文件
  2. methods: {
  3.      // test2作为调用方调用test1方法
  4.      async test2 (param) {
  5.      const data = await test1(param)
  6.      }
  7. }

3、引入jquery

此处就不写了，这种方式感觉挺没追求的。

vue中的同步和异步问题

同步

在主线程上排队之行的任务,只有在最前面的任务执行完成之后,才之行后面的任务。

（生活中的例子话糙理不怪：银行排队，只有一个窗口的时候，A业务办理完在接着办理B）

异步

是指不进入主线程,而是进入了“任务队列”的任务,只有“任务队列”通知主线程,某个异步任务可执行了,该任务才会进入主线程执行。

（生活中的例子话糙理不怪：多个窗口，可以同时办理业务，互不影响）

  • 同步的优点是：同步是按照顺序一个一个来，不会乱掉，更不会出现上面代码没有执行完就执行下面的代码，
  • 缺点：是解析的速度没有异步的快；
  • 异步的优点是：异步是接取一个任务，直接给后台，在接下一个任务，一直一直这样，谁的先读取完先执行谁的，
  • 缺点：没有顺序 ，谁先读取完先执行谁的 ，会出现上面的代码还没出来下面的就已经出来了，会报错；

异步任务分为：宏任务   微任务

  • 宏任务：包含整体代码script /  setTimeout /  setInterval
  • 微任务：Promise.then(非new Promise) / process.nextTick(node中)

事件执行顺序：

  • 1.先执行宏任务，在执行微任务
  • 2.微任务根据先进先出的顺序执行
  • 3.微任务清空后在执行宏任务
  • 4.按先进先出的顺序取出执行

Promise 实现异步调用

asnyc/await 实现同步调用

  1.      // 项目中使用的事例：Vue接口请求异步变同步
  2.      created() {
  3.          this.initData();
  4.      }
  5.      methods: {
  6.          async initData() {
  7.              let res = await getList(this.params);
  8.              if (res.message === “成功”) {
  9.                  this.resultList = res.data;;
  10.              }
  11.          }
  12.      }
  1. // 异步请求同步的方法
  2.      handleClick() {
  3.          return new Promise((resolve,reject) => { //resolve 成功 ,reject 失败
  4.              getRequest().then(res => {
  5.                  //操作1
  6.                  resolve();
  7.              }).catch(error =>{
  8.                  console.log(error)
  9.                  reject()
  10.              })
  11.          })
  12.      },
  13.      test(){
  14.          Promise.all([this.handleClick()]).then(res=>{
  15.              //操作2
  16.          })
  17.      }
  1.      // promise的操作
  2.      const promise = new Promise(function(resolve, reject){
  3.          if(一步操作成功){
  4.              resolve(value);
  5.          }else{
  6.              reject(error);
  7.          }
  8.      })
  9.      // 异步操作
  10.      new Promise((resolve, reject) => {
  11.          resolve(1);
  12.          console.log(2);
  13.      }).then(r => {
  14.          console.log(r);
  15.      });
  16.      // 2
  17.      // 写法一
  18.      const promise = new Promise(function(resolve, reject) {
  19.          try {
  20.              throw new Error(‘test’);
  21.          } catch(e) {
  22.              reject(e);
  23.          }
  24.      });
  25.      promise.catch(function(error) {
  26.          console.log(error);
  27.      });
  28.      // 写法二
  29.      const promise = new Promise(function(resolve, reject) {
  30.          reject(new Error(‘test’));
  31.      });
  32.      promise.catch(function(error) {
  33.          console.log(error);
  34.      });

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。

标签

相关推荐

发表评论