vue中同步方法的实现

延伟

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.     });

复制代码

总结

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

来源:https://www.jb51.net/javascript/2845110hx.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！