“这个”有多贵；“关键”；Ruby哈希函数？

我使用了一些散列，其中一些散列的值是其他散列的键

我需要使用几次来获取一个值的键，这样我就可以使用它来访问另一个散列中的内容

我想知道这可能会对性能产生什么样的影响。在我的情况下，这些散列的数量很少，内容也很小，但我想从理论上知道

---

我应该避免使用这个太多吗？与获取键的值相比，它的性能如何？

在ruby 1.9.3和2.0.0中搜索是O（n）操作

static VALUE
rb_hash_key(VALUE hash, VALUE value)
{
    VALUE args[2];

    args[0] = value;
    args[1] = Qnil;

    rb_hash_foreach(hash, key_i, (VALUE)args);

    return args[1];
}

rb\u hash\u foreach的实现

：

void
rb_hash_foreach(VALUE hash, int (*func)(ANYARGS), VALUE farg)
{
    struct hash_foreach_arg arg; 

    if (!RHASH(hash)->ntbl)
        return;
    RHASH_ITER_LEV(hash)++;
    arg.hash = hash;
    arg.func = (rb_foreach_func *)func;
    arg.arg  = farg;
    rb_ensure(hash_foreach_call, (VALUE)&arg, hash_foreach_ensure, hash);
}

---

然而，您的哈希值很小@theTinMan关于过早优化的说法是正确的，你不应该担心它。

这样想：你偶尔会做一个额外的步骤来获得值。当您使用条件测试并向计算中添加几个步骤时，就会发生这种情况

很明显，这会带来一些开销，但现在担心这一点是过早的优化。您可以通过使用该类来测试获取散列键的替代方法（与常规方法相比）来感受差异

我想你必须做几百万次循环才能看到明显的不同

---

下面是我如何创建@fontanus提到的反向映射：

hash = {a:1, b:2}
hash.merge!(Hash[hash.values.zip(hash.keys)])

其结果是：

{
    :a => 1,
    :b => 2,
     1 => :a,
     2 => :b
}

也可以通过将散列强制转换为数组，将其展平并反转，然后将其转换回散列来完成，但我发现这并不像上面那样直观。YMMV

hash.merge!(Hash[*hash.to_a.flatten.reverse])

---

@steenslag让我想起了。我知道有问题，但记不起方法名：

>> hash.merge!(hash.invert) { :a => 1, :b => 2, 1 => :a, 2 => :b } >>散列，合并！（hash.invert） { ：a=>1， ：b=>2， 1=>：a， 2=>：b }

---

给他一张赞成票

（1）事实并非如此。在Ruby 2.0之前的Ruby 1.9中，哈希是有序的。（2） 散列排序与否对

键有何影响？我看不出有什么理由。@sawa（1）谢谢你说得对，它不是Ruby 2，而是1.9.2。-2号错了。（2） 在无序列表中，你无法比线性搜索更快地找到元素，但如果你知道你的列表是有序的，那么你可以使用其他搜索算法。在什么意义上说，你是“有序的”？在Ruby哈希被称为有序的上下文中，这并不意味着键被“排序”。这意味着插入的键的顺序被保留。@sawa Hum。。。你的意思是结构没有按顺序保持，但是每次你想迭代它时，它都是sorterd？看起来有点奇怪，但可能。。。不管怎样，因为我不确定，所以打第一句。@fotanus“每次你想迭代它都会被排序？”–不。它从来不会自动排序。排序意味着每次遍历都会以相同的顺序生成元素（1.9之前的情况不是这样），即插入元素的顺序。之前的优化以及其他事情是万恶之源。“过早优化”是。哈希有一个方法可以做到这一点：+1 HA！就是这样。我知道有一个，但记不得了。您可以看到我的Perl泄漏到我的答案中。：-）