Merge pull request #150 from bdewater/regexp-match-questionmark

Add `String#match?` to comparisons

Author: Arcovion

README.md

@@ -975,7 +975,11 @@ Comparison:
             String#+:  2977282.7 i/s - 1.80x slower
 ```
 
-##### `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)
+##### `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 
+`String#start_with?`/`String#end_with?`.
 
 > :warning: <br>
 > Sometimes you cant replace regexp with `start_with?`, <br>
@@ -988,34 +992,32 @@ Comparison:
 
 ```
 $ ruby -v code/string/start-string-checking-match-vs-start_with.rb
-ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]
-
-Calculating -------------------------------------
-           String#=~    56.672k i/100ms
-  String#start_with?   118.308k i/100ms
--------------------------------------------------
-           String#=~    919.574k (± 6.4%) i/s -      4.590M
-  String#start_with?      4.177M (± 6.4%) i/s -     20.822M
+  ruby 2.4.3p205 (2017-12-14 revision 61247) [x86_64-darwin17]
 
-Comparison:
-  String#start_with?:  4177162.6 i/s
-           String#=~:   919574.2 i/s - 4.54x slower
+  Calculating -------------------------------------
+             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
+             String#=~:  1088461.5 i/s - 5.80x  slower
 ```
 
 ```
 $ ruby -v code/string/end-string-checking-match-vs-end_with.rb
-ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]
+  ruby 2.4.3p205 (2017-12-14 revision 61247) [x86_64-darwin17]
 
-Calculating -------------------------------------
-           String#=~    53.194k i/100ms
-    String#end_with?   105.871k i/100ms
--------------------------------------------------
-           String#=~    891.124k (± 7.2%) i/s -      4.468M
-    String#end_with?      2.942M (± 7.6%) i/s -     14.610M
-
-Comparison:
-    String#end_with?:  2942017.4 i/s
-           String#=~:   891124.1 i/s - 3.30x slower
+  Calculating -------------------------------------
+             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
+             String#=~:   918100.5 i/s - 4.95x  slower
 ```
 
 ##### `String#start_with?` vs `String#[].==` [code](code/string/start_with-vs-substring-==.rb)
@@ -1037,32 +1039,35 @@ Comparison:
    String#[0...n] ==:   427206.8 i/s - 4.79x slower
 ```
 
-##### `Regexp#===` vs `String#match` vs `String#=~` [code ](code/string/===-vs-=~-vs-match.rb)
+##### `Regexp#===` vs `String#match` vs `String#=~` vs `String#match?` [code ](code/string/===-vs-=~-vs-match.rb)
+
+`String#match?` and `Regexp#match?` are available on Ruby 2.4 or later.
+ActiveSupport [provides](http://guides.rubyonrails.org/v5.1/active_support_core_extensions.html#match-questionmark)
+a forward compatible extension of `Regexp` for older Rubies without the speed
+improvement.
 
 > :warning: <br>
-> Sometimes you can't replace `match` with `=~`, <br>
+> Sometimes you can't replace `match` with `match?`, <br>
 > This is only useful for cases where you are checking <br>
 > for a match and not using the resultant match object. <br>
 > :warning: <br>
 > `Regexp#===` is also faster than `String#match` but you need to switch the order of arguments.
 
 ```
-$ ruby -v code/string/===-vs-=~-vs-match.rb.rb
-ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]
+$ ruby -v code/string/===-vs-=~-vs-match.rb
+ruby 2.4.3p205 (2017-12-14 revision 61247) [x86_64-darwin17]
 
 Calculating -------------------------------------
-           String#=~    98.184k i/100ms
-          Regexp#===    92.382k i/100ms
-        String#match    83.601k i/100ms
--------------------------------------------------
-           String#=~      2.442M (± 7.6%) i/s -     12.175M
-          Regexp#===      2.259M (± 7.9%) i/s -     11.271M
-        String#match      1.840M (± 7.3%) i/s -      9.196M
+       String#match?      6.284M (± 5.6%) i/s -     31.324M in   5.001471s
+           String#=~      2.581M (± 4.7%) i/s -     12.977M in   5.038887s
+          Regexp#===      2.482M (± 4.1%) i/s -     12.397M in   5.002808s
+        String#match      2.097M (± 4.3%) i/s -     10.592M in   5.060535s
 
 Comparison:
-           String#=~:  2442335.1 i/s
-          Regexp#===:  2259277.3 i/s - 1.08x slower
-        String#match:  1839815.4 i/s - 1.33x slower
+       String#match?:  6283591.8 i/s
+           String#=~:  2581356.8 i/s - 2.43x  slower
+          Regexp#===:  2482379.7 i/s - 2.53x  slower
+        String#match:  2096984.3 i/s - 3.00x  slower
 ```
 
 See [#59](https://github.com/JuanitoFatas/fast-ruby/pull/59) and [#62](https://github.com/JuanitoFatas/fast-ruby/pull/62) for discussions.

code/string/===-vs-=~-vs-match.rb

@@ -1,20 +1,25 @@
 require "benchmark/ips"
 
-def fastest
+def fast
+  "foo".freeze.match?(/boo/)
+end
+
+def slow
   "foo".freeze =~ /boo/
 end
 
-def fast
+def slower
   /boo/ === "foo".freeze  
 end
 
-def slow
+def slowest
   "foo".freeze.match(/boo/)
 end
 
 Benchmark.ips do |x|
-  x.report("String#=~") { fastest }
-  x.report("Regexp#===") { fast }
-  x.report("String#match") { slow }
+  x.report("String#match?") { fast } if RUBY_VERSION >= "2.4.0".freeze
+  x.report("String#=~") { slow }
+  x.report("Regexp#===") { slower }
+  x.report("String#match") { slowest }
   x.compare!
 end

code/string/end-string-checking-match-vs-end_with.rb

@@ -1,17 +1,22 @@
 require 'benchmark/ips'
 
-SLUG = 'root_url'
+SLUG = "some_kind_of_root_url"
 
-def slow
+def slower
   SLUG =~ /_(path|url)$/
 end
 
+def slow
+  SLUG.match?(/_(path|url)$/)
+end
+
 def fast
   SLUG.end_with?('_path', '_url')
 end
 
 Benchmark.ips do |x|
-  x.report('String#=~')        { slow }
+  x.report('String#=~')        { slower }
+  x.report('String#match?')    { slow } if RUBY_VERSION >= "2.4.0".freeze
   x.report('String#end_with?') { fast }
   x.compare!
 end

code/string/start-string-checking-match-vs-start_with.rb

@@ -1,17 +1,22 @@
 require 'benchmark/ips'
 
-SLUG = 'test_reverse_merge.rb'
+SLUG = 'test_some_kind_of_long_file_name.rb'
 
-def slow
+def slower
   SLUG =~ /^test_/
 end
 
+def slow
+  SLUG.match?(/^test_/)
+end
+
 def fast
   SLUG.start_with?('test_')
 end
 
 Benchmark.ips do |x|
-  x.report('String#=~')          { slow }
+  x.report('String#=~')          { slower }
+  x.report('String#match?')      { slow } if RUBY_VERSION >= "2.4.0".freeze
   x.report('String#start_with?') { fast }
   x.compare!
 end