Javascript 迭代node.js中的对象键

由于Javascript 1.7有一个对象，它允许：

var a={a:1,b:2,c:3};
var it=Iterator(a);

function iterate(){
    try {  
        console.log(it.next());
        setTimeout(iterate,1000);
    }catch (err if err instanceof StopIteration) {  
        console.log("End of record.\n");  
    } catch (err) {  
        console.log("Unknown error: " + err.description + "\n");  
    }  

}
iterate();

node.js中是否有类似的内容

现在我正在使用：

function Iterator(o){
    /*var k=[];
    for(var i in o){
        k.push(i);
    }*/
    var k=Object.keys(o);
    return {
        next:function(){
            return k.shift();
        }
    };
}

---

但是，将所有对象键存储在

k

中会产生大量开销，您需要的是对对象或数组的延迟迭代。这在ES5中是不可能的（因此在node.js中是不可能的）。我们最终会得到这个

唯一的解决方案是找到一个节点模块，该模块扩展V8以实现迭代器（可能还有生成器）。我找不到任何实现。您可以查看蜘蛛猴源代码并尝试以C++作为V8扩展来编写它。 您可以尝试以下操作，但它也会将所有键加载到内存中

Object.keys(o).forEach(function(key) {
  var val = o[key];
  logic();
});

然而，由于

Object.keys

是一种本机方法，因此它可能允许更好的优化

如您所见，Object.keys的速度明显加快。实际内存存储是否更优化则是另一回事

var async = {};
async.forEach = function(o, cb) {
  var counter = 0,
    keys = Object.keys(o),
    len = keys.length;
  var next = function() {
    if (counter < len) cb(o[keys[counter++]], next);
  };
  next();
};

async.forEach(obj, function(val, next) {
  // do things
  setTimeout(next, 100);
});

var async={}；
async.forEach=函数（o，cb）{
变量计数器=0，
键=对象。键（o），
len=键。长度；
var next=函数（）{
如果（计数器

还请记住，您可以向函数传递第二个参数，指定要用作

此

关键字的对象

// myOjbect is the object you want to iterate.
// Notice the second argument (secondArg) we passed to .forEach.
Object.keys(myObject).forEach(function(element, key, _array) {
  // element is the name of the key.
  // key is just a numerical value for the array
  // _array is the array of all the keys

  // this keyword = secondArg
  this.foo;
  this.bar();
}, secondArg);

调整他的代码：

Object.prototype.each = function(iterateFunc) {
        var counter = 0,
keys = Object.keys(this),
currentKey,
len = keys.length;
        var that = this;
        var next = function() {

            if (counter < len) {
                currentKey = keys[counter++];
                iterateFunc(currentKey, that[currentKey]);

                next();
            } else {
                that = counter = keys = currentKey = len = next = undefined;
            }
        };
        next();
    };

    ({ property1: 'sdsfs', property2: 'chat' }).each(function(key, val) {
        // do things
        console.log(key);
    });

Object.prototype.each=函数（iterateFunc）{
变量计数器=0，
keys=对象。keys（此），
currentKey，
len=键。长度；
var=这个；
var next=函数（）{
如果（计数器

我是node.js的新手（大约2周），但我刚刚创建了一个模块，可以递归地向控制台报告对象的内容。它将列出所有项目或搜索特定项目，然后在需要时按给定深度向下钻取

也许您可以定制它以满足您的需要。保持简单！为什么要复杂化

'use strict';

//console.log("START: AFutils");

// Recusive console output report of an Object
// Use this as AFutils.reportObject(req, "", 1, 3); // To list all items in req object by 3 levels
// Use this as AFutils.reportObject(req, "headers", 1, 10); // To find "headers" item and then list by 10 levels
// yes, I'm OLD School!  I like to see the scope start AND end!!!  :-P
exports.reportObject = function(obj, key, level, deep) 
{
    if (!obj)
    { 
        return;
    }

    var nextLevel = level + 1;

    var keys, typer, prop;
    if(key != "")
    {   // requested field
        keys = key.split(']').join('').split('[');
    }
    else
    {   // do for all
        keys = Object.keys(obj);
    }
    var len = keys.length;
    var add = "";
    for(var j = 1; j < level; j++)
    {
        // I would normally do {add = add.substr(0, level)} of a precreated multi-tab [add] string here, but Sublime keeps replacing with spaces, even with the ["translate_tabs_to_spaces": false] setting!!! (angry)
        add += "\t";
    }

    for (var i = 0; i < len; i++) 
    {
        prop = obj[keys[i]];
        if(!prop)
        {
            // Don't show / waste of space in console window...
            //console.log(add + level + ": UNDEFINED [" + keys[i] + "]");
        }
        else
        {
            typer = typeof(prop);
            if(typer == "function")
            {
                // Don't bother showing fundtion code...
                console.log(add + level + ": [" + keys[i] + "] = {" + typer + "}");
            }
            else
            if(typer == "object")
            {
                console.log(add + level + ": [" + keys[i] + "] = {" + typer + "}");
                if(nextLevel <= deep)
                {
                    // drop the key search mechanism if first level item has been found...
                    this.reportObject(prop, "", nextLevel, deep); // Recurse into
                }
            }
            else
            {
                // Basic report
                console.log(add + level + ": [" + keys[i] + "] = {" + typer + "} = " + prop + ".");
            }
        }
    }
    return ;
};

//console.log("END: AFutils");

“严格使用”；
//log（“START:AFutils”）；
//对象的递归控制台输出报告
//将其用作AFutils.reportObject（req，“，1，3）；//按3级列出req对象中的所有项目
//将其用作AFutils.reportObject（req，“headers”，1，10）；//查找“标题”项，然后按10级列出
//是的，我是老派！我喜欢看到范围的开始和结束！！！：-P
exports.reportObject=函数（对象、键、级别、深度）
{
如果（！obj）
{ 
返回；
}
var nextLevel=级别+1；
变量键、打字机、道具；
如果（键！=“”）
{//请求的字段
keys=key.split（']'）。join（''）.split（'['）；
}
其他的
{//
键=对象。键（obj）；
}
var len=keys.length；
var add=“”；
对于（变量j=1；j如果（nextLevel用于键/值的简单迭代，有时像这样的库可以成为您的朋友

const _ = require('underscore');

_.each(a, function (value, key) {
    // handle
});

仅供参考
您看到了吗？什么开销？您有多少个键和迭代器？如果它们的产品少于100万，请忽略这一“低效”。@jcolebrandφ：似乎
createNodeIterator
用于DOM元素，我甚至没有DOM；）@c69:我将所有数据存储在对象的
键中，而
值设置为
1
（700k键中约20MB），实际上，现在我只是忽略了这个“开销”，但我更喜欢一个更好的解决方案：）我将其视为一个需要处理的类；-）谢谢！，这稍微改进了我的迭代器：）（更新了代码）但遗憾的是，记忆问题依然存在：（我不能使用<代码>前缀）因为每次迭代步骤都应该从异步代码> SETTIMEOUT中调用。@ StWe添加了一个<代码>异步。Frace<代码>谢谢！请说明我可能会尝试C++扩展方法。Oc/Stw关于C++扩展，你有没有写？它对我起作用。不知道 BuyStasks。我使用这个函数从<代码> Loasy< /Calp>图书馆。很好地添加了线程，但是……为什么在这个世界上显示被传递的对象的键被称为“元素”，而键数组的枚举器被称为“KEY”。？我可以建议您更新代码示例以使用
Object.keys（myObject）.forEach（function（key，index，arrayOfKeys）{