Merge pull request #154 from JacobEvelyn/inefficient-hash-search

Add Hash#key? vs. Hash#keys.include? and Hash#value? vs. Hash#values.include?

Author: ixti

README.md

@@ -805,6 +805,41 @@ Comparison:
       Hash#keys.each:   869262.3 i/s - 1.21x slower
 ```
 
+#### `Hash#key?` instead of `Hash#keys.include?` [code](code/hash/keys-include-vs-\[\]-vs-key.rb)
+
+> `Hash#keys.include?` allocates an array of keys and performs an O(n) search; <br>
+> `Hash#key?` performs an O(1) hash lookup without allocating a new array.
+
+```
+$ ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin17]
+
+Calculating -------------------------------------
+  Hash#keys.include?      8.612k (± 2.5%) i/s -     43.248k in   5.024749s
+           Hash#key?      6.366M (± 5.5%) i/s -     31.715M in   5.002276s
+
+Comparison:
+           Hash#key?:  6365855.5 i/s
+  Hash#keys.include?:     8612.4 i/s - 739.15x  slower
+```
+
+##### `Hash#value?` instead of `Hash#values.include?` [code](code/hash/values-include-vs-value.rb)
+
+> `Hash#values.include?` allocates an array of values and performs an O(n) search; <br>
+> `Hash#value?` performs an O(n) search without allocating a new array.
+
+```
+$ ruby -v code/hash/values-include-vs-value.rb
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin17]
+
+Calculating -------------------------------------
+Hash#values.include?     23.187k (± 4.3%) i/s -    117.720k in   5.086976s
+         Hash#value?     38.395k (± 1.0%) i/s -    194.361k in   5.062696s
+
+Comparison:
+         Hash#value?:    38395.0 i/s
+Hash#values.include?:    23186.8 i/s - 1.66x  slower
+```
+
 ##### `Hash#merge!` vs `Hash#[]=` [code](code/hash/merge-bang-vs-\[\]=.rb)
 
 ```
@@ -1020,7 +1055,7 @@ Comparison:
 ##### `String#match` vs `String.match?` vs `String#start_with?`/`String#end_with?` [code (start)](code/string/start-string-checking-match-vs-start_with.rb) [code (end)](code/string/end-string-checking-match-vs-end_with.rb)
 
 The regular expression approaches become slower as the tested string becomes
-longer. For short strings, `String#match?` performs similarly to 
+longer. For short strings, `String#match?` performs similarly to
 `String#start_with?`/`String#end_with?`.
 
 > :warning: <br>
@@ -1040,7 +1075,7 @@ $ ruby -v code/string/start-string-checking-match-vs-start_with.rb
              String#=~      1.088M (± 4.0%) i/s -      5.471M in   5.034404s
          String#match?      5.138M (± 5.0%) i/s -     25.669M in   5.008810s
     String#start_with?      6.314M (± 4.3%) i/s -     31.554M in   5.007207s
-  
+
   Comparison:
     String#start_with?:  6314182.0 i/s
          String#match?:  5138115.1 i/s - 1.23x  slower
@@ -1055,7 +1090,7 @@ $ ruby -v code/string/end-string-checking-match-vs-end_with.rb
              String#=~    918.101k (± 6.0%) i/s -      4.650M in   5.084079s
          String#match?      3.009M (± 6.8%) i/s -     14.991M in   5.005691s
       String#end_with?      4.548M (± 9.3%) i/s -     22.684M in   5.034115s
-  
+
   Comparison:
       String#end_with?:  4547871.0 i/s
          String#match?:  3008554.5 i/s - 1.51x  slower

code/hash/keys-include-vs-key.rb

@@ -0,0 +1,18 @@
+require "benchmark/ips"
+
+HASH = Hash[*("a".."zzz").to_a.shuffle]
+KEY = "zz"
+
+def key_fast
+  HASH.key? KEY
+end
+
+def key_slow
+  HASH.keys.include? KEY
+end
+
+Benchmark.ips do |x|
+  x.report("Hash#keys.include?") { key_slow }
+  x.report("Hash#key?") { key_fast }
+  x.compare!
+end

code/hash/values-include-vs-value.rb

@@ -0,0 +1,18 @@
+require "benchmark/ips"
+
+HASH = Hash[*("a".."zzz").to_a.shuffle]
+VALUE = "zz"
+
+def value_fast
+  HASH.value? VALUE
+end
+
+def value_slow
+  HASH.values.include? VALUE
+end
+
+Benchmark.ips do |x|
+  x.report("Hash#values.include?") { value_slow }
+  x.report("Hash#value?") { value_fast }
+  x.compare!
+end