Javascript：检查元素是否在二维数组中的快速方法？

我有一个

nodes\u对象

数组，它的结构如下：

  nodes_object = {
             1: {
                 source: '001',
                 name: 'A',
                 target: '004',
                 name: 'B'
                },
             2: {
                 source: '003',
                 name: 'C',
                 target: '001',
                 name: 'A'
                },
             }

然后我还有一个数组

排序

，其结构如下：

     sorted = { 
             1: {
                val: '001',
                count: '100'
                },
             2: {
                val: '003',
                count: '80'
             }

我需要创建一个函数，该函数将通过

节点\u对象

重复，检查

源

和

目标

是否都包含在其中一个

排序的
val
参数中，如果是，则继续

到目前为止，我提出了下面的函数，它首先通过
节点\u对象
进行重复，然后通过
排序
进行重复，以查看其中是否存在任何元素，但我想知道是否有更快更有效的方法来实现这一点

谢谢大家!

  for (var i = 0; i < nodes_object.length; i++) {

        var sourcein = null;
        var targetin = null;

        for (var j = 0; j < sorted.length; j++) {
            if (sorted[j].val == nodes_object[i][0]) {
                sourcein = 1;
            }
            if (sorted[j].val == nodes_object[i][2]) {
                targetin = 1;
            }
        }


        if ((sourcein) && (targetin)) {

                // Perform the function
        }
   }

for（变量i=0；i
首先，要创建数组，您使用的是
[]
，而不是
{}
。因此，它应该是：

nodes_object = [
    {
     source: '001',
     name: 'A',
     target: '004',
     name: 'B'
    },
    {
     source: '003',
     name: 'C',
     target: '001',
     name: 'A'
    },
];

对于排序后的
也是如此

创建一个对象，其关键帧是要测试的
val
对象

hash = {};
for (var k = 0; k < sorted.length; k++) {
    hash[sorted[k]] = true;
}

首先，要创建数组，请使用
[]
，而不是
{}
。因此，它应该是：

nodes_object = [
    {
     source: '001',
     name: 'A',
     target: '004',
     name: 'B'
    },
    {
     source: '003',
     name: 'C',
     target: '001',
     name: 'A'
    },
];

对于排序后的
也是如此

创建一个对象，其关键帧是要测试的
val
对象

hash = {};
for (var k = 0; k < sorted.length; k++) {
    hash[sorted[k]] = true;
}

首先，要创建数组，请使用
[]
，而不是
{}
。因此，它应该是：

nodes_object = [
    {
     source: '001',
     name: 'A',
     target: '004',
     name: 'B'
    },
    {
     source: '003',
     name: 'C',
     target: '001',
     name: 'A'
    },
];

对于排序后的
也是如此

创建一个对象，其关键帧是要测试的
val
对象

hash = {};
for (var k = 0; k < sorted.length; k++) {
    hash[sorted[k]] = true;
}

首先，要创建数组，请使用
[]
，而不是
{}
。因此，它应该是：

nodes_object = [
    {
     source: '001',
     name: 'A',
     target: '004',
     name: 'B'
    },
    {
     source: '003',
     name: 'C',
     target: '001',
     name: 'A'
    },
];

对于排序后的
也是如此

创建一个对象，其关键帧是要测试的
val
对象

hash = {};
for (var k = 0; k < sorted.length; k++) {
    hash[sorted[k]] = true;
}

这些是对象，不是数组。@Barmar不确定它们是否真的是，或者它是否只是用于问题的一个奇怪的符号。为什么要使用
null
和
1
而不是
false
和
true
？@nnnn我后来使用了那些
sourcein
和
targetin
值。这些是对象，不是数组。@Barmar不确定它们是否真的是数组，或者它是否只是用于这个问题的一个奇怪的符号。为什么要使用
null
和
1
而不是
false
和
true
？@nnnn我后来使用了
sourcein
和
targetin
值。这些都是对象，不是数组。@Barmar不确定它们是否真的是数组，或者它是否只是用于这个问题的一个奇怪的符号。为什么要使用
null
和
1
而不是
false
和
true
？@nnnn我后来使用了
sourcein
和
targetin
值。这些都是对象，不是数组。@Barmar不确定它们是否真的是数组，或者它是否只是用于这个问题的一个奇怪的符号。为什么要使用
null
和
1
而不是
false
和
true
？@nnnn我后来使用了
sourcein
和
targetin
值……加上JavaScript技术上没有多维数组，但我知道OP的意思。OP希望检查源和目标是否都包含在一个已排序的val参数中（这是它们的示例代码的工作方式）。这将导致另一个测试：
if（nodes_object[I]。source==nodes_object[I]。target&&nodes_object[I]。source in hash）{…}
这就是我最初开始编写的内容。然后我注意到他的代码在循环完成后检查变量。因为他只是要求一种更快的编码方式，所以我假设基本逻辑是正确的，所以我保留了它。那么@Barmar您认为您提出的解决方案会更快吗？非常感谢您的帮助！…再加上JavaScri从技术上讲，pt没有多维数组，但我知道OP的意思。OP希望检查源和目标是否都包含在一个已排序的val参数中（这就是它们的示例代码的工作方式）。这将导致另一个测试：
if（nodes\u object[I]。source==nodes\u object[I]。target&&nodes\u object[I].source在哈希中）{…}
这就是我最初开始编写的内容。然后我注意到他的代码在循环完成后检查变量。因为他只是要求一种更快的编码方式，所以我假设基本逻辑是正确的，所以我保留了它。那么@Barmar您认为您提出的解决方案会更快吗？非常感谢您的帮助！…再加上JavaScri从技术上讲，pt没有多维数组，但我知道OP的意思。OP希望检查源和目标是否都包含在一个已排序的val参数中（这就是它们的示例代码的工作方式）。这将导致另一个测试：
if（nodes\u object[I]。source==nodes\u object[I]。target&&nodes\u object[I].source在哈希中）{…}
这就是我最初开始编写的内容。然后我注意到他的代码在循环完成后检查变量。因为他只是要求一种更快的编码方式，所以我假设基本逻辑是正确的，所以我保留了它。那么@Barmar您认为您提出的解决方案会更快吗？非常感谢您的帮助！…再加上JavaScri从技术上讲，pt没有多维数组，但我知道OP的意思。OP希望检查源和目标是否都包含在一个已排序的val参数中（这就是它们的示例代码的工作方式）。这将导致另一个测试：
if（nodes\u object[I]。source==nodes\u object[I]。target&&nodes\u object[I]。