给Nodejs回调加超时限制

2019独角兽企业重金招聘Python工程师标准>>>

Nodejs下的IO操作都是异步的，有时候异步请求返回太慢，不想无限等待回调怎么办呢？我们可以给回调函数加一个超时限制，到一定时间还没有回调就表示失败，继续后面的步骤。

方案1：用async的parallel实现

在这里我用到了async的parallel方法，parallel可以让若干个异步回调的方法并行执行，正常情况下，所有回调函数都完成后会汇集到parallel最终的回调函数里，但是有一种例外，如果其中一个步骤有错误抛出并直接调用parallel最终的回调函数，利用这个特点就可以实现我们要的功能。

我封装了一个函数asyncWrapper， 逻辑比较简单，直接看代码：

async-timer.js

const async = require('async');

const asyncWrapper = (fn, interval, ...args) =>{
    let final_callback = args[args.length-1];
    async.parallel([
        function(callback){
            args[args.length - 1] = callback;
            fn.apply(this, args);
        },
        function(callback){
            setTimeout(function(){
                callback(408);
            }, interval);
        }
    ],
    function(err, results){
        if(err==408 && results[0])err = null;
        final_callback.apply(this,[err].concat([results[0]]));
    });
}

if(module.parent){
    exports.asyncWrapper = asyncWrapper;
}else{
    let myfn = (arg_1, arg_2, callback) => {
        setTimeout(function(){
            callback(null,'value 1: '+arg_1,'value 2: '+arg_2);
        }, 1000);
    }
    asyncWrapper(myfn, 2000, 10, 20, (err, values)=>{
        console.log(`${err}, ${values}`);
    });
}

你可以直接运行这个js看看效果：

node async-timer.js

 

模块调用方法：

const asyncWrapper = require('./async-timer.js').asyncWrapper


const fn = (arg1, arg2, callback) => {
      //...假设这里过程很漫长，有可能超时
      callback(null, result_1, result_2);
}

asyncWrapper(
     fn,//异步函数
     10000,//超时时间
     'arg1_value',//异步函数的参数1
     'arg2_value',//异步函数的参数2，有多个参数就在后面继续加
     (err, results)=>{
        //results : [result_1, result_2]
        //最后的回调,results比较特殊，fn有多个返回值时，results会以数组的形式返回给你
     }
);

这种方案的好处是对node没有最低版本要求，引入async库就可以用，缺陷是最终返回的值都是在一个参数里面以数组的形式呈现。

方案2：用Promise实现

在promise里面加settimeout，超过时间就reject。

promise-timer.js

const promiseWrapper = (fn, interval, ...args) =>{
	let final_callback = args[args.length-1];
	new Promise((resolve, reject)=>{
		args[args.length - 1] = (err, ...vals)=>{
			if(err)reject(err);
			else resolve(vals);
		};
        fn.apply(this, args);
        setTimeout(_=>{
        	reject('Promise time out');
        }, interval);
	})
	.then(
		result => {
			final_callback.apply(this, [null].concat(result));
		}
		)
    .catch(err=>{
    	final_callback(err);
    })
}


if(module.parent){
    exports.promiseWrapper = promiseWrapper;
}else{
    let myfn = (arg_1, arg_2, callback) => {
        setTimeout(function(){
            callback(null,'value 1: '+arg_1,'value 2: '+arg_2);
        }, 1000);
    }
    promiseWrapper(myfn, 1000, 10, 20, (err, value_1, value_2)=>{
        console.log(`${err}, value 1: ${value_1} ... value 2: ${value_2}`);
    });
}

模块调用方法：

const asyncWrapper = require('./promise-timer.js').promiseWrapper


const fn = (arg1, arg2, callback) => {
      //...假设这里过程很漫长，有可能超时
      callback(null, result_1, result_2);
}

promiseWrapper(
     fn,//异步函数
     10000,//超时时间
     'arg1_value',//异步函数的参数1
     'arg2_value',//异步函数的参数2，有多个参数就在后面继续加
     (err, result_1, result_2)=>{
        //最后的回调
     }
);

这种方案要求nodejs版本高于5.0，支持Promise。

转载于:https://my.oschina.net/waterbear/blog/916641