Javascript 需要关于节点js异步无限循环的帮助吗

我试着用这个 辅导的 我尝试了

async.parallel（）

，我想一次又一次地循环一些函数。但它被卡在第一个，并没有无限循环。关于这件事，谁能给我提个建议吗

编辑：代码：添加了两个应该一次又一次删除的函数

var util = require('util');
var async = require('async');
var SensorTag = require('./index');
var USE_READ = true;

SensorTag.discover(function(sensorTag) {
    console.log('discovered: ' + sensorTag);

var items = [9000];
var asyncTasks = [];

items.forEach(function(item){
  // We don't actually execute the async action here
  // We add a function containing it to an array of "tasks"
    asyncTasks.push(function(callback){
        console.log('connectAndSetUp');
        sensorTag.connectAndSetUp(callback);
    }),

    asyncTasks.push(function(callback){
        console.log('readDeviceName');
        sensorTag.readDeviceName(function(error, deviceName) {
            console.log('\tdevice name = ' + deviceName);
            callback();
        });
    });
});

asyncTasks.push(function(callback){
  // Set a timeout for 3 seconds
    setTimeout(function(){
    // It's been 3 seconds, alert via callback
    callback();
    }, 3000);
});

//async.parallel(asyncTasks, function(){
//console.log('DONE');

async.parallel(asyncTasks, function(){
  // All tasks are done now
  //doSomethingOnceAllAreDone();
});
});

编辑：我正在尝试这一个，但无法循环。可能我在node.js中遗漏了一些基本问题。有人能帮我吗

var util = require('util');
var async = require('async');
var SensorTag = require('./index');
var USE_READ = true;

var count = 0;

/*PART 1*/  


SensorTag.discover(function(sensorTag) {
    console.log('discovered: ' + sensorTag);

  async.series([
      function(callback) {
        console.log('connectAndSetUp');
        sensorTag.connectAndSetUp(callback);
      },
      function(callback) {
        console.log('readDeviceName');
        sensorTag.readDeviceName(function(error, deviceName) {
          console.log('\tdevice name = ' + deviceName);
          callback();
        });
      },
      function(callback) {
        console.log('readSystemId');
        sensorTag.readSystemId(function(error, systemId) {
          console.log('\tsystem id = ' + systemId);
          callback();
        });
      }

  ]);

});

/*PART 2*/

async.whilst(
      function () { return count < 5; },
      function (callback) {

      function(callback) {
        console.log('enableIrTemperature');
        sensorTag.enableIrTemperature();
      },
      function(callback) {
        setTimeout(callback, 2000);
      },
      function(callback) {
        console.log('readIrTemperature');
        sensorTag.readIrTemperature(function(error, objectTemperature, ambientTemperature) {
            console.log('\tobject temperature = %d °C', objectTemperature.toFixed(1));
            console.log('\tambient temperature = %d °C', ambientTemperature.toFixed(1));

            callback();
          });

      },
      function (err) {
        console.log('5 seconds have passed');
        // 5 seconds have passed
      }
          count++;
          setTimeout(callback, 1000);
      }

);

var util=require（'util'）；
var async=require（'async'）；
var SensorTag=需要（'./索引'）；
var USE_READ=true；
var计数=0；
/*第1部分*/
SensorTag.discover（功能（SensorTag）{
console.log（'discovered:'+sensorTag）；
异步系列([
函数（回调）{
console.log（'connectAndSetUp'）；
sensorTag.connectAndSetUp（回调）；
},
函数（回调）{
console.log（'readDeviceName'）；
sensorTag.readDeviceName（函数（错误，deviceName）{
console.log（'\t设备名称='+deviceName）；
回调（）；
});
},
函数（回调）{
log（'readSystemId'）；
sensorTag.readSystemId（函数（错误，systemId）{
console.log（'\tsystem id='+systemId）；
回调（）；
});
}
]);
});
/*第二部分*/
异步的(
函数（）{返回计数<5；}，
函数（回调）{
函数（回调）{
console.log（'enableIrTemperature'）；
sensorTag.enableIrTemperature（）；
},
函数（回调）{
setTimeout（回调，2000）；
},
函数（回调）{
console.log（'readIrTemperature'）；
sensorTag.readIrTemperature（功能（错误、对象温度、环境温度）{
console.log（'\t对象温度=%d°C'，objectTemperature.toFixed（1））；
console.log（'\t环境温度=%d°C'，环境温度.toFixed（1））；
回调（）；
});
},
功能（err）{
console.log（'5秒过去了'）；
//5秒钟过去了
}
计数++；
setTimeout（回调，1000）；
}
);

我不能循环地讨论这个问题。我想要的是在第1部分中执行函数，然后在第2部分中循环所有函数。我已尝试递归，可能不正确且无法执行

您可能需要使用

setInterval(function(){
    callback();
}, 3000)

---

setTimeout（），运行一次。

setTimeout

用于在预定时间后调用某个对象一次。然而，这是使用称为递归的技术调用无限循环的最佳方式。例如：

var foo = function() {
  setTimeout(function() {
    // do stuff that may take time

    foo()
  }, 3000)  
}

---

不要使用

setInterval

，因为它将再次调用，即使它尚未完成函数中的其他操作。

您可以递归执行：

asyncTasks.push(function (callback){
  var count = 0;

  myTask(function fn(err) {
    if(err || count >= 5) return callback(err);
    count++;
    myTask(fn);
  });
});

或

---

编辑 您将要编写的大多数函数都有回调，因为Node.js是一种延续传递风格的语言，I/O是异步的

node.js异步函数有一种模式，其中除了任意数量的参数之外，函数还使用一个具有以下签名的额外函数：

// results is optional
function(err,[results]){}

因此，函数声明应该类似于：

// next() here is the function described above
SensorTag.registerEvent = function(event,next) {
  // Do stuff...
  // Do more stuf...

  if(stuffFailed){
    // If first param is truthy
    // something went wrong
    return next("Some error")
  } 

  // null as first param mean
  // implicitly that everything went ok
  next(null,["some","result"]);
};

如果出现错误，则在执行下面的代码之前显式返回

。例如：

var getCurrentUser = function(callback){
  DB.findCurrentUser({ foo: 'always' },function(err,user) {
    if(err){
      return callback(err);
    }

    return callback(null,user);
  });
}

getCurrentUser(function(err,userProfile) {
  if(err){
    console.log(err);
    return;
  }

  console.log('OK! We got user: %s',userProfile.id);
});

Async使用这种模式。这是一个很好的控制流库，但是您需要了解如何控制连续流

在函数
SensorTag.discover中，必须将回调作为第二个参数，以便在完成该函数后继续进行。
另外，如果要将其他所有函数直接插入到
async
中，则它们应该具有相同的签名

如果您的所有函数（未发布）都具有该签名，并且您正确地处理了错误
SensorTag.discover
可能如下所示：

// This function needs a callback if you wish
// to continue your program
SensorTag.discover(function(sensorTag) {
  console.log('discovered: ' + sensorTag);

  async.series([
    sensorTag.connectAndSetUp,
    sensorTag.readDeviceName,
    sensorTag.readSystemId
  ],function(err,tasksData) {
    if(err){
      console.error(err);
      return;
    }
    console.log('All tasks succedded!');
    // No external callback to continue
  });
});

如果这三个函数看起来像上面的
getCurrentUser
示例，那么应该可以工作。您遇到的问题可能在这些内部功能中

<>代码>而是相同的，但它只需要3个函数，其中一个重要的是中间的一个，那就是应该遵循<代码>回调（Err）< /C>模式的那个函数。因此：

SensorTag.discover(function(sensorTag) {
  console.log('discovered: ' + sensorTag);

  var count = 0;

  async.whilst(
    function () { return count < 5; },
    function (callback) {
      console.log('count === %d',count);
      async.series([
        sensorTag.connectAndSetUp,
        sensorTag.readDeviceName,
        sensorTag.readSystemId
      ],callback);
    },
    function (err) {
      // This is our continuation callback
      // But again, we don't have an external callback
    }
  );
});

我建议您在深入研究async库之前，先阅读Node.js和异步编程模式。正如我之前所说，异步功能非常强大，但您需要理解这些概念，否则将永远无法调试。
请展示您的代码。如果没有这些，很难猜出你做错了什么。添加了code@germ>我添加了1个函数，以后会添加更多。只是checking@germi我想要的是反复循环函数again@germi你看过我的编辑吗？我已经添加了代码。除了教程中列出的工具之外，还有更多的工具，特别是有，但没有循环，函数没有再次调用。发生了什么？它被卡在最后一个调用的函数上，没有再次开始执行。它挂在最后一个功能Maroshi你能看到我的编辑吗？我试过循环，但没有发生。请看我的第二次编辑
SensorTag.discover(function(sensorTag) {
  console.log('discovered: ' + sensorTag);

  var count = 0;

  async.whilst(
    function () { return count < 5; },
    function (callback) {
      console.log('count === %d',count);
      async.series([
        sensorTag.connectAndSetUp,
        sensorTag.readDeviceName,
        sensorTag.readSystemId
      ],callback);
    },
    function (err) {
      // This is our continuation callback
      // But again, we don't have an external callback
    }
  );
});

SensorTag.discover = function(sensorTag,next) {
  console.log('discovered: ' + sensorTag);

  var count = 0;

  async.whilst(
    function () { return count < 5; },
    function (callback) {
      console.log('count === %d',count);
      async.series([
        sensorTag.connectAndSetUp,
        sensorTag.readDeviceName,
        sensorTag.readSystemId
      ],callback);
    },
    function (err) {
      next(err);
    }
  );
});

// Then you call it externally
SensorTag.discover(mySensorTag,function(err) {
  if(err){
    console.error(err);
  }

  // Do more stuff...
});