优化程序结构：避免回调地狱

最新推荐文章于 2024-03-12 21:21:28 发布
最新推荐文章于 2024-03-12 21:21:28 发布
阅读量3.1k 收藏 3
点赞数 4
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jdh99/article/details/72598819
版权

优化程序结构：避免回调地狱


本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.


环境：

主机:WIN10

开发环境:Android Studio 2.2 Preview 3


说明：

在编程中，经常会处理到回调函数。如果一个模块中回调函数过多，特别是在回调中处理的业务还有回调，就会导致回调嵌套。这就会导致代码结构混乱，俗称回调地狱。如下图：

来源：https://kongwsh.github.io/2016/09/11/callback/


经过思考，单片机项目中的编程经验可以应用在此处解决问题。

回调本质上是异步，类似单片机的中断。受限于单片机的主频较低，一般不在中断中处理复杂逻辑，而仅是产生信号，由状态机捕捉此信号，然后在主流程中进行处理。


单片机编程的语言是C，是面向过程的语言。在java等高级语言中，都是以面向对象编程思路为主。但处理业务流程时，恰恰是面向过程的。


参照以上思路，解决方案如下：

在回调中并不处理业务，而仅是产生信号，保存参数，然后触发状态机处理业务，这样就能让程序结构足够清晰。


源代码：

更改之前的代码：

package com.bazhangkeji.classroom.session.create;

import com.bazhangkeji.classroom.common.Events;
import com.bazhangkeji.classroom.common.RxBus;
import com.bazhangkeji.classroom.structure.SessionInfo;
import com.bazhangkeji.classroom.login.LoginState;
import com.bazhangkeji.classroom.net.Protocol;
import com.bazhangkeji.classroom.net.TcpClient;
import com.bazhangkeji.classroom.repository.cache.SessionCache;

import java.util.ArrayList;

import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

public class CreateSessionManager implements Protocol{
    private GetSessionServerAddress getSessionServerAddress;
    private CreateSession createSession;
    private CreateSessionSuccess createSessionSuccess;

    private OnResultListener observer;
    private boolean isStart = false;
    private SessionInfo sessionInfo;
    private String dstId;

    private Disposable disposableListen;

    public CreateSessionManager() {
        getSessionServerAddress = new GetSessionServerAddress();
        createSession = new CreateSession();
        createSessionSuccess = new CreateSessionSuccess();

        sessionInfo = new SessionInfo();
    }

    /**
     * 创建1V1语音会话
     * @param dstId: 对方id
     */
    public void create1V1Voice(String dstId, OnResultListener observer) {
        if (isStart) {
            return;
        }

        sessionInfo.init();
        sessionInfo.owner = LoginState.getInstance().getUserId();
        sessionInfo.type = SESSION_TYPE_1V1_VOICE;
        sessionInfo.members.add(LoginState.getInstance().getUserId());
        sessionInfo.members.add(dstId);
        this.dstId = dstId;
        start(observer);
    }

    /**
     * 创建1V1视频会话
     * @param dstId: 对方id
     */
    public void create1V1Video(String dstId, OnResultListener observer) {
        if (isStart) {
            return;
        }

        sessionInfo.init();
        sessionInfo.owner = LoginState.getInstance().getUserId();
        sessionInfo.type = SESSION_TYPE_1V1_VIDEO;
        sessionInfo.members.add(LoginState.getInstance().getUserId());
        sessionInfo.members.add(dstId);
        this.dstId = dstId;
        start(observer);
    }

    /**
     * 创建1VN语音会话
     * @param groupId: 群组id
     * @param audioChannel: 语音通道
     * @param members: 成员列表
     */
    public void create1VN(String groupId, String audioChannel, ArrayList<String> members, OnResultListener observer) {
        if (isStart) {
            return;
        }

        sessionInfo.init();
        sessionInfo.owner = LoginState.getInstance().getUserId();
        sessionInfo.groupId = groupId;
        sessionInfo.audioChannel = audioChannel;
        sessionInfo.type = SESSION_TYPE_1VN;
        sessionInfo.members.addAll(members);
        start(observer);
    }

    private void start(OnResultListener observer) {
        if (isStart) {
            return;
        }

        stop();
        isStart = true;
        this.observer = observer;

        getSessionServerAddress.start(new GetSessionServerAddress.OnResultListener() {
            @Override
            public void notifySuccess(Object observable, String ip, int port) {
                sessionInfo.sessionServerIp = ip;
                sessionInfo.sessionServerPort = port;
                disposableListen = RxBus.getInstance().toObservable(Events.TcpMakeConnectResult.class)
                        .observeOn(Schedulers.io())
                        .subscribe(t -> dealTcpMakeConnectResult((Events.TcpMakeConnectResult)t));
                TcpClient.getInstance().makeConnect(ip, port);
            }

            @Override
            public void notifyFailure(Object observable) {
                observer.notifyFailure(this, OnResultListener.GET_SESSION_SERVER_ADDRESS_TIMEOUT);
                stop();
            }
        });
    }

    private void dealTcpMakeConnectResult(Events.TcpMakeConnectResult connectResult) {
        disposableListen.dispose();
        if (connectResult.result) {
            switch (sessionInfo.type) {
                case SESSION_TYPE_1V1_VOICE:
                    createSession.create1V1Voice(dstId, new ObserverCreateSession());
                    break;
                case SESSION_TYPE_1V1_VIDEO:
                    createSession.create1V1Video(dstId, new ObserverCreateSession());
                    break;
                case SESSION_TYPE_1VN:
                    createSession.create1VN(sessionInfo.groupId, sessionInfo.audioChannel, sessionInfo.members, new ObserverCreateSession());
                    break;
            }
        } else {
            observer.notifyFailure(this, OnResultListener.WAIT_TCP_CONNECT_TIMEOUT);
            stop();
        }
    }

    /**
     * 停止
     */
    public void stop() {
        if (disposableListen != null && !disposableListen.isDisposed()) {
            disposableListen.dispose();
        }
        getSessionServerAddress.releaseResource();
        createSession.releaseResource();
        isStart = false;
    }

    /**
     * 是否忙碌
     * @return true:忙碌.false:空闲
     */
    public boolean isBusy() {
        return isStart;
    }

    class ObserverCreateSession implements CreateSession.OnResultListener {

        @Override
        public void notifySuccess(Object observable, SessionInfo sessionInfo) {
            SessionCache.getInstance().joinSession(CreateSessionManager.this.sessionInfo);
            createSessionSuccess.sendFrame();
            observer.notifySuccess(CreateSessionManager.this, CreateSessionManager.this.sessionInfo);
            stop();
        }

        @Override
        public void notifyFailure(Object observable, int result) {
            observer.notifyFailure(CreateSessionManager.this, result);
            stop();
        }
    }

    public interface OnResultListener {
        // 结果
        int SUCCESS = 0;
        int GROUP_NOT_EXIST = 1;
        int NOT_OWNER = 2;
        int SESSION_MEMBERS_TOO_MANY = 3;
        int TCP_DISCONNECT = 4;
        int CREATE_SESSION_TIMEOUT = 5;
        int GET_SESSION_SERVER_ADDRESS_TIMEOUT = 6;
        int WAIT_TCP_CONNECT_TIMEOUT = 7;

        /**
         * 创建会话成功
         * @param observable: 被观察者
         * @param sessionInfo: 会话信息
         */
        void notifySuccess(Object observable, SessionInfo sessionInfo);

        /**
         * 创建会话失败
         * @param observable: 被观察者
         * @param result: 结果
         */
        void notifyFailure(Object observable, int result);
    }
}


更改之后的代码：

package com.bazhangkeji.classroom.session.create;

import com.bazhangkeji.classroom.common.Events;
import com.bazhangkeji.classroom.common.RxBus;
import com.bazhangkeji.classroom.structure.SessionInfo;
import com.bazhangkeji.classroom.login.LoginState;
import com.bazhangkeji.classroom.net.Protocol;
import com.bazhangkeji.classroom.net.TcpClient;
import com.bazhangkeji.classroom.repository.cache.SessionCache;

import java.util.ArrayList;

import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

public class CreateSessionManager implements Protocol{
    private final int S_FREE = 0;
    private final int S_GET_SESSION_SERVER_ADDRESS = 1;
    private final int S_TCP_MAKE_CONNECT = 2;
    private final int S_CREATE_SESSION = 3;

    // 状态机
    private int stateMachine;
    private boolean stateFirstRun;
    // 信号
    private Signal signal;

    private OnResultListener observer;
    private SessionInfo sessionInfo;
    private String dstId;
    private int createSessionFailureResult;

    // 业务
    private GetSessionServerAddress getSessionServerAddress;
    private CreateSession createSession;
    private CreateSessionSuccess createSessionSuccess;

    private Disposable disposableListen;

    public CreateSessionManager() {
        stateMachine = S_FREE;
        stateFirstRun = true;
        signal = new Signal();
        
        getSessionServerAddress = new GetSessionServerAddress();
        createSession = new CreateSession();
        createSessionSuccess = new CreateSessionSuccess();

        sessionInfo = new SessionInfo();
    }

    private void stateMachineRun() {
        for (int i = 0; i < 2; i++) {
            switch (stateMachine) {
                case S_FREE:
                    s_free();
                    break;
                case S_GET_SESSION_SERVER_ADDRESS:
                    s_get_session_server_address();
                    break;
                case S_TCP_MAKE_CONNECT:
                    s_tcp_make_connect();
                    break;
                case S_CREATE_SESSION:
                    s_create_session();
                    break;
            }
        }
    }

    private void s_free() {
        if (signal.sigStart) {
            signal.init();
            stateFirstRun = true;
            stateMachine = S_GET_SESSION_SERVER_ADDRESS;
        }
    }

    private void s_get_session_server_address() {
        if (stateFirstRun) {
            stateFirstRun = false;
            getSessionServerAddress.start(new ListenGetSessionServerAddress());
        }

        if (signal.sigGetSessionServerAddressFailure) {
            observer.notifyFailure(this, OnResultListener.GET_SESSION_SERVER_ADDRESS_TIMEOUT);
            stop();
        } else if (signal.sigGetSessionServerAddressSuccess) {
            signal.init();
            stateFirstRun = true;
            stateMachine = S_TCP_MAKE_CONNECT;
        }
    }

    private void s_tcp_make_connect() {
        if (stateFirstRun) {
            stateFirstRun = false;

            disposableListen = RxBus.getInstance().toObservable(Events.TcpMakeConnectResult.class)
                    .observeOn(Schedulers.io())
                    .subscribe(t -> dealTcpMakeConnectResult((Events.TcpMakeConnectResult) t));
            TcpClient.getInstance().makeConnect(sessionInfo.sessionServerIp, sessionInfo.sessionServerPort);
        }
        
        if (signal.sigTcpMakeConnectFailure) {
            observer.notifyFailure(this, OnResultListener.WAIT_TCP_CONNECT_TIMEOUT);
            stop();
        } else if (signal.sigTcpMakeConnectSuccess) {
            signal.init();
            stateFirstRun = true;
            stateMachine = S_CREATE_SESSION;
        }
    }

    private void s_create_session() {
        if (stateFirstRun) {
            stateFirstRun = false;

            switch (sessionInfo.type) {
                case SESSION_TYPE_1V1_VOICE:
                    createSession.create1V1Voice(dstId, new ListenCreateSession());
                    break;
                case SESSION_TYPE_1V1_VIDEO:
                    createSession.create1V1Video(dstId, new ListenCreateSession());
                    break;
                case SESSION_TYPE_1VN:
                    createSession.create1VN(sessionInfo.groupId, sessionInfo.audioChannel, sessionInfo.members, new ListenCreateSession());
                    break;
            }
        }
        
        if (signal.sigCreateSessionFailure) {
            observer.notifyFailure(CreateSessionManager.this, createSessionFailureResult);
            stop();
        } else if (signal.sigCreateSessionSuccess) {
            SessionCache.getInstance().joinSession(CreateSessionManager.this.sessionInfo);
            createSessionSuccess.sendFrame();
            observer.notifySuccess(CreateSessionManager.this, CreateSessionManager.this.sessionInfo);
            stop();
        }
    }

    /**
     * 停止
     */
    public void stop() {
        signal.init();
        stateFirstRun = true;

        getSessionServerAddress.releaseResource();
        createSession.releaseResource();

        if (disposableListen != null && !disposableListen.isDisposed()) {
            disposableListen.dispose();
        }
        
        stateMachine = S_FREE;
    }

    private void dealTcpMakeConnectResult(Events.TcpMakeConnectResult connectResult) {
        disposableListen.dispose();
        if (connectResult.result) {
            signal.sigTcpMakeConnectSuccess = true;
            stateMachineRun();
        } else {
            signal.sigTcpMakeConnectFailure = true;
            stateMachineRun();
        }
    }

    class ListenGetSessionServerAddress implements GetSessionServerAddress.OnResultListener {

        @Override
        public void notifySuccess(Object observable, String ip, int port) {
            sessionInfo.sessionServerIp = ip;
            sessionInfo.sessionServerPort = port;
            signal.sigGetSessionServerAddressSuccess = true;
            stateMachineRun();
        }

        @Override
        public void notifyFailure(Object observable) {
            signal.sigGetSessionServerAddressFailure = true;
            stateMachineRun();
        }
    }

    class ListenCreateSession implements CreateSession.OnResultListener {

        @Override
        public void notifySuccess(Object observable, SessionInfo sessionInfo) {
            signal.sigCreateSessionSuccess = true;
            stateMachineRun();
        }

        @Override
        public void notifyFailure(Object observable, int result) {
            createSessionFailureResult = result;
            signal.sigCreateSessionFailure = true;
            stateMachineRun();
        }
    }

    /**
     * 创建1V1语音会话
     * @param dstId: 对方id
     */
    public void create1V1Voice(String dstId, OnResultListener observer) {
        if (stateMachine != S_FREE) {
            return;
        }

        this.observer = observer;

        sessionInfo.init();
        sessionInfo.owner = LoginState.getInstance().getUserId();
        sessionInfo.type = SESSION_TYPE_1V1_VOICE;
        sessionInfo.members.add(LoginState.getInstance().getUserId());
        sessionInfo.members.add(dstId);
        this.dstId = dstId;

        signal.sigStart = true;
        stateMachineRun();
    }

    /**
     * 创建1V1视频会话
     * @param dstId: 对方id
     */
    public void create1V1Video(String dstId, OnResultListener observer) {
        if (stateMachine != S_FREE) {
            return;
        }

        this.observer = observer;

        sessionInfo.init();
        sessionInfo.owner = LoginState.getInstance().getUserId();
        sessionInfo.type = SESSION_TYPE_1V1_VIDEO;
        sessionInfo.members.add(LoginState.getInstance().getUserId());
        sessionInfo.members.add(dstId);
        this.dstId = dstId;

        signal.sigStart = true;
        stateMachineRun();
    }

    /**
     * 创建1VN语音会话
     * @param groupId: 群组id
     * @param audioChannel: 语音通道
     * @param members: 成员列表
     */
    public void create1VN(String groupId, String audioChannel, ArrayList<String> members, OnResultListener observer) {
        if (stateMachine != S_FREE) {
            return;
        }

        this.observer = observer;

        sessionInfo.init();
        sessionInfo.owner = LoginState.getInstance().getUserId();
        sessionInfo.groupId = groupId;
        sessionInfo.audioChannel = audioChannel;
        sessionInfo.type = SESSION_TYPE_1VN;
        sessionInfo.members.addAll(members);

        signal.sigStart = true;
        stateMachineRun();
    }

    /**
     * 是否忙碌
     * @return true:忙碌.false:空闲
     */
    public boolean isBusy() {
        return stateMachine == S_FREE;
    }

    class Signal {
        boolean sigStart = false;
        boolean sigGetSessionServerAddressSuccess = false;
        boolean sigGetSessionServerAddressFailure = false;
        boolean sigTcpMakeConnectSuccess = false;
        boolean sigTcpMakeConnectFailure = false;
        boolean sigCreateSessionSuccess = false;
        boolean sigCreateSessionFailure = false;

        void init() {
            sigStart = false;
            sigGetSessionServerAddressSuccess = false;
            sigGetSessionServerAddressFailure = false;
            sigTcpMakeConnectSuccess = false;
            sigTcpMakeConnectFailure = false;
            sigCreateSessionSuccess = false;
            sigCreateSessionFailure = false;
        }
    }

    public interface OnResultListener {
        // 结果
        int SUCCESS = 0;
        int GROUP_NOT_EXIST = 1;
        int NOT_OWNER = 2;
        int SESSION_MEMBERS_TOO_MANY = 3;
        int TCP_DISCONNECT = 4;
        int CREATE_SESSION_TIMEOUT = 5;
        int GET_SESSION_SERVER_ADDRESS_TIMEOUT = 6;
        int WAIT_TCP_CONNECT_TIMEOUT = 7;

        /**
         * 创建会话成功
         * @param observable: 被观察者
         * @param sessionInfo: 会话信息
         */
        void notifySuccess(Object observable, SessionInfo sessionInfo);

        /**
         * 创建会话失败
         * @param observable: 被观察者
         * @param result: 结果
         */
        void notifyFailure(Object observable, int result);
    }
}





jdh99
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
解决异步回调地狱的三种方法（promise、async/await、generator）
肖的博客
04-12 7768
promise 地址：https://blog.csdn.net/lucky541788/article/details/83473401 async/await 地址：https://blog.csdn.net/lucky541788/article/details/88116387 generator this.$http.get('/data1', data1, (res, err) =...
JavaScript中避免回调地狱方法
Andy Tools
06-20 7946
在使用JavaScript时，为了实现某些逻辑经常会写出层层嵌套回调函数，如果嵌套过多，会极大影响代码可读性和逻辑，这种情况也被成为回调地狱(callback hell)。我们不能一直容忍这种code存在在代码中。 1 什么是回调地狱(callback hell) 2 如何避免 2.1 解决回调嵌套问题（ES6 promise） 2.2 ES6 co/yield方案 2.2.1 什么是G...
如何处理嵌套的回调并避免“回调地狱”
cumi6497的博客
08-07 862
JavaScript is a strange language. Once in a while, you have to deal with a callback that’s in another callback that’s in yet another callback. JavaScript是一种奇怪的语言。 有时，您必须处理另一个回调中的另一个回调。 People affecti...
什么是回调地狱
最新发布
Mxy18851251178的博客
03-12 302
为了解决这个问题，程序员可以采用一些策略，如使用Promise、async/await等技术来简化异步编程，避免回调函数的嵌套。具体来说，当需要执行多个异步操作时，为了保证操作的顺序性，程序员可能会将回调函数嵌套在另一个回调函数中。例如，第一个异步操作完成后，调用第二个异步操作，并在第二个异步操作的回调函数中处理结果。如果这样的嵌套层级过多，代码就会变得难以阅读和维护，形成了所谓的“回调地狱”。总之，回调地狱是编程中需要避免的一种情况，通过合理的编程技巧和工具，可以有效地解决这个问题。
如何避免回调地狱
subsistent的博客
03-27 171
promise只有两个状态resolve和reject，当它触发任何一个状态后，它会将当前的值缓存起来，并在有回调函数添加进来的时候尝试调用回调函数，如果这个时候还没有触发resolve或者reject，那么回调函数会被缓存，等待调用，如果已经有了状态(resolve或者reject)，则立刻调用回调函数。并且所有回调函数在执行后都立即被销毁。它就是 Generator 函数的语法糖，async函数就是将 Generator 函数的星号（*）替换成async，将yield替换成await，仅此而已。
回调函数与回调地狱及其解决方法 | JavaScript
qq_42376600的博客
10-13 1958
回调函数与回调地狱及其解决方法 JavaScript
The life circle of Activity in andrid
WuNJIT的博客
09-17 115
package com.codecademy.myactivity; import androidx.appcompat.app.AppCompatActivity; import android.app.Activity; import android.os.Bundle; import android.widget.Toast; public class MainActivity extends AppCompatActivity { @Override // Bundle savedI
使用Promise解决回调地狱
01-08
那么什么是回调地狱呢？言简意赅的来讲就是我在回调函数里面调用了回调函数又在调用的回调函数的回调函数里面调用了回调函数……就像下图中的代码一样 说是千层饼有点差不多，说是俄罗斯套娃也不为过，就是一个套一...
增强微信小程序API，远离回调地狱
03-29
而小程序的API的设计，都是采用回调形式。这样，业务过于复杂的时候，就会陷入回调地狱中，而且代码的可读性也变差。 材料准备 提到异步编程，Promise就该闪亮登场了。 Promise 微信小程序有众多的API，总不能用到...
ES6之Promise解决回调地狱
01-20
目录回调函数：回调地狱：Promise介绍：Promise解决回调地狱： 回调函数：  在一个函数里面以形参的方式调用一个传递进来的函数。 例如： function a(callback){ callback(); } a(function(){ }) 回调地狱：  回...
浅谈js中的回调地狱问题
01-08
回调地狱 由多层嵌套的回调函数组成的代码称为回调地狱，多数在写阻塞执行代码的时候会产生。回调地狱的代码可读性差，很难让人弄清楚业务逻辑。 下面便是回调地狱的代码： function callbackFn(callback){ ...
回调地狱和Promise使用（详解）
01-08
回调地狱和Promise 1.回调函数的作用及回调地狱 先说一下什么是回调函数的作用 1.1在js中我们会使用很多的异步方法，例如定时器，ajax还有node中的fs 1.2 很多时候我们需要拿到这个异步函数里面的一些数据，但是通过...
回调“地狱”与反应模式
liululee的博客
06-28 208
点击左上角蓝字，关注“锅外的大佬”专注分享国外最新技术内容了解更多有关基于反应流的方法以及如何避免回调地狱的信息。更好地理解基于反应流的方法的有用性的方法之一是它如何简化...
回调地狱和反应模式
最佳 Java 编程
06-13 254
我可以更好地了解a的用途的一种方式 基于反应流的方法是它简化了无阻塞IO调用的方式。 这篇文章将快速讲解进行同步远程调用所涉及的那种代码，然后说明如何在非阻塞IO中分层，尽管在资源（尤其是线程）的使用方面非常高效，但会带来称为回调地狱的复杂性，并且基于反应流的方法如何简化编程模型。 目标服务 由于我将编写一个客户呼叫，因此代表城市详细信息的目标服务有两个端点。 当使用uri类型的“...
AJAX-解决回调函数地狱问题
前端程序员、项目经理、人工智能博主
11-07 840
async函数是使用async关键字声明的函数。async函数是AsyncFunction构造函数的实例，并且其中运行使用await关键字。async和await关键字让我们可以用一种更简洁的方式写出基于Promise的异步行为而无需刻意地链式调用promise。
一文告诉你什么是回调地狱，如何解决回调地狱？
热门推荐
qq_42698326的博客
12-13 4万+
文章目录前言一、回调地狱是什么？二、如何解决回调地狱1.Promise2.async/await总结 前言 在正式了解“回调地狱”之前，我们先了解两个概念： 回调函数 当一个函数作为参数传入另一个参数中，并且它不会立即执行，只有当满足一定条件后该函数才可以执行，这种函数就称为回调函数。我们熟悉的定时器和Ajax中就存在有回调函数： setTimeout(function(){ //function(){console.log('执行了回调函数')}就是回调函数，它只有在3秒后才会执行 consol
回调地狱的解决方式总结
前端小白菜
07-29 9374
回调地狱解决方法总结
如何更优雅的书写Javascript之告别回调地狱
vuturn的专栏
04-13 7187
什么是回调地狱？ PS: 某大牛说过，世上本没有多层回调嵌套，写的人多了也便有了。 下面我们举个例子 在使用jquery animat做多个动画效果的时候，可能很多的童鞋写出过如下的代码。  代码如下 复制代码 // 在前一个动画执行完成后，紧接着执行下一个动画 $('xx').animate({xxxx}, function(){   
Promise的前世今生和妙用技巧
weixin_33800463的博客
10-22 191
浏览器事件模型和回调机制 JavaScript作为单线程运行于浏览器之中，这是每本JavaScript教科书中都会被提到的。同时出于对UI线程操作的安全性考虑，JavaScript和UI线程也处于同一个线程中。因此对于长时间的耗时操作，将会阻塞UI的响应。为了更好的UI体验，应该尽量的避免JavaScript中执行较长耗时的操作（如大量for循环的对象diff等）或者是长时间I/O阻塞的...
unicloud避免回调地狱
09-11
Unicloud提供了一种避免回调地狱的机制。通过使用async/await语法，可以以同步的方式编写异步代码，使代码更加清晰易读。在Unicloud中，可以使用async关键字定义一个异步函数，并在其中使用await关键字来等待一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值