三维数组如何在JavaScript中使用“每个”函数

Question

三维数组如何使用every函数，结果很奇怪：

var foo = [];
foo[0] = [];
foo[1] = [];
foo[0][0] = [];
foo[0][1] = [];
foo[1][0] = [];
foo[1][1] = [];
foo[0][0][0] = "kanon";
foo[0][0][1] = "JOJO";
foo[0][1][0] = "Dio";
foo[0][1][1] = "Sort";
foo[1][0][0] = "What";
foo[1][0][1] = "Gary";
foo[1][1][0] = "Tofu";
foo[1][1][1] = "bili";
var foo2 = ["JOJO","JOJO","mon","ti","JOJO"];
function isJOJO(x){
    if(x === "JOJO"){
        document.write(x + " is JOJO. <br>");
        return true;
    }else{
        document.write(x + " is not JOJO. <br>");
        return false;
    }
}
document.write(foo.every(isJOJO));
document.write("<br><br>");
document.write(foo2.every(isJOJO));

Chrome中的结果如下：

kanon,JOJO,Dioo,Sort is not JOJO. 
false

JOJO is JOJO. 
JOJO is JOJO. 
mon is not JOJO. 
false

一维数组foo2的结果是正确的，但三维数组的结果不是...

我定义三维数组foo的方式是否错误？

为什么只排序直到Sort ，甚至打印kanon和Dioo ，这不是===“ JOJO”

或者谁可以向我推荐另一本官方书籍或网站，我现在正在使用这本书，该书由Stoyan Stefanov和Kumar Chetan Sharma授权编写

非常感谢。 ^ w ^

Answer 1

Javascript没有真正的多维数组，所有数组都是一维的。 但是，数组的元素可以是任何类型，创建的数组是其元素为其他数组的那些数组，这些数组也具有数组作为元素。

但是像Array.prototype.every这样的数组函数每一个都只考虑给定的顶级数组，而不会递归到所包含的数组中。 因此，当您尝试：

foo.every(isJOJO)

它呼吁

isJOJO(foo[0])

相当于

isJOJO([["kanon","JOJO"],["Dioo","Sort"]])

这不等于"JOJO" ，因此它返回false ，并导致every()返回false 。

Answer 2

这两个阵列实际上都是一维的。 实际上，所有编程语言中的所有数组都是一维的。 额外的维度只是人类对一维数组包含的内容的解释。

foo是一个普通（一维）数组，碰巧包含一个包含数组的数组。 让我们重写您的代码以使其显而易见：

var foo = [];
foo[0] = [['kanon','JOJO'],['Dioo','Sort']];
foo[1] = [['What','Gary'],['Tofu',bili']];

现在，很明显foo仅包含两个成员。 碰巧那些成员是数组。

因此foo.every()将遍历foo[0]和foo[1] 。 如果您需要遍历foo的内容，则需要像对foo[0].every()一样对它们调用.every() 。

Answer 3

您可能要三维地找到 ：

var firstJOJO=foo.find(arr=>arr.find(inner=>inner.find(isJOJO)));

Answer 4

正如其他答案所描述的那样， foo的顶级元素是数组，因此，如果要查看它们中的值，可以使用递归：

 var foo = []; foo[0] = []; foo[1] = []; foo[0][0] = []; foo[0][1] = []; foo[1][0] = []; foo[1][1] = []; foo[0][0][0] = "kanon"; foo[0][0][1] = "JOJO"; foo[0][1][0] = "Dio"; foo[0][1][1] = "Sort"; foo[1][0][0] = "What"; foo[1][0][1] = "Gary"; foo[1][1][0] = "Tofu"; foo[1][1][1] = "bili"; var foo2 = ["JOJO","JOJO","mon","ti","JOJO"]; function isJOJO(x){ if(Array.isArray(x)){ return x.every(isJOJO); }else if(x === "JOJO"){ console.log(x + " is JOJO."); return true; }else{ console.log(x + " is not JOJO."); return false; } } console.log(foo.every(isJOJO)); console.log(foo2.every(isJOJO)); 

Answer 5

Javascript本身并不做多维数组。 它将数组的数组进行到第n次。 因此，在您的情况下，您的foo是一个数组数组，每个子数组都是一个数组数组。

因此，在调用foo.every（isJOJO）时传递给isJOJO函数的值是一个数组数组。 这就是为什么它与“ JOJO”不同的原因。

您将要测试传递给函数的值是否是数组，如果要运行，请运行：x.every（isJOJO）。

Answer 6

Barmar发布的答案清楚地解释了为什么代码不起作用。 从那里开始。

要递归地在多维数组中查找元素，可以编写deepEvery函数：

function deepEvery(array, condition) {
  const results = []

  for (let item of array) {
    if (Array.isArray(item)) {
      // Handle internal arrays with a recursive call:
      for (let subitem of deepEvery(item, condition)) results.push(subitem)

    } else {
      // Handle single items by testing the condition:
      if (condition(item)) results.push(item)
    }
  }

  return results
}

例如：

const array = [
  [
    ["foo", "bar"]
  ],
  [ "foo" ],
  "foo"
]

console.log(deepEvery(array, x => x === 'foo'))
# ['foo', 'foo', 'foo']