Javascript对象键查找的奇怪比较性能 演示：

我正在编写一段代码，可以通过循环到第一个javascript对象（称为a）来比较两个javascript对象，从而在第二个javascript对象（称为B）中执行键查找（我将value作为键，将occurrence作为值）

但是，当我测量对象A的子键查找性能时（每数据量10次，程序每运行10次（每行100次，200次…），我会得到最小数据量的高定时（因此可能会减少dict B中的键）

对象布局： 对象A如下所示：

{
 SQL_TABLE_1:
 {
     column_1:
      [ 
        '2jmj7l5rSfeb/vlWAYkK/YBwIDk=',
        '3MaRDFGBKvsLLhrLUdplz3wUiOI=',
        'PEvUFHDR4HbOYXcj7danOvyRJqs='
        'XHvERAKZ4AqU+iWlx2scZXdem80=',
        'nSG0lvwlkIe5YxZGTo5binr3pAw=',
        'Swuc/7YCU9Ptfrff+KHaJJ1+b7U=',
        'N28qqdfezfZbPmK7CaGmj7m7IOQ=',
        'ffc7skeffegT1ZytAqjco3EpwUE=',
        '2XldayBefzBxsUuu6tMFYHVZEEY=',
        '5rC2y6IzadQ1aEy7CvNyr30JJ2k='
      ]
 },
 SQL_TABLE_2:
   {
      column_1:[......]
   }
}

对象B字段有各种大小，但在我们的测试中，此大小从未改变 对象B看起来像：

[
field_1:
 { 
  '2jmj7l5rSfeb/vlWAYkK/YBwIDk=': 1,
  '3MaRDFGBKvsLLhrLUdplz3wUiOI=': 1,
  'PEvUFHDR4HbOYXcj7danOvyRJqs=': 1,
  'XHvERAKZ4AqU+iWlx2scZXdem80=': 4,
  'nSG0lvwlkIe5YxZGTo5binr3pAw=': 1,
  'Swuc/7YCU9Ptfrff+KHaJJ1+b7U=': 1,
  'N28qqdfezfZbPmK7CaGmj7m7IOQ=': 27,
  'ffc7skeffegT1ZytAqjco3EpwUE=': 1,
  '2XldayBefzBxsUuu6tMFYHVZEEY=': 18,
  '5rC2y6IzadQ1aEy7CvNyr30JJ2k=': 1 },
field_2:{......}
]

代码中的计时测量结构如下：

    sql_field_1:
    {
       mongo_field_1: 0.003269665241241455, mongo_field_2: 0.0015446391105651855, mongo_field_3: 0.0009834918975830079, mongo_field_4: 0.0004488091468811035,
    },
    sql_field_2:
    {
        ....
    }

目标 目标是为对象A的每个子键在对象B子键上执行键查找

代码 以下是导致此行为的代码： 对象A称为sql_dict_数组 对象B称为hash_mongo_dict

    for(var field_name in hash_mongo_dict)
        {       
            performance_by_mongo_field[field_name] = {};
            result_by_mongo_field[field_name] = {};
            // LOOP ON OBJECT A KEYS
            for(var table_name in sql_dict_array)
            {
                // Start of time measurement
                var start_time = performance.now();


                // there is only one column in our test data
                for(var column_name in sql_dict_array[table_name])
                {   
                    found_count = 0;

                    for(var value of sql_dict_array[table_name][column_name])
                    {   
                        // **SUBKEY LOOPKUP HERE WITH VALUE**
                        var results = hash_mongo_dict[field_name][value];
                        // IF NOT UNDEFINED THEN IT HAS BEEN FOUND
                        // THIS CHECK IS NOT THE BOTTLENECK
                        if(results != undefined)
                        { 
                            found_count+=results;
                        }
                    }
                    if(found_count > limit_parameter)
                    {
                        console.log("error: too many match between hashes")
                        process.exit(0)
                    }
                    // PERFORMANCE CALCULATION
                    performance_by_mongo_field[field_name][table_name] = (performance.now() - start_time)/1000;
                    result_by_mongo_field[field_name][table_name+'.'+column_name] = (found_count/verif_hash_count*100);

                }
            }
         return some results...
        }

测试： 使用这段代码，我希望无论对象B的大小（子键的数量）如何，都能有几乎的恒定时间，但在我的代码中，当嵌套对象A中只有10个子键时，我的时间会更长，当达到100个或更多键时，它会变得稳定（用6000个键测试）

下面是对象A的一个键的键查找代码的10次运行，该键包含10个子键，其中包含来自对象B的300.000+数据：

0.2824700818061829 0.2532380700111389 0.2455208191871643 0.2610406551361084 0.2840422649383545 0.2344329071044922 0.2375670108795166 0.2354590659914150.23111085414886476 0.23635668310791

下面是相同的比较，但是使用了4000+子键：

0.0027927708625793456 0.0018292622566223144 0.015235211849212647 0.0036304402351379395 0.0029149875640869 0.004972007751464848444 0.01465702114105250.003572652339935303 0.0032280778884887697 0.00323297664792

---

我将感谢您提供的所有建议，

您的对象A定义无效，它是数组对象吗？是的，感谢您指出我更新了这个问题，我将感谢您提供给Megeting的任何建议，现在请尝试将性能度量准确地放在（假设的）周围关键说明。我假设你认为这是子键查找对吗？ps：我认为这可以归结为未定义检查的结果太随机，导致分支预测失败。删除“未定义检查”部分后，性能结果没有发生任何变化，令人遗憾的是，这也是最低的I可以这样获得计时：

JSON sql_字段_1:{mongo_字段_1:0.003269665241455，mongo_字段_2:0.0015446391105651855，mongo_字段_3:0.0009834918975830079，mongo_字段_4:0.000448809146811035，}，sql_字段_2:{

我在主要帖子中也写了这些内容。您的对象A定义无效，它是数组对象吗？是的，感谢您指出我更新了这个问题，我将感谢您向Megeting提供的任何建议，现在请尝试将性能度量准确地放在（假设的）周围关键说明。我假设你认为这是子键查找对吗？ps：我认为这可以归结为未定义检查的结果太随机，导致分支预测失败。删除“未定义检查”部分后，性能结果没有发生任何变化，令人遗憾的是，这也是最低的I你可以这样来计时：

JSON sql_field_1:{mongo_field_1:0.00326966525241241455，mongo_field_2:0.0015446391105651855，mongo_field_3:0.0009834918975830079，mongo_field_4:0.000448809146811035，}，sql_field__2:{……}

我也在主帖中写了这些