Javascript 检查是否定义了数组[4][3][7][3]

当存在一个一维数组时，通过简单调用

arr[6]

来检查它是否已定义，如果该属性不存在，它将返回

undefined

，或者调用

typeof arr[6]===undefined

---

问题是，在我的例子中，我有

arr[5][1][6][2][5][3][7]

，其中

arr[5]

可能不存在，或者

arr[5][1]

等等。这自然会触发错误：

类型错误：无法读取属性[…]

一个解决方案是编写多个IF语句。但是，有没有更好的解决方案，请允许我检查是否定义了

arr[5][1][6][2][5][3][7]

？

我想不出比以下更好的解决方案了：

var defined = false;
try {
   defined = !!arr[5][1][6][2][5][3][7]
} catch(e)
{
   // nothing
}

---

但是非常糟糕的设计。

我想不出比以下更好的设计了：

var defined = false;
try {
   defined = !!arr[5][1][6][2][5][3][7]
} catch(e)
{
   // nothing
}

---

但是设计非常糟糕。

将访问它的代码放在

try

和

catch

之间。如果它起作用，它就起作用，如果不起作用，你会得到一个很好的异常，你可以做出相应的反应

---

作为旁注，想到是什么促使您这样设计系统，我不寒而栗……

将访问它的代码放在

try

和

catch

之间。如果它起作用，它就起作用，如果不起作用，你会得到一个很好的异常，你可以做出相应的反应

---

作为旁注，想到是什么促使您这样设计系统，我不寒而栗……

因为这似乎是一个有趣的问题，我编写此函数是为了以一种非常好的方式解决它：）

现在假设你有这个：

arr[foo][bar][baz];

你可以用

deepCheck(arr, [foo, bar, baz]);

---

也许我应该指出，我确实有点同意，如果你确实有非常长的数组，这听起来确实像是一个设计问题。

因为这似乎是一个有趣的问题，我写这个函数是为了以一种很好的非例外的方式解决它：）

现在假设你有这个：

arr[foo][bar][baz];

你可以用

deepCheck(arr, [foo, bar, baz]);

---

也许我应该指出，我确实有点同意，如果你确实有这样的非常长的数组，这听起来确实像是一个设计问题。

这种语言没有内置的解决方案，但是你可以用这样的函数来处理它：

var verifyIndexes = function(target) {
    var current = target;
    for (i = 1; i < arguments.length; i++) {
        if (arguments[i] in current) {
            current = current[arguments[i]];
        } else {
            return false;
        }
    }
    return true;
}

var myArray = [[[1, 2, 3], 4], 5];
console.log(verifyIndexes(myArray, 0));        // true
console.log(verifyIndexes(myArray, 0, 0, 0));  // true
console.log(verifyIndexes(myArray, 0, 0, 3));  // false
console.log(verifyIndexes(myArray, 0, 1));     // true
console.log(verifyIndexes(myArray, 0, 2));     // false

function arrayDimensionsExist(source, dimensions) {
    var currentDepth = source;
    for (var i = 0; i < dimensions.length; i++) {
        var key = dimensions[i];
        if (currentDepth[key] === null) {
            return false;
        } else {
            currentDepth = source[key];
        }
    }
    return true;
}

var verifyIndexes=函数（目标）{
var电流=目标；
对于（i=1；i

该语言没有内置的解决方案，但您可以使用如下函数处理它：

var verifyIndexes = function(target) {
    var current = target;
    for (i = 1; i < arguments.length; i++) {
        if (arguments[i] in current) {
            current = current[arguments[i]];
        } else {
            return false;
        }
    }
    return true;
}

var myArray = [[[1, 2, 3], 4], 5];
console.log(verifyIndexes(myArray, 0));        // true
console.log(verifyIndexes(myArray, 0, 0, 0));  // true
console.log(verifyIndexes(myArray, 0, 0, 3));  // false
console.log(verifyIndexes(myArray, 0, 1));     // true
console.log(verifyIndexes(myArray, 0, 2));     // false

function arrayDimensionsExist(source, dimensions) {
    var currentDepth = source;
    for (var i = 0; i < dimensions.length; i++) {
        var key = dimensions[i];
        if (currentDepth[key] === null) {
            return false;
        } else {
            currentDepth = source[key];
        }
    }
    return true;
}

var verifyIndexes=函数（目标）{
var电流=目标；
对于（i=1；i

通过使用try/catch块，您可以检查元素是否可以访问

var x;
try {
   x = arr[5][1][6][2][5][3][7];
} catch(TypeError)
{
   // the element cannot be accessed
   x = undefined;
}

---

然后就可以很容易地使用if语句检查“x”是否已定义。

通过使用try/catch块，您可以检查元素是否可以访问

var x;
try {
   x = arr[5][1][6][2][5][3][7];
} catch(TypeError)
{
   // the element cannot be accessed
   x = undefined;
}

---

然后就可以很容易地检查“x”是否定义了，是否使用了if语句。

一种实用的方法是将这个问题分解为它的组成部分；查看已知的数据和手头的工具

那么，我们知道什么呢？在检查

arr[5][1][6][2][5][3][7]

是否定义时，我们知道我们要检查的密钥。现在问问自己，JavaScript中有哪些工具？要检查是否定义了数组索引，我们可以将其与null进行比较，即：

if (array[index] === null) { 
    return false 
}

如果我们要尝试编写此代码，首先应该想到的事情之一就是简单地遍历每个键，顺序如下：例如：

if (array[5] === null) {
    return false;
} else if (array[5][1] === null) {
    return false
} ...snip...

// Good news, it's defined!
return true

显然，这种方法是可以改进的，它需要编写大量重复的代码，而且不灵活，不可重用。如果您发现自己一遍又一遍地做着同样的事情，那么您可能有一个很好的循环构造候选对象。为了实现一个循环，您需要一个变量，它会随着每次重复而改变——在上面的示例中，变量是我们正在检查的嵌套数组的最右边的元素。首先，让我们从列出我们的变体开始：

var variants = [ 5, 1, 6, 2, 5, 3, 7 ];
for (var i = 0; i < variants.length; i++) {
   console.log("variant: " + variants[i]);
}

var变量=[5,1,6,2,5,3,7]；
对于（变量i=0；i

我们从这里走到哪里？事情变得有点困难了，您需要了解数组是如何在JavaScript中通过引用传递的，并在循环体中利用它；最终你可能会得到这样的结果：

var verifyIndexes = function(target) {
    var current = target;
    for (i = 1; i < arguments.length; i++) {
        if (arguments[i] in current) {
            current = current[arguments[i]];
        } else {
            return false;
        }
    }
    return true;
}

var myArray = [[[1, 2, 3], 4], 5];
console.log(verifyIndexes(myArray, 0));        // true
console.log(verifyIndexes(myArray, 0, 0, 0));  // true
console.log(verifyIndexes(myArray, 0, 0, 3));  // false
console.log(verifyIndexes(myArray, 0, 1));     // true
console.log(verifyIndexes(myArray, 0, 2));     // false

function arrayDimensionsExist(source, dimensions) {
    var currentDepth = source;
    for (var i = 0; i < dimensions.length; i++) {
        var key = dimensions[i];
        if (currentDepth[key] === null) {
            return false;
        } else {
            currentDepth = source[key];
        }
    }
    return true;
}

函数ArrayDimensionsExister（源，维度）{
var currentDepth=源；
对于（变量i=0；i

务实的方法是将这个问题分解为各个组成部分；查看已知的数据和手头的工具

那么，我们知道什么呢？在检查

arr[5][1][6][2][5][3][7]

是否定义时，我们知道我们要检查的密钥。现在问问自己，JavaScript中有哪些工具？要检查是否定义了数组索引，可以比较