Найшвидший спосіб перевірити, чи рядок відповідає регулярному виразу в ruby?

Який найшвидший спосіб перевірити, чи рядок відповідає регулярному виразу в Ruby?

Моя проблема полягає в тому, що мені доводиться "egrep" перелічувати величезний список рядків, щоб знайти, які саме відповідають регулярному вираженню, що надається під час виконання. Мене цікавить лише те, чи рядок відповідає регулярному вираженню, а не те, де він відповідає, і який вміст відповідних груп. Я сподіваюся, це припущення може бути використано для зменшення часу, який мій код витрачає на відповідність регулярним виразам.

Я завантажую регулярний вираз

pattern = Regexp.new(ptx).freeze

Я виявив, що string =~ patternце трохи швидше, ніж string.match(pattern).

Чи існують інші прийоми або комбінації клавіш, які можуть допомогти зробити цей тест ще швидшим?

Починаючи з Ruby 2.4.0, ви можете використовувати RegExp#match?:

pattern.match?(string)

Regexp#match?явно вказано як підвищення продуктивності в примітках до випуску для 2.4.0 , оскільки дозволяє уникнути розподілу об'єктів, виконаних іншими методами, такими як Regexp#matchі=~ :

Regexp # збіг?
Додано Regexp#match?, яке виконує збіг регулярного виразу, не створюючи об’єкт зворотного посилання і не змінюючи його $~для зменшення розподілу об’єктів.

Це простий орієнтир:

require 'benchmark'

"test123" =~ /1/
=> 4
Benchmark.measure{ 1000000.times { "test123" =~ /1/ } }
=>   0.610000   0.000000   0.610000 (  0.578133)

"test123"[/1/]
=> "1"
Benchmark.measure{ 1000000.times { "test123"[/1/] } }
=>   0.718000   0.000000   0.718000 (  0.750010)

irb(main):019:0> "test123".match(/1/)
=> #<MatchData "1">
Benchmark.measure{ 1000000.times { "test123".match(/1/) } }
=>   1.703000   0.000000   1.703000 (  1.578146)

Так =~швидше, але це залежить від того, що ви хочете мати як повернене значення. Якщо ви просто хочете перевірити, чи містить текст регулярний вираз чи його не використовувати=~

Це орієнтир, який я провів, знайшовши деякі статті в мережі.

У 2.4.0 переможець re.match?(str)(як пропонує @ wiktor-stribiżew), у попередніх версіях re =~ strздається найшвидшим, хоча str =~ reмайже таким же швидким.

#!/usr/bin/env ruby
require 'benchmark'

str = "aacaabc"
re = Regexp.new('a+b').freeze

N = 4_000_000

Benchmark.bm do |b|
    b.report("str.match re\t") { N.times { str.match re } }
    b.report("str =~ re\t")    { N.times { str =~ re } }
    b.report("str[re]  \t")    { N.times { str[re] } }
    b.report("re =~ str\t")    { N.times { re =~ str } }
    b.report("re.match str\t") { N.times { re.match str } }
    if re.respond_to?(:match?)
        b.report("re.match? str\t") { N.times { re.match? str } }
    end
end

Результати МРТ 1.9.3-o551:

$ ./bench-re.rb  | sort -t $'\t' -k 2
       user     system      total        real
re =~ str         2.390000   0.000000   2.390000 (  2.397331)
str =~ re         2.450000   0.000000   2.450000 (  2.446893)
str[re]           2.940000   0.010000   2.950000 (  2.941666)
re.match str      3.620000   0.000000   3.620000 (  3.619922)
str.match re      4.180000   0.000000   4.180000 (  4.180083)

Результати МРТ 2.1.5:

$ ./bench-re.rb  | sort -t $'\t' -k 2
       user     system      total        real
re =~ str         1.150000   0.000000   1.150000 (  1.144880)
str =~ re         1.160000   0.000000   1.160000 (  1.150691)
str[re]           1.330000   0.000000   1.330000 (  1.337064)
re.match str      2.250000   0.000000   2.250000 (  2.255142)
str.match re      2.270000   0.000000   2.270000 (  2.270948)

Результати МРТ 2.3.3 (здається, є регресія у відповідності регулярних виразів):

$ ./bench-re.rb  | sort -t $'\t' -k 2
       user     system      total        real
re =~ str         3.540000   0.000000   3.540000 (  3.535881)
str =~ re         3.560000   0.000000   3.560000 (  3.560657)
str[re]           4.300000   0.000000   4.300000 (  4.299403)
re.match str      5.210000   0.010000   5.220000 (  5.213041)
str.match re      6.000000   0.000000   6.000000 (  6.000465)

Результати МРТ 2.4.0:

$ ./bench-re.rb  | sort -t $'\t' -k 2
       user     system      total        real
re.match? str     0.690000   0.010000   0.700000 (  0.682934)
re =~ str         1.040000   0.000000   1.040000 (  1.035863)
str =~ re         1.040000   0.000000   1.040000 (  1.042963)
str[re]           1.340000   0.000000   1.340000 (  1.339704)
re.match str      2.040000   0.000000   2.040000 (  2.046464)
str.match re      2.180000   0.000000   2.180000 (  2.174691)

А як щодо re === str(порівняння випадку)?

Оскільки він оцінює істинність чи хибність і не потребує зберігання збігів, повернення індексу збігів та іншої інформації, мені цікаво, чи був би це ще швидшим способом порівняння, ніж =~.

Добре, я тестував це. =~все одно швидше, навіть якщо у вас є кілька груп захоплення, проте це швидше, ніж інші варіанти.

До речі, що хорошого freeze? Я не міг виміряти жодного підвищення продуктивності від цього.

Залежно від того, наскільки складним є ваш регулярний вираз, ви можете просто використовувати просту нарізку рядків. Я не впевнений у практичності цього для вашої програми чи в тому, чи він справді може запропонувати якісь покращення швидкості.

'testsentence'['stsen']
=> 'stsen' # evaluates to true
'testsentence'['koala']
=> nil # evaluates to false

Мені цікаво, чи є якийсь дивний спосіб зробити цю перевірку ще швидшим, можливо, використовуючи якийсь дивний метод у Regexp або якусь дивну конструкцію.

Двигуни Regexp відрізняються тим, як вони здійснюють пошук, але, загалом, закріплюють ваші шаблони на швидкість і уникають жадібних збігів, особливо при пошуку довгих рядків.

Найкраще, поки ви не ознайомитесь з тим, як працює певний движок, - це робити тести та додавати / видаляти прив’язки, спробувати обмежити пошук, використовувати підстановочні знаки проти явних збігів тощо.

Фруктово камінь дуже корисна для швидкого бенчмаркінг речей, тому що це розумно. Вбудований Benchmark- код Ruby також корисний, хоча ви можете писати тести, які обманюють вас, не дотримуючись обережності.

Я використовував обидва варіанти у багатьох відповідях тут, на Stack Overflow, тому ви можете шукати мої відповіді та побачити безліч маленьких хитрощів та результатів, щоб дати вам ідеї щодо того, як писати швидший код.

Найбільше, що слід пам’ятати, це погано передчасно оптимізувати свій код, перш ніж дізнатись, де відбуваються уповільнення.

Щоб заповнити відповіді Wiktor Stribiżew та Dougui, я б сказав, що /regex/.match?("string")приблизно так само швидко "string".match?(/regex/).

Рубін 2.4.0 (10000000 ~ 2 сек)

2.4.0 > require 'benchmark'
 => true 
2.4.0 > Benchmark.measure{ 10000000.times { /^CVE-[0-9]{4}-[0-9]{4,}$/.match?("CVE-2018-1589") } }
 => #<Benchmark::Tms:0x005563da1b1c80 @label="", @real=2.2060338060000504, @cstime=0.0, @cutime=0.0, @stime=0.04000000000000001, @utime=2.17, @total=2.21> 
2.4.0 > Benchmark.measure{ 10000000.times { "CVE-2018-1589".match?(/^CVE-[0-9]{4}-[0-9]{4,}$/) } }
 => #<Benchmark::Tms:0x005563da139eb0 @label="", @real=2.260814556000696, @cstime=0.0, @cutime=0.0, @stime=0.010000000000000009, @utime=2.2500000000000004, @total=2.2600000000000007> 

Рубін 2.6.2 (100 000 000 ~ 20 с)

irb(main):001:0> require 'benchmark'
=> true
irb(main):005:0> Benchmark.measure{ 100000000.times { /^CVE-[0-9]{4}-[0-9]{4,}$/.match?("CVE-2018-1589") } }
=> #<Benchmark::Tms:0x0000562bc83e3768 @label="", @real=24.60139879199778, @cstime=0.0, @cutime=0.0, @stime=0.010000999999999996, @utime=24.565644999999996, @total=24.575645999999995>
irb(main):004:0> Benchmark.measure{ 100000000.times { "CVE-2018-1589".match?(/^CVE-[0-9]{4}-[0-9]{4,}$/) } }
=> #<Benchmark::Tms:0x0000562bc846aee8 @label="", @real=24.634255946999474, @cstime=0.0, @cutime=0.0, @stime=0.010046, @utime=24.598276, @total=24.608321999999998>

Примітка: час змінюється, іноді /regex/.match?("string")швидше, а іноді "string".match?(/regex/), різниця може бути лише внаслідок активності машини.