vue中同步方法的实现

vue同步方法实现

有三种实现方式

1、axios本身属于Promise

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

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

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

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

2、async结合await

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

3、引入jquery

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

vue中的同步和异步问题

同步

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

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

异步

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

(生活中的例子话糙理不怪:多个窗口,可以同时办理业务,互不影响) 

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

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

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

事件执行顺序:

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

Promise 实现异步调用

asnyc/await 实现同步调用

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

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持IT俱乐部。

本文收集自网络,不代表IT俱乐部立场,转载请注明出处。https://www.2it.club/navsub/js/8194.html
上一篇
下一篇
联系我们

联系我们

在线咨询: QQ交谈

邮箱: 1120393934@qq.com

工作时间:周一至周五,9:00-17:30,节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部