Javascript：如何在多维数组上实现迭代器？

我有两个dim阵列，如下所示：

var a = [[1,2,3],[4,5,6],[7,8,9]];

我想写一个迭代器，每次调用时返回一个值

iterator(); //returns 1
iterator(); //returns 2
iterator(); //returns 3

我尝试过这样的方法：

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i, j;
    return function() {
        for (var i = 0; i < a.length; i++) {
            var b = a[i];
            for (var j = 0; j < b.length; j++) {
                return a[i][j];
            }
        }
    }
};
var a = iterator();
a(); //1
a(); //1
a(); //1

函数迭代器（）{
变量a=[[1,2,3]，[4,5,6]，[7,8,9]；
varⅠ，j；
返回函数（）{
对于（变量i=0；i

它总是返回我的第一个元素

我可以试试这个：

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i = 0, j = 0;
    return function() {
        for (; i < a.length; i++) {
            var b = a[i];
            for (; j < b.length; j++) {
                return a[i][j];
            }
        }
    }
};

function test() {
    var a = [1,2,3,4,5], i = 0;
    return function() {
        while (i < a.length) {
            return a[i++];
        }
    }
}
var a = test();
a(); //1
a(); //2
a(); //3

函数迭代器（）{
变量a=[[1,2,3]，[4,5,6]，[7,8,9]；
var i=0，j=0；
返回函数（）{
对于（；i

也不管用

但如果我试一下这个：

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i = 0, j = 0;
    return function() {
        for (; i < a.length; i++) {
            var b = a[i];
            for (; j < b.length; j++) {
                return a[i][j];
            }
        }
    }
};

function test() {
    var a = [1,2,3,4,5], i = 0;
    return function() {
        while (i < a.length) {
            return a[i++];
        }
    }
}
var a = test();
a(); //1
a(); //2
a(); //3

功能测试（）{
变量a=[1,2,3,4,5]，i=0；
返回函数（）{
while（i

它很好用

这里有什么区别？如何使循环工作

---

对我来说，另一个明显的问题是边界。当我到达数组边界时，我应该如何停止？

可以使用简单的

if

来测试

j

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i = 0, j = 0;
    return function() {
        for (; i < a.length; i++) {
            var b = a[i];
            if (j < b.length){
                return a[i][j++];
            }
            j = 0;
        }
        return undefined; // reached when there is no value left
    }
};

函数迭代器（）{
变量a=[[1,2,3]，[4,5,6]，[7,8,9]；
var i=0，j=0；
返回函数（）{
对于（；i

对于第二维度，您可以使用简单的

if

来测试

j

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i = 0, j = 0;
    return function() {
        for (; i < a.length; i++) {
            var b = a[i];
            if (j < b.length){
                return a[i][j++];
            }
            j = 0;
        }
        return undefined; // reached when there is no value left
    }
};

函数迭代器（）{
变量a=[[1,2,3]，[4,5,6]，[7,8,9]；
var i=0，j=0；
返回函数（）{
对于（；i

对于第二维度，您可以使用简单的

if

来测试

j

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i = 0, j = 0;
    return function() {
        for (; i < a.length; i++) {
            var b = a[i];
            if (j < b.length){
                return a[i][j++];
            }
            j = 0;
        }
        return undefined; // reached when there is no value left
    }
};

函数迭代器（）{
变量a=[[1,2,3]，[4,5,6]，[7,8,9]；
var i=0，j=0；
返回函数（）{
对于（；i

对于第二维度，您可以使用简单的

if

来测试

j

function iterator() {
    var a = [[1,2,3],[4,5,6],[7,8,9]];
    var i = 0, j = 0;
    return function() {
        for (; i < a.length; i++) {
            var b = a[i];
            if (j < b.length){
                return a[i][j++];
            }
            j = 0;
        }
        return undefined; // reached when there is no value left
    }
};

函数迭代器（）{
变量a=[[1,2,3]，[4,5,6]，[7,8,9]；
var i=0，j=0；
返回函数（）{
对于（；i

扩展标准特性通常不是一个好主意，但对于一个教学示例，我将破例。为了实际使用，我建议实现您自己的类

总体思路

Array.prototype.beginIterator = function()
{
    var counter = 0;
    return function()
        { 
            if (counter<=this.length) return this[counter++]; 
            else return undefined;
        };
}

目前，这只适用于一维数组，但它可以应用于其他数组或对象的任何逻辑

多维（任意）解决方案：

以下迭代器允许任何组合中的任何维度数组：

Array.prototype.beginIterator = function()
{
    var counter = 0;
    var iterators = null;

    return function()
        { 
            val = undefined;
            if (iterators!=null)
            {
                val = iterators();
                if (val!==undefined) return val;
                else
                {
                    iterators = null;
                    counter++;
                }
            }

            while (counter <=this.length)
            {
                if (!(this[counter] instanceof Array)) return this[counter++];
                else
                {
                    iterators = this[counter++].beginIterator();
                    val = iterators();
                    if (val!==undefined) return val;
                }
            }
            return undefiend;
        };
}

---

扩展标准特性通常不是一个好主意，但对于一个教学示例，我将破例。为了实际使用，我建议实现您自己的类

总体思路

Array.prototype.beginIterator = function()
{
    var counter = 0;
    return function()
        { 
            if (counter<=this.length) return this[counter++]; 
            else return undefined;
        };
}

目前，这只适用于一维数组，但它可以应用于其他数组或对象的任何逻辑

多维（任意）解决方案：

以下迭代器允许任何组合中的任何维度数组：

Array.prototype.beginIterator = function()
{
    var counter = 0;
    var iterators = null;

    return function()
        { 
            val = undefined;
            if (iterators!=null)
            {
                val = iterators();
                if (val!==undefined) return val;
                else
                {
                    iterators = null;
                    counter++;
                }
            }

            while (counter <=this.length)
            {
                if (!(this[counter] instanceof Array)) return this[counter++];
                else
                {
                    iterators = this[counter++].beginIterator();
                    val = iterators();
                    if (val!==undefined) return val;
                }
            }
            return undefiend;
        };
}

---

扩展标准特性通常不是一个好主意，但对于一个教学示例，我将破例。为了实际使用，我建议实现您自己的类

总体思路

Array.prototype.beginIterator = function()
{
    var counter = 0;
    return function()
        { 
            if (counter<=this.length) return this[counter++]; 
            else return undefined;
        };
}

目前，这只适用于一维数组，但它可以应用于其他数组或对象的任何逻辑

多维（任意）解决方案：

以下迭代器允许任何组合中的任何维度数组：

Array.prototype.beginIterator = function()
{
    var counter = 0;
    var iterators = null;

    return function()
        { 
            val = undefined;
            if (iterators!=null)
            {
                val = iterators();
                if (val!==undefined) return val;
                else
                {
                    iterators = null;
                    counter++;
                }
            }

            while (counter <=this.length)
            {
                if (!(this[counter] instanceof Array)) return this[counter++];
                else
                {
                    iterators = this[counter++].beginIterator();
                    val = iterators();
                    if (val!==undefined) return val;
                }
            }
            return undefiend;
        };
}

---

扩展标准特性通常不是一个好主意，但对于一个教学示例，我将破例。为了实际使用，我建议实现您自己的类

总体思路

Array.prototype.beginIterator = function()
{
    var counter = 0;
    return function()
        { 
            if (counter<=this.length) return this[counter++]; 
            else return undefined;
        };
}

目前，这只适用于一维数组，但它可以应用于其他数组或对象的任何逻辑

多维（任意）解决方案：

以下迭代器允许任何组合中的任何维度数组：

Array.prototype.beginIterator = function()
{
    var counter = 0;
    var iterators = null;

    return function()
        { 
            val = undefined;
            if (iterators!=null)
            {
                val = iterators();
                if (val!==undefined) return val;
                else
                {
                    iterators = null;
                    counter++;
                }
            }

            while (counter <=this.length)
            {
                if (!(this[counter] instanceof Array)) return this[counter++];
                else
                {
                    iterators = this[counter++].beginIterator();
                    val = iterators();
                    if (val!==undefined) return val;
                }
            }
            return undefiend;
        };
}

---

在这种情况下，为什么需要一个循环呢。无论如何，您都在有效地展平阵列。您可以通过边界检查增加索引：

函数迭代器（）{
var a=[[1,2,3]，[4,5,6]，[7,8,9]]，i=0，j=0；
返回函数（）{
如果（j>=a[i].length）{j=0；i++；}
如果（i>=a.length）{j=0；i=0；}
log（a[i][j++]）；
}
};
var x=迭代器（）；
x（）；x（）；x（）；x（）；x（）；x（）；x（）；x（）；x（）；x（）；
x（）；x（）；x（）；x（）；x（）；x（）；x（）；x（）；x（）；x（）
在这种情况下，为什么需要循环呢。无论如何，您都在有效地展平阵列。您只需将索引与