5

Ruby 1.9.3p0 で Rails 3.2.3 を使用しています。

オプションのリストに文字列が含まれているかどうかを判断する必要があることがよくあります。Ruby配列.includeメソッドを使用できるようです:

<% if ['todo','pending','history'].include?(params[:category]) %>

または、正規表現equals-tilde マッチの短縮形で、オプションを区切る垂直バーを使用します。

<% if params[:category] =~ /todo|pending|history/ %>

パフォーマンスの点でどちらが優れていますか?

さらに良いアプローチはありますか?

4

2 に答える 2

9

要約:要素が受け入れられた入力と拒否された入力の両方Array#include?String勝ちます。この例では、受け入れ可能な値が3つしかありません。チェックするより大きなセットについては、Set#include?withString要素が勝つ可能性があるようです。


テスト方法

これは経験的にテストする必要があります。

同様に考慮したい場合があるいくつかの代替手段を次に示します。コンパイル済みの正規表現、シンボルのリスト、およびSetwithString要素です。

パフォーマンスは、ほとんどの入力が期待されるセットに含まれて受け入れられるかどうか、またはほとんどがセット外で拒否されるかどうかにも依存する可能性があると思います。

経験的なテスト スクリプトを次に示します。

require 'benchmark'
require 'set'

strings = ['todo','pending','history']
string_set = Set.new(strings)
symbols = strings.map(&:to_sym)
regex_compiled = Regexp.new(strings.join("|"))

strings_avg_size = (strings.map(&:size).inject {|sum, n| sum + n}.to_f / strings.size).to_i
num_inputs = 1_000_000

accepted_inputs = (0...num_inputs).map { strings[rand(strings.size)] } 
rejected_inputs = (0...num_inputs).map { (0..strings_avg_size).map { ('a'...'z').to_a[rand(26)] }.join }

Benchmark.bmbm(40) do |x|
  x.report("Array#include?, Strings, accepted:") { accepted_inputs.map {|s| strings.include?(s) } }
  x.report("Array#include?, Strings, rejected:") { rejected_inputs.map {|s| strings.include?(s) } }
  x.report("Array#include?, Symbols, accepted:") { accepted_inputs.map {|s| symbols.include?(s.to_sym) } }
  x.report("Array#include?, Symbols, rejected:") { rejected_inputs.map {|s| symbols.include?(s.to_sym) } }
  x.report("Set#include?, Strings, accepted:") { accepted_inputs.map {|s| string_set.include?(s) } }
  x.report("Set#include?, Strings, rejected:") { rejected_inputs.map {|s| string_set.include?(s) } }
  x.report("Regexp#match, interpreted, accepted:") { accepted_inputs.map {|s| s =~ /todo|pending|history/ } }
  x.report("Regexp#match, interpreted, rejected:") { rejected_inputs.map {|s| s =~ /todo|pending|history/ } }
  x.report("Regexp#match, compiled, accepted:") { accepted_inputs.map {|s| regex_compiled.match(s) } }
  x.report("Regexp#match, compiled, rejected:") { rejected_inputs.map {|s| regex_compiled.match(s) } }
end

結果

Rehearsal ---------------------------------------------------------------------------
Array#include?, Strings, accepted:        0.210000   0.000000   0.210000 (  0.215099)
Array#include?, Strings, rejected:        0.530000   0.010000   0.540000 (  0.543898)
Array#include?, Symbols, accepted:        0.330000   0.000000   0.330000 (  0.337767)
Array#include?, Symbols, rejected:        1.870000   0.050000   1.920000 (  1.923155)
Set#include?, Strings, accepted:          0.270000   0.000000   0.270000 (  0.274774)
Set#include?, Strings, rejected:          0.460000   0.000000   0.460000 (  0.463925)
Regexp#match, interpreted, accepted:      0.380000   0.000000   0.380000 (  0.382060)
Regexp#match, interpreted, rejected:      0.650000   0.000000   0.650000 (  0.660775)
Regexp#match, compiled, accepted:         1.130000   0.080000   1.210000 (  1.220970)
Regexp#match, compiled, rejected:         0.630000   0.000000   0.630000 (  0.640721)
------------------------------------------------------------------ total: 6.600000sec

                                              user     system      total        real
Array#include?, Strings, accepted:        0.210000   0.000000   0.210000 (  0.219060)
Array#include?, Strings, rejected:        0.430000   0.000000   0.430000 (  0.444911)
Array#include?, Symbols, accepted:        0.340000   0.000000   0.340000 (  0.341970)
Array#include?, Symbols, rejected:        1.080000   0.000000   1.080000 (  1.089961)
Set#include?, Strings, accepted:          0.270000   0.000000   0.270000 (  0.281270)
Set#include?, Strings, rejected:          0.400000   0.000000   0.400000 (  0.406181)
Regexp#match, interpreted, accepted:      0.370000   0.000000   0.370000 (  0.366931)
Regexp#match, interpreted, rejected:      0.560000   0.000000   0.560000 (  0.558652)
Regexp#match, compiled, accepted:         0.920000   0.000000   0.920000 (  0.915914)
Regexp#match, compiled, rejected:         0.620000   0.000000   0.620000 (  0.627620)

結論

(上記の概要を参照)

チェックを行う前に、これらのランダムな文字列のすべてをシンボルテーブルにインターンする必要があるため、拒否された入力に対してシンボル配列が非常に遅くなるということは、私には理にかなっています。

特にコード内でリテラルとして解釈された Regexp と比較して、コンパイルされた Regexp のパフォーマンスが非常に悪いことは、熟考した後でさえ、私にはあまり意味がありません。なぜそれがそれほど悪いのか、誰か説明できますか?

于 2012-08-10T18:20:30.843 に答える
1

@ms-tg の回答には優れたベンチマークがあり、私に関する限り、あなたの質問に適切に回答しています。ちょっとしたメモを追加したかっただけです。これらの 2 つのオプションが常に同じ結果になるとは限らないため、注意してください。

params = Hash.new
keyword_array = ['todo','pending','history']  
included = nil

params[:category] = "history plus other text" 

start_time = Time.now
1000.times do
   included = keyword_array.include?(params[:category])
end
puts "Array.include? returned #{included} in #{(Time.now - start_time)*1000}ms"    
start_time = Time.now
1000.times do
   included = (params[:category] =~ /todo|pending|history/).is_a?(Integer) 
end
puts "Regexp returned #{included} in #{(Time.now - start_time)*1000}ms"  

戻り値:

Array.include? 0.477ms で false を返しました

正規表現は 0.953ms で true を返しました

この場合、正規表現はtrueを返しましたが、array.include? falseを返しました。これは、ロジックを構築するときに考慮する必要があります。

基本的に、文字列が正確に配列に含まれていない場合、array.include? false になりますが、キーワードの 1 つが文字列のどこかにある場合、正規表現は true になります (他のテキストがあるかどうかに関係なく)。

于 2012-08-10T18:34:26.980 に答える