Nodejs回調加超時限制兩種實現(xiàn)方法

更新時間：2017年06月09日 11:47:05 作者：小水熊

這篇文章主要介紹了Nodejs回調加超時限制兩種實現(xiàn)方法的相關資料,需要的朋友可以參考下

Nodejs回調加超時限制兩種實現(xiàn)方法

Nodejs下的IO操作都是異步的，有時候異步請求返回太慢，不想無限等待回調怎么辦呢？我們可以給回調函數(shù)加一個超時限制，到一定時間還沒有回調就表示失敗，繼續(xù)后面的步驟。

方案1：用async的parallel實現(xiàn)

在這里我用到了async的parallel方法，parallel可以讓若干個異步回調的方法并行執(zhí)行，正常情況下，所有回調函數(shù)都完成后會匯集到parallel最終的回調函數(shù)里，但是有一種例外，如果其中一個步驟有錯誤拋出并直接調用parallel最終的回調函數(shù)，利用這個特點就可以實現(xiàn)我們要的功能。

我封裝了一個函數(shù)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,//異步函數(shù)
   10000,//超時時間
   'arg1_value',//異步函數(shù)的參數(shù)1
   'arg2_value',//異步函數(shù)的參數(shù)2，有多個參數(shù)就在后面繼續(xù)加
   (err, results)=>{
    //results : [result_1, result_2]
    //最后的回調,results比較特殊，fn有多個返回值時，results會以數(shù)組的形式返回給你
   }
);

這種方案的好處是對node沒有最低版本要求，引入async庫就可以用，缺陷是最終返回的值都是在一個參數(shù)里面以數(shù)組的形式呈現(xiàn)。

方案2：用Promise實現(xiàn)

在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,//異步函數(shù)
   10000,//超時時間
   'arg1_value',//異步函數(shù)的參數(shù)1
   'arg2_value',//異步函數(shù)的參數(shù)2，有多個參數(shù)就在后面繼續(xù)加
   (err, result_1, result_2)=>{
    //最后的回調
   }
);

這種方案要求nodejs版本高于5.0，支持Promise。

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

您可能感興趣的文章: