精华内容
下载资源
问答
  • 今天研究一个小问题: 怎么拿到JavaScript异步函数的返回值? 1.错误尝试 当年未入行时,我的最初尝试: [removed] function getSomething() { var r = 0; setTimeout(function() { r = 2; }, 10); return r; ...
  • 通过调用initReqLimit,传入并发阈值作为参数,则可返回一个接受异步函数为参数的处理函数,假设其为reqLimit,接收的异步函数会在适当的时候调用, 如果当前并发量没有超出阈值,则该异步函数会立刻得到调用,但...
  • 我们需要实现一个队列,将这些异步函数添加进队列并且管理它们的执行,队列具有First In First Out的特性,也就是先添加进去的会被先执行,接着才会执行下一个(注意跟栈作区别) 大家也可以类比一下jQuery的animate...
  • 在写Node.js的过程中,连续的IO操作可能会导致“金字塔噩梦”,回调函数的多重嵌套让代码变的难以维护,利用CommonJs的Promise来封装异步函数,使用统一的链式API来摆脱多重回调的噩梦。  Node.js提供的非阻塞IO...
  • 防止在异步操作正在进行时多次调用异步函数。 操作完成后,将进行操作进行时对该函数的最后一次调用。 中间调用将丢失,如果在异步操作正在进行时没有进行调用,则不会再次调用该函数。 这种去抖动不是基于时间,...
  • 下面小编就为大家带来一篇不同js异步函数同步的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 本文实例讲述了JS异步函数队列功能。分享给大家供大家参考,具体如下: 场景: 做直播,会有入场消息,入场特效,用户如果有坐骑,需要给他展示几秒钟的坐骑特效,如果几个人同时进场,那该怎么展示呢?这时候就会...
  • 解决异步函数嵌套问题以及获取异步函数返回值 普通ajax请求数据一般是接口嵌套,很繁琐,不好使用,解决异步函数嵌套的方法如下: 1. 一个方法中有异步函数是可以对改方法使用then获取返回数据 //孙子函数 function ...

    解决异步函数嵌套问题以及获取异步函数返回值

    普通ajax请求数据一般是接口嵌套,很繁琐,不好使用,解决异步函数嵌套的方法如下:

    1. 一个方法中有异步函数是可以对改方法使用then获取返回数据

    //孙子函数
    function grandChild() {
        let p = new Promise((resolve) => {
            setTimeout(function() {
                resolve('孙子')
            }, 500)
        })
        return p
    }
    
    //儿子函数
    function child(item) {
        let p = new Promise((resolve) => {
            setTimeout(function() {
                resolve('儿子' + item)
            }, 700)
        })
        return p
    }
    
    • 在一个函数中只使用一个异步函数,对该函数通过then获取返回数据
    //在finalFun函数中只使用一个异步函数
    function finalFunc() {
        return grandChild()  //这里必须要有return返回这个函数
     }
     
     //使用finalFun
     finalFunc().then(e => {
     	console.log(e)  //输出“孙子”
     })
    
    • 在一个函数中使用2个嵌套的异步函数,不能通过then获取返回数据,会报错,需要在第一个函数名之前添加return,将2个嵌套函数都返回就不会报错了
    //错误的写法
    //在函数finalFunc中定义2个嵌套异步函数,即在一个异步函数的then中再调用一个异步函数
    function finalFunc() {
        grandChild().then(e => {
        	return child()
        })  //这里必须要有return返回这个函数
     }
     
    //使用finalFun
    finalFunc().then(e => {
    	console.log(e)   //会报错,报finalFunc.then是undefined,因为嵌套的异步函数是再then中使用,不能被finalFunc函数的外部使用,所以会报错
    }) 
    
    //正确的写法
    //在函数finalFunc中定义2个嵌套异步函数,即在一个异步函数的then中再调用一个异步函数
    function finalFunc() {
        return grandChild().then(e => {   //这个return必须存在,否则不会输出数据
        	return child()
        })  //这里必须要有return返回这个函数
     }
     
    //使用finalFun
    finalFunc().then(e => {
    	console.log(e)   //输出 ‘孙子儿子’ 
    }) 
    

    2. 使用await和async

    //await是将异步转换为同步,即必须等上一步执行完之后才会执行下一步,await需要与async一起搭配使用,
    //async标志函数是异步函数,函数返回的Promise对象,需要通过then获取数据
    async function  finalFunc() {
        let datagrandChild = await grandChild()
        let datachild = await  child()
        return (datafather + datagrandChild)
    }
    
    //使用finalFunc()
    finalFunc().then(e => {
    	console.log(e)  //输出‘孙子儿子’
    })
    

    3. 使用callback回调函数

    //给函数一个callback函数作为函数的参数
    function finalFunc(callback) {
        grandChild().then(g => {
            //在孙子函数的回调方法中调用儿子函数
            child(g)
        }).then( c => {
            //在儿子函数的回调方法中调用callback回调函数
            callback(c)
        })
    }
    
    //使用finalFunc()函数
    finalFunc(e => {
    	console.log(e)    //输出‘儿子孙子’
    })
    
    展开全文
  • 同步函数与异步函数

    千次阅读 2019-11-01 01:09:57
    同步、异步概念 定义:同步和异步关注的是消息通信机制(synchronous communication/ asynchronous communication)。从程序同步,就是调用方发起某个调用后,调用方得等待这个调用返回结果才能继续往下执行。异步,...

    1 同步、异步概念

            同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication)。

    1、从程序调用的角度来看

    同步,就是调用方发起一个调用后,必须等待这个调用返回结果之后才能继续往下执行。换句话说,调用者是 “主动等待” 这个调用的返回结果。

    异步,则是和同步相反 ,调用方发起一个调用后,调用方不会一直等待该调用返回结果,而是在调用发出后就直接返回了,所以没有返回处理结果,调用者继续执行后续操作,而被调用者通过某种反馈机制来通知调用者最后的处理结果。比如说监听被调用者的状态、被调用者执行完成后主动发出通知告知调用者或者通过回调的方式。

    2、从IO系统调用的角度来看

    IO操作是通过系统调用(System Call)来实现的,涉及到应用程序与系统内核之间的数据交换过程。

    阻塞式同步IO:应用进程必须等待IO操作完成,才能进行其他的操作,在此期间,进程一直处于阻塞状态,也就是挂起状态。

    非阻塞式同步IO:应用进程发起一个IO请求后,内核会立即返回一个结果,如果IO操作没有完成,应用进程会再次发送这个IO请求,直到IO操作完成为止,在此期间,进程一直处于运行态。

    异步IO:应用进程发起一个IO请求后,内核也会立即返回一个结果,与非阻塞IO系统调用不同的是,它不需要轮询检测IO操作是否完成,而是可以继续执行其他的操作,等到IO操作完成后,内核会通过某种机制来通知应用进程(设置一个用户空间特殊的变量值 或者 触发一个 signal 或者 产生一个软中断 或者 调用应用程序的回调函数)。

    3、从进程间通信的角度来看

    进程间的通信可以通过调用原语 send() 和 receive() 来进行。消息传递可以是阻塞或非阻塞的——也称为同步或异步。也就是说,从进程间通信的角度来看,阻塞和同步(非阻塞和异步)就是一对同义词。且需要针对发送方和接收方作区别对待。

    • 阻塞式发送(blocking send):发送方进程会被一直阻塞, 直到消息被接受方进程所收到。
    • 非阻塞式发送(nonblocking send): 发送方进程调用 send() 后, 函数立即返回,并继续其他操作。
    • 阻塞式接收(blocking receive):接收方调用 receive() 后一直阻塞, 直到有消息到达可用。
    • 非阻塞式接收(nonblocking receive):接收方调用 receive() 函数后, 要么得到一个有效的结果, 要么得到一个空值, 即不会被阻塞。

    2 同步与异步的区别

    同步:所有的操作都做完,才返回结果给用户。比如说,服务器端接收一个客户端的请求连接,建立连接后,Server处理Client的请求操作(如数据处理、读写操作等),Server在处理请求操作过程中,无法在响应其他客户端的连接,必须等到Server端处理完当前客户端的请求业务并返回处理结果给Client,两者断开连接后,Server才能处理下一个Client的连接请求。这个过程就是消息同步处理机制。

    异步:不需要等所有操作都做完,就可以继续执行其他的操作。上面的例子,如果是异步通信机制的话,Server与一个Client建立连接后,它把这个Client的业务请求通过缓存机制(如消息队列,先将请求消息放入消息队列中)交给其他的工作线程(工作线程可以通过线程池技术来实现)处理,Server可以继续接受其他客户端的连接请求,当某个客户端的业务请求处理完成时,通过某种反馈机制通知Server,然后Server把处理结果返回给Client端,然后断开连接。这个过程就是消息异步处理机制,这样的好处就是Server端可以响应高并发的连接请求,把连接请求和消息处理独立开来,能够提供系统的响应速度和数据处理的高效性。

    上面是从服务端的解读解读的,若是从客户端的角度谈同步,当客户端发送req请求给服务端,在等待服务端的resp响应应答时,客户端不能做其他的事情。当服务端处理完了客户端的请求业务后才返回resp应答消息给客户端。这样的话客户端需要一直等待。用户使用起来会很不友好。

    同步函数:当函数被调用时,直到函数把所要做的事情全部做完了才返回。对于调用者来说,调用者必须等到函数调用返回时才能继续后续的执行。

    异步函数:当函数被调用时,该函数会立即返回尽管该函数规定的操作任务可能还没有完成。异步函数的调用更像是一个消息传递过程,被调函数接收到调用者传进来的参数后,会把它放入消息队列中或者共享内存中,然后函数返回。真正的消息处理过程是在另一个线程中完成的,调用者不需要去等待这个消息处理结果,它可以去执行其他的任务。

    从客户端的角度来说的话,当客户端发送req请求给服务端时,在等待服务端应答响应时,客户端可以继续做其他的事情,这样节约了时间,提高了效率。

    同步函数执行过程

    同步调用:当调用方法执行完成后并返回结果,主调函数才能继续执行后续代码 。

    异步函数执行过程

    异步调用:可以参考ajax,主调函数调用方法后不会等到sum方法执行完成,而是继续执行后续代码。sum方法执行完成后主要通过状态通知主线程,或者通过回调方式处理这次异步方法执行的结果。

    3 同步异步与阻塞非阻塞不能混为一谈

    阻塞和非阻塞 强调的是程序在等待调用结果(消息,返回值)时的状态.  阻塞调用是指调用结果返回之前,当前线程会被挂起。调用线程只有在得到结果之后才会返回。非阻塞调用指在不能立刻得到结果之前,该调用不会阻塞当前线程。 对于同步调用来说,很多时候当前线程还是激活的状态,只是从逻辑上当前函数没有返回而已,即同步等待时什么都不干,白白占用着资源。

    同步和异步 强调的是消息通信机制 (synchronous communication/ asynchronous communication)。所谓同步,就是在发出一个"调用"时,在没有得到结果之前,该“调用”就不返回。但是一旦调用返回,就得到返回值了。换句话说,就是由“调用者”主动等待这个“调用”的结果。而异步则是相反,"调用"在发出之后,这个调用就直接返回了,所以没有返回结果。换句话说,当一个异步调用发出后,调用者不会立刻得到结果。而是在"调用"发出后,"被调用者"通过状态、通知来通知调用者,或通过回调函数处理这个调用。

    参考

    同步函数与异步函数

    同步(Synchronous)和异步(Asynchronous)

     

    展开全文
  • 《The Evolution of Asynchronous JavaScript》外文梳理了JavaScript异步函数的发展历程,首先通过回调函数实现异步,之后又经历了Promise/A+、生成器函数,而未来将是async函数的。感谢景庄对该文章的翻译,内容...
  • 本文主要分析在循环体中怎么调用异步函数,并且满足循环调用异步函数,并在异步函数值返回之后,再处理后续业务的同步需求。 这篇文章是受到和 六卿 在群里讨论问题时启发而写的,主要讨论的问题就只在循环体内进行...

    本文主要分析在循环体中怎么调用异步函数,并且满足循环调用异步函数,并在异步函数值返回之后,再处理后续业务的同步需求。

    这篇文章是受到和 六卿 在群里讨论问题时启发而写的,主要讨论的问题就只在循环体内进行异步调用。他也写了自己的总结: node 中循环异步的问题[‘解决方案‘]_源于 map 循环和 for 循环对异步事件配合 async、await 的支持

    业务分析

    根据我的理解,当时讨论的问题是基于这样一个需求:

    1. 首先需要调用一个 API 去获得数据

      获取的数据是一个数组类型,这里就代称为 arr

    2. 会对 arr 进行遍历,在遍历的过程中继续调用其他的 API 去获得数据,并且对数据进行一些操作

    整体的业务逻辑和需求,模拟大概是这个样子的:

    const map = new Map([
      [1, 'one'],
      [2, 'two'],
      [3, 'three'],
      [4, 'four'],
      [5, 'five'],
    ]);
    
    // 用 setTimeout 模拟异步的 api 调用
    // timeout 会获得一个数组类型的数据,随后会有另外的 api 根据数组内的数据,再一次去进行异步调用,获取其他数据
    const timeout = () =>
      new Promise((resolve) => setTimeout(() => resolve([1, 2, 3, 4, 5])), 1000);
    
    // 循环体内调用的数据
    const getEl = (key) =>
      new Promise((resolve) => setTimeout(() => resolve(map.get(key)), 1000));
    
    const getData = () => {
      const data = timeout();
      let str = [];
      // 这里没有处理异步操作,所以会有语法错误
      data.forEach((el) => {
        const elVal = getEl(el);
        str.push(elVal);
      });
      // 最后输出结果应该是 ['one', 'two', ...] 这样一个包含 异步调用后返回值 的数组
      console.log(str);
    };
    
    getData();
    

    当然,上面只是一个最基本的逻辑实现,并没有实现异步操作,现在直接运行的话就会报错。不过基本的逻辑是在这里的:

    1. API 那里获取到值 data
    2. 遍历 data,在遍历中继续调用 API 取值并进行操作。

    初版的问题

    最初的方案其实就是比较平铺直叙,用 async/await 配合的方式去获取数据:

    // 其他函数没有改动,只修改了 getData 这一部分
    const getData = async () => {
      // 使用 await 语法糖
      const data = await timeout();
      let str = [];
      // 加上 async 和 await 去等待异步调用
      data.forEach(async (el) => {
        const elVal = await getEl(el);
        str.push(elVal);
        // 可以正常输出
        console.log(elVal);
      });
      // 返回值却是一个空数组
      console.log(str);
    };
    
    getData();
    

    输出结果却不尽如人意,在命令行中输出的顺序是这样的:

    []
    one
    two
    three
    four
    five
    

    可以看到,异步的数据获取是在输出数组之后发生的,这也代表 forEach 内的异步调用的顺序,不如预期所想。

    解决方案

    改为 for循环体 是 六卿 在自己的总结内提出的解决方案;这里再提出了两个不使用 for循环体 的解决方案。

    传统的 for 循环

    一个解决方案就是将 forEach/map 替换成传统的 for (let i = 0; i < arr.lengt; i++) 这样的传统写法,如:

    const getData2 = async () => {
      const data = await timeout();
      let str = [];
      for (let i = 0; i < data.length; i++) {
        const element = await getEl(data[i]);
        console.log(element);
        str.push(element);
      }
      console.log(str);
    };
    
    getData2();
    

    最终的输出结果为:

    one
    two
    three
    four
    five
    [ 'one', 'two', 'three', 'four', 'five' ]
    

    数组的输出结果在 API 调用结果之后,也就意味着数据可以正常地被渲染或是处理。

    不使用 for 循环的解决方案

    所以异步的代码只能使用传统的 for 循环吗?

    也不尽然,只是解决方法无法基于 forEach 去实现而已。

    分析 forEach 为什么不工作

    在输出的时候我发现了一些微妙的异常,例如说使用 for 循环时,每一行的输出都是有一定间隔事件的——毕竟 await 应该会“锁”住运行,一直到数据接收之后才会进行下一步的调用。但是使用 forEach 函数时,它等待了大约几秒钟的时间,随后一下子将所有的结果一起输出。

    直接用文字描述可能没有这么直观,那么就打几个时间戳。一个在刚刚进入函数的时候打印出当前时间,一个在循环体内输出值的时候打印出当前时间,更加直观的对比一下:

    forEachfor

    也就是说,forEach 的循环调用并没有 await 里面的异步操作。所以,当 forEach 中的同步代码执行完毕之后,异步代码才开始执行,这也是为什么 forEach 的代码先输出了一个空的数组之后,才在控制台上打印异步调用中获取的值。

    异步调用的复习资料在这里:[万字详解]JavaScript 中的异步模式及 Promise 使用

    那么,函数最上方已经声明了 async 关键字,forEach 中也使用了 await 去等数。而且,明明 await timeout() 工作了,为什么就只有 forEach 没有工作?

    那是因为,forEach 整个函数没有使用 await 进行等待,整个 forEach 是同步执行的。forEach 的实现是基于内部的回调函数执行,因此,当进入循环之后,函数内部会去调用传进来的回调函数。当回调函数是异步时,回调函数就会被放入时间循环机制中,forEach 内部会继续去执行同步代码,也就是继续循环。

    很可惜的是,基于历史原因——forEach 函数是 ES5 时代的函数,Promise 等异步操作的支持是 ES6 以后才有的支持——直接使用 forEach 是没有办法实现在循环体内调用异步函数的方法。

    但是,都 2021 年了,这也不代表没有解决方案。

    并行解决方案

    如果数据彼此之间没有依赖关系,其实个人更建议使用这种方式,相对而言效率会更高一些。

    实现的方式是 Promise.all 结合 awaitmap 去实现:

    • Promise.all 可以接收由 Promise 组成的数组,并且返回一个 Promise。

    • map 的特性与 forEach 相似,区别在于前者会返回一个数组,后者会返回一个 undefined。

      Promise.all 的参数正好又是一个由 Promise 组成的数组;并且,Promise.all 的返回值就是一个 Promise

    • await 是 ES7 推出的语法糖,可以用来等待一个 Promise 的执行完成。

    所以结合 Promise.allawaitmap 就可以近似同步地发送多个异步请求。之所以说是 近似,还是因为毕竟是一个迭代,总归需要按序数组中第一个元素开始执行,只不过大多数情况下,数组的迭代与异步操作比起来消耗时间可以小到近乎不计。

    实现如下:

    const getData = async () => {
      const data = await timeout();
      const curr = new Date();
      console.log(curr);
      let str = [];
      // 使用 Promise.all 去等待内部所有的 Promise 执行完毕
      await Promise.all(data.map((el) => getEl(el))).then((val) => {
        str = val;
        console.log(new Date() - curr);
        return val;
      });
      console.log(str);
    };
    
    getData();
    

    效果截图:

    可以看出,与最初使用传统的 for 循环相比,使用 Promise.all 能够有效的提升性能。当有多个较为耗时的异步任务,并且彼此之间没有依赖关系的时候,为了能够提升用户体验,最好还是使用 Promise.all 去调用。

    这是因为 await 等待的是所有的 Promise 执行完毕的结果,即锁住的是 Promise.all,而内部的 map 依旧是同步执行的。所以对于循环体内的异步函数来说,它不需要等待上一个迭代完成,再去执行下一个迭代——await 这个语法糖会等待 Promise 执行完毕再去执行下一个 Promise。

    其执行流程大概如下:

    input
    Promise All
    iteration 1
    iteration 2
    iteration 3
    ...
    iteration N
    output

    串行解决方案

    for await...of 是基于对 iterable(可迭代) 的实现,这种实现比较适合用于有依赖关系的内容。如较大文件的加载,可以通过在阅读到某一个点的时候触发下一段文件的加载,以达到提升用户体验感的效果。

    使用案例如下:

    const getData3 = async () => {
      const data = await timeout();
      const curr = new Date();
      console.log(curr);
      let str = [];
      for await (el of data) {
        const element = await getEl(el);
        console.log(element, new Date() - curr);
        str.push(element);
      }
      console.log(str);
    };
    
    getData3();
    

    效果如下:

    因为使用了 await 去等待上一个异步调用结果返回之后,再去执行下一个异步调用,因此消耗的时间也更多。

    其执行流程大概如下:

    input
    iteration 1
    iteration 2
    iteration 3
    ...
    iteration N
    output

    总结

    整体来说,在循环体内调用异步函数有以下三种方法:

    • 传统 for循环

      最传统的解决方案

    • Promise.all, awaitmap 的结合

      可以近似同步地并行调用循环体内的 API,如果需要在数组之中循环调用 API,并且 API 之间彼此没有什么关联,那么使用这个方案可以极大的提升用户体验感

    • for await...of

      for of 的异步支持版本,可以串行调用 API,在不使用其他关键字的情况下与传统的 for循环 效果一样

      但是,因为 for of 是基于迭代器实现的,这也就代表着可以通过重写迭代器去实现一些特殊的业务场景,如:

      • 视频渐进式下载

      • 页面内容分段加载

        这种效果在小说网站中用的还挺多的,为了防盗,部分小说网站在 VIP 章节中都是用图片代替文字。

    展开全文
  • Async/await 编写异步代码时,每个 async 函数都要包裹在try/catch中,代码量多了看着冗余不优雅,express又不像koa的异步机制可以订阅全局的error事件,为了解决这个问题,需要写个捕获异步函数异常的中间件。...
  • JavaScript中异步函数

    万次阅读 2019-01-12 16:17:09
    JavaScript 中常见的异步函数有:定时器,事件和ajax等,那么如何来处理这些异步函数呢,常用的方法有下面几种: 回调函数 function eat() { console.log('好的,我开动咯'); } function cooking(cb) { console...

    JavaScript 中常见的异步函数有:定时器,事件和 ajax 等,那么如何来处理这些异步函数呢,常用的方法有下面几种:

    1. 回调函数

    function eat() {
      console.log('好的,我开动咯');
    }
    
    function cooking(cb) {
      console.log('妈妈认真做饭');
      setTimeout(function () {
        console.log('小明快过来,开饭啦')
        cb();
      }, 1000);
    }
    
    function read() {
      console.log('小明假装正在读书');
    }
    
    cooking(eat);
    read();
    
    /* 执行顺序:
    妈妈认真做饭
    小明假装正在读书
    小明快过来,开饭啦
    好的,我开动咯
    */
    

    优点: 简单
    缺点: 如果有大量异步并存在依赖会形成回调地狱

    2. 事件

    function eat() {
      console.log('妈妈敲门啦,该去吃饭啦');
    }
    
    function cooking() {
      console.log('妈妈认真做饭');
      setTimeout(function () {
        console.log('小明,出来吃饭啦')
        bus.$emit('done');
      }, 3000);
    }
    
    function read() {
      console.log('小明又假装正在读书');
      bus.$on('done', eat);
    }
    
    cooking();
    read();
    /* 执行顺序:
    妈妈认真做饭
    小明又假装正在读书
    小明,出来吃饭啦
    妈妈敲门啦,该去吃饭啦
    */
    

    优点:代码解耦
    缺点:处理回调地狱需要定义和监听大量的事件

    3. 发布订阅

    function eat() {
      console.log('爸爸叫我去吃饭啦');
    }
    
    function cooking() {
      console.log('妈妈认真做饭');
      setTimeout(function () {
        console.log('孩子他爸,叫小明出来吃饭');
        Dad.publish("done");
      }, 3000);
    }
    
    function read() {
      console.log('小明依旧假装正在读书');
      Dad.subscribe('done', eat);
    }
    
    cooking();
    read();
    
    /* 执行顺序:
    妈妈认真做饭
    小明依旧假装正在读书
    孩子他爸,叫小明出来吃饭
    爸爸叫我去吃饭啦
    */
    

    优点:创建了一下中介者(Dad)来管理发布和订阅,事件越多越强大
    缺点:仍然需要定义一大堆事件

    4. promise

    function read() {
      console.log('小明认真读书');
    }
    
    function eat() {
      return new Promise((resolve, reject) => {
        console.log('好嘞,吃饭咯');
        setTimeout(() => {
          resolve('饭吃饱啦');
        }, 1000)
      })
    }
    
    function wash() {
      return new Promise((resolve, reject) => {
        console.log('唉,又要洗碗');
        setTimeout(() => {
          resolve('碗洗完啦');
        }, 1000)
      })
    }
    
    function mop() {
      return new Promise((resolve, reject) => {
        console.log('唉,还要拖地');
        setTimeout(() => {
          resolve('地拖完啦');
        }, 1000)
      })
    }
    
    const cooking = new Promise((resolve, reject) => {
      console.log('妈妈认真做饭');
      setTimeout(() => {
        resolve('小明快过来,开饭啦');
      }, 3000);
    })
    
    cooking.then(msg => {
      console.log(msg);
      return eat();
    }).then(msg => {
      console.log(msg);
      return wash();
    }).then(msg => {
      console.log(msg);
      return mop();
    }).then(msg => {
      console.log(msg);
      console.log('终于结束啦,出去玩咯')
    })
    read();
    
    /* 执行顺序:
    妈妈认真做饭
    小明认真读书
    小明快过来,开饭啦
    好嘞,吃饭咯
    饭吃饱啦
    唉,又要洗碗
    碗洗完啦
    唉,还要拖地
    地拖完啦
    终于结束啦,出去玩咯
    */ 
    

    优点: 既有回调函数的简单直观,又具备事件的状态内聚
    缺点: 错误会被吃掉,无法通过window.onerror捕获

    参考:
    https://github.com/frontend9/fe9-library/issues/14
    https://github.com/mqyqingfeng/Blog/issues/98

    展开全文
  • 主要介绍了python如何实现异步调用函数执行,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • python异步函数中调用同步函数

    千次阅读 2019-08-24 08:44:13
    异步函数调用同步函数 普通函数里面不能await,只有async函数才能await。也就是说,同步函数执行的时候会阻塞所有协程。 直接调用 如果同步函数执行的时间很短。就直接调用。 在执行器里跑 如果同步函数执行的时间很...
  • JS篇 - 异步函数执行顺序问题

    千次阅读 2019-12-05 15:08:19
    大家做笔试题的时候一定遇到过判断异步函数执行顺序的题目,包含setTimeout,setInterval,Promise,Async等等,来一道基础题,抛砖引玉一下: for (var i = 1;i < 6;i ++) { setTimeout(function fn() { ...
  • 异步函数 从任何东西(promises、streams、objects 和 async 函数)创建一个异步函数 安装 npm install --save to-async-function 例子 将任何类型的数据源转换为异步函数 var toAsyncFunction = require ( 'to-...
  • 问题:最常见的就是一个异步函数调用成功,另一个函数需要用到这个接口的返回值或者处理值,由于异步机制问题,可能会导致下一个函数还没有拿到上一个函数的返回值就开始调用了,这个时候我们可以通过回调函数解决...
  • 一个小工具,用于将基于回调的异步函数转换为基于承诺的异步函数。 var promisify = require('promisify-node-callback'), readFile = promisify( require('fs').readFile ); readFile('./package.json')....
  • 在进行多个异步函数调用时,有一些请求必须一个接一个链接在一起,而另一些请求可以同时执行,因为它们不相互依赖。 在后一种情况下,能够在所有同时请求完成后执行单个回调方法很重要。 AsyncBatch 是一个 Java ...
  • Vuex 同步函数 异步函数 getters

    千次阅读 2019-09-24 18:32:02
    actions: { //放异步函数的地儿 add2s(context,person){ setTimeout(item=>{ context.commit('add',person) },2000) } } }) App.vue: <h1>App标题 姓名:<input type="text" v-model='name'></div>...
  • Create-Async-Functions-Fetch-Remote:编写异步函数并使用asyncawait进行调用调用getRandomNumber的函数返回诺言在诺言中,编写一个setTimeout()将在0.5秒后使用随机数解析诺言编写一个异步函数,该函数调用get...
  • 异步函数调用与实现

    2019-01-02 16:07:54
    写了个小DEMO private void button1_Click(object sender, EventArgs e) { Task.Run(() =&gt; { for (int i = 0; i &lt; 100; i++) { ...
  • 关于JS同步函数和异步函数

    千次阅读 2019-03-10 10:35:26
    关于JS中的同步函数和异步函数 自己个人的理解: 同步函数:同步函数是顺序执行的,如果这自上而下的过程很长,那么该线程就会一直挂起,知道函数返回,才能让该线程重新调度 异步函数:当该线程遇到譬如此类,就会执行下一...
  • js 中异步函数之所以特别,一个重要的原因就是它执行完成的时间、耗费的时间靠人的主观是不得而知的。所以不能靠设置定时函数来让上一个程式完成之后来进行下一个函数。 接上次的博客:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 533,586
精华内容 213,434
关键字:

异步函数