Question

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

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 的方式是错误的吗？

为什么它只是在排序之前订购，甚至打印 kanon 和 Dioo ，这不是===“JOJO”

或者谁可以推荐我另一本官方书籍或网站，我现在正在使用这本书由Stoyan Stefanov和Kumar Chetan Sharma授权的面向对象的JavaScript第二版

非常感谢。 ^ W ^

Answer 1

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

但像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的内容，那么你需要在它们上面调用.every()，例如foo[0].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函数的值因此是一个数组数组。这就是为什么它与＆＃34; JOJO＆＃34;不相同。

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

Answer 6

answer posted by 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']

三维数组如何在javascript

6 个答案: