duanguai2781
duanguai2781
2017-05-29 16:23

如何控制NodeJS中的应用程序流

已采纳

I'm writing my first application in nodeJS. I'm writing a telegram bot, and i was wondering how to control the flow of the application given it asynchronous nature. I come from a php background where everything was simple, procedural, one after the other.

Lets say, in my bot, when any message is received, first the program must make sure the user details are in the cache or database before proceeding. After the check is done it can proceed.

I was going to do this by using a variable for a flag, but it cannot be done because of the asynchronous nature of javascript. I have no idea how to go about doing this. Do i assign listeners to an object and emit events to control the flow?

Here is my code

    const fs = require('fs');

// Establish connection with cache and database
const mysql = require('mysql-wrapper');
const Memcached = require('memcached');
const memcached = new Memcached('localhost:11211');
const bb = require('bot-brother');

var settings = {
    host: 'localhost',
    database: 'test',
    user: 'root',
};
var qb = require('node-querybuilder').QueryBuilder(settings, 'mysql', 'single');

//Load the database cache functions
const dbc = require("./dbc");
dbc.memcached = memcached;
dbc.mysqc = qb;

//Load the user handling functions 
const user = require("./user");
user.dbc = dbc;

const bot = bb({
    key : '331263599:AAHmLl4Zcg4sKGnz7GNzacgkJl1W8lwz33c',
    polling: { interval: 0, timeout: 1 }
});

//code that checks user existence in cache/db
bot.api.on('message', (msg)=>{
    console.log(msg.from);
    var userData = msg.from;
    var tid = userData.id;
    //Check if user is in cache 
    user.check_user_existence(tid,function(re){
        if(re < 2){
            user.complete_user_existence(re,userData,function(err,response){
                if(err){
                    bot.api.sendMessage(tid,"Sorry an unexpected error occured!");
                } else {
                    console.log('ha');
                    play = 1;
                }
            });
        } 

    });
});


//Code to be run after checking 
if(play==1){
    send_another_message();
    do_some_things();
}
  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享
  • 邀请回答

2条回答

  • douwu5009 douwu5009 4年前

    You can use callbacks or promises You can use async module or mutexes

    If you need serialize some asynchronous functions you can use one of this approaches:

    Callback

    Native promises

    Bluebird promise

    Async module

    Callback and Promise mostly used for related functions which second function needs first function .bluebird is a module for creating promises and having full customize on it.

    Async module is good way to run functions asynchronous and get result of them together.

    Last way is Mutex if you had asynchronous write in single object or file you need lock-release approach

    点赞 评论 复制链接分享
  • dongzhanlian6289 dongzhanlian6289 4年前

    You can run code synchronously via nsynjs. Your code may transform like this:

    Step 1. Wrap slow functions with callbacks into nsynjs-aware wrappers:

    // content of wrappers.js
    user = require("./user");
    exports.user_check_user_existence_wrapper = function (ctx, uid) {
        var res = {};
    
        user.check_user_existence(tid,function(re){
            res.re = re;
            ctx.resume();
        })
    
        return res;
    };
    exports.user_check_user_existence_wrapper.nsynjsHasCallback = true;
    
    exports.user_complete_user_existence_wrapper = function(ctx, re, userData) {
        var res = {};
    
        user.complete_user_existence(tid,function(error,ue_response){
            res.error = error;
            res.ue_response = ue_response;
            ctx.resume(error); // if error is set, it will cause exception in the caller
        })
    
        return res;
    };
    exports.user_complete_user_existence_wrapper.nsynjsHasCallback = true;
    

    Step 2. Put your synchronous logic into function, use wrappers from above to execute slow functions:

    var synchronousCode = function(wrappers,msg) {
        console.log(msg.from);
        var userData = msg.from;
        var tid = userData.id;
        //Check if user is in cache 
        var re = wrappers.user_check_user_existence_wrapper(nsynjsCtx,tid).re;
        if(re < 2)
            try {
                var res = wrappers.user_complete_user_existence_wrapper(re,userData).ue_response;
                console.log('ha');
                play = 1;
            }
            catch (e) {
                bot.api.sendMessage(tid,"Sorry an unexpected error occured!",e);
            };
    }
    

    Step 3. Run your synchronous function via nsynjs:

    var nsynjs = require('nsynjs');
    var wrappers = require('./wrappers');
    var synchronousCode = function(wrappers,msg) {
    ....
    }
    
    bot.api.on('message', function(msg) {
        nsynjs.run(synchronousCode,{},wrappers,msg,function(){
            console.log('synchronousCode finished');
        })
    });
    

    Please see more examples here: https://github.com/amaksr/nsynjs/tree/master/examples/node-module-loading

    点赞 评论 复制链接分享

为你推荐