Javascript 如何使用字典提高性能？

我的问题是，我在这段代码中没有最快的性能。 我有30个测试，我必须用这段代码解决，但我只解决了28个，直到它抛出一个错误，因为它需要很长时间

这是我的示例输入：

queryType: ["insert", "insert", "addToValue", "addToKey", "get"]
query: [[1,2], [2,3], [2], [1], [3]]

function testHashMap(queryType, query) {
    let hash = {};
    let result = 0;
    let offset = 0;
    let len = queryType.length;
    for (let i = 0; i < len; ++i) {
        let querys = query[i][0];
        switch (queryType[i]) {
            case "insert": 
                hash[querys] = query[i][1];
                break;
            case "addToValue": 
                for (let key in hash) {
                    hash[key] += querys;
                }
                break;
            case "addToKey": 
                offset += querys;
                break;
            case "get": 
                result += hash[querys - offset];
                break;
        }
    }
    return result;
}

这是我当前的代码：

queryType: ["insert", "insert", "addToValue", "addToKey", "get"]
query: [[1,2], [2,3], [2], [1], [3]]

function testHashMap(queryType, query) {
    let hash = {};
    let result = 0;
    let offset = 0;
    let len = queryType.length;
    for (let i = 0; i < len; ++i) {
        let querys = query[i][0];
        switch (queryType[i]) {
            case "insert": 
                hash[querys] = query[i][1];
                break;
            case "addToValue": 
                for (let key in hash) {
                    hash[key] += querys;
                }
                break;
            case "addToKey": 
                offset += querys;
                break;
            case "get": 
                result += hash[querys - offset];
                break;
        }
    }
    return result;
}

函数testHashMap（queryType，query）{
设hash={}；
设结果=0；
设偏移量=0；
设len=queryType.length；
for（设i=0；i

有人知道如何提高这个函数的速度吗？

---

谢谢你抽出时间

如果这是代码中的一个热点，分派对象可能会更快（您的问题似乎就是这样）：

函数testHashMap（queryType，query）{
设hash={}；
设结果=0；
设偏移量=0；
设len=queryType.length；
常数调度={
插入（i）{
hash[querys]=查询[i][1]；
},
addToValue（）{
for（让输入散列）{
散列[键]+=查询；
}
},
addToKey（）{
偏移量+=查询；
},
得到（）{
结果+=散列[查询-偏移]；
}
};
for（设i=0；i{}）（i）；
}
返回结果；
}

---

这是因为JavaScript引擎被调整为在热点中积极优化对象方法/属性查找。

正如Matt Timmermans在评论中指出的那样，一种加速的方法可能不是实际增加每个值。假设我们的起始值是

[1, 1, 1, 1]

现在为每个元素添加3，我们记录一个通用的

偏移量

，3

假设我们现在得到一个insert，

[2,4]

。我们想把第三个元素设为4，所以我们先减去偏移量。4-3=1，所以我们实际上根本不改变第三个元素

现在我们需要

获取索引2处的元素。我们加上我们的一般抵销：

1 + 3 = 4

正如所料

这样，所有更新都保持在时间复杂度
O（1）
的状态，运行速度应该更快。
addToValue
花费的时间太长。本练习的重点是找出如何在不实际添加每个值的情况下产生相同的效果。
查询类型：[“插入”、“插入”、“添加”、“插入”、“添加”、“添加值”、“添加值”、“添加值”、“添加值”、“获取”]query:[-5、-2]、[2,4]、-1]、-3]、[1]、[3、-2]、-4]、-2]、[2]、-8]
现在我们有两次get，“现在它是怎么工作的？”罗布伦克不确定我是否明白。我在您的示例中看到一个
get
，但您说我们有两个
get
。请提供一个具有预期输出的完整示例，我将用我提出的方法进行检查。我想我忘记了这一点。例如，您有[“插入”、“获取”、“插入”、“获取”]，现在您有两次必须将值添加到结果中。但是如果你像你告诉我的那样使用偏移量，就没有简单的方法来获得写值，不是吗？@RoyBlunk类似这样的东西？从索引2处的元素为4的位置继续，我们得到了偏移量为3的
[1,1,1,1]。现在是第二次插入，
[2，-6]
，因此我们将其设置为
（-6）-offset=-9
。现在的列表是
[1,1，-9,1
。现在我们又得到了2，我们得到了-9+3=-6，正如预期的那样。也许我在寻找错误的方法，我会尝试你的方法。