Ruby Language
Reguliere expressies en op regex gebaseerde bewerkingen

Groepen, genoemd en anderszins.

Ruby breidt de standaardsyntaxis van de groep (...) met een benoemde groep (?<name>...) . Dit maakt extractie op naam mogelijk in plaats van dat u moet tellen hoeveel groepen u hebt.

name_reg = /h(i|ello), my name is (?<name>.*)/i #i means case insensitive

name_input = "Hi, my name is Zaphod Beeblebrox"

match_data = name_reg.match(name_input) #returns either a MatchData object or nil
match_data = name_input.match(name_reg) #works either way

if match_data.nil? #Always check for nil! Common error.
  puts "No match"
else
  match[0] #=> "Hi, my name is Zaphod Beeblebrox"
  match[1] #=> "i" #the first group, (i|ello)
  match[2] #=> "Zaphod Beeblebrox"
  #Because it was a named group, we can get it by name
  match[:name]  #=> "Zaphod Beeblebrox"
  match["name"] #=> "Zaphod Beeblebrox"
  puts "Hello #{match[:name]}!"
end

De index van de wedstrijd wordt geteld op basis van de volgorde van de linker haakjes (waarbij de hele regex de eerste groep is op index 0)

reg = /(((a)b)c)(d)/
match = reg.match 'abcd'
match[0] #=> "abcd"
match[1] #=> "abc"
match[2] #=> "ab"
match[3] #=> "a"
match[4] #=> "d"

= ~ operator

if /hay/ =~ 'haystack'
  puts "There is hay in the word haystack"
end

Opmerking: de bestelling is aanzienlijk . Hoewel 'haystack' =~ /hay/ in de meeste gevallen een equivalent is, kunnen bijwerkingen verschillen:

• Strings die zijn vastgelegd uit benoemde capture-groepen worden alleen toegewezen aan lokale variabelen wanneer Regexp#=~ wordt aangeroepen ( regexp =~ str );
• Omdat de juiste operand een willekeurig object kan zijn, wordt voor regexp =~ str Regexp#=~ of String#=~ .

Merk op dat dit geen waar / onwaar waarde retourneert, maar in plaats daarvan ofwel de index van de overeenkomst indien gevonden, of nul indien niet gevonden. Omdat alle gehele getallen in robijn waarachtig zijn (inclusief 0) en nul is vals, werkt dit. Als u een Booleaanse waarde wilt, gebruikt u #=== zoals in een ander voorbeeld wordt getoond.

quantifiers

Met Quantifiers kunt u het aantal herhaalde tekenreeksen opgeven.

• Nul of één:

  /a?/
  

• Nul of veel:

  /a*/
  

• Een of meerdere:

  /a+/
  

• Exact getal:

  /a{2,4}/ # Two, three or four
  /a{2,}/  # Two or more
  /a{,4}/  # Less than four (including zero)
  

Standaard zijn kwantificatoren hebzuchtig , wat betekent dat ze zoveel tekens als ze kunnen nemen terwijl ze nog steeds een match maken. Normaal valt dit niet op:

/(?<site>.*) Stack Exchange/ =~ 'Motor Vehicle Maintenance & Repair Stack Exchange'

De genoemde capture-groep site zal worden ingesteld op '' Motor Vehicle Maintenance & Repair' zoals verwacht. Maar als 'Stack Exchange' een optioneel onderdeel van de string is (omdat het in plaats daarvan 'Stack Overflow' kan zijn), werkt de naïeve oplossing niet zoals verwacht:

/(?<site>.*)( Stack Exchange)?/

Deze versie komt nog steeds overeen, maar de genoemde opname bevat 'Stack Exchange' omdat * deze karakters gretig opeet. De oplossing is om nog een vraagteken toe te voegen om de * lui te maken:

/(?<site>.*?)( Stack Exchange)?/

Toevoegen ? naar elke kwantificator zal het lui maken.

Karakter klassen

Beschrijft reeksen symbolen

U kunt symbolen expliciet opsommen

/[abc]/ # 'a' or 'b' or 'c'

Of gebruik bereiken

/[a-z]/ # from 'a' to 'z'

Het is mogelijk om bereiken en afzonderlijke symbolen te combineren

/[a-cz]/ # 'a' or 'b' or 'c' or 'z'

Voorloopstreepje ( - ) wordt behandeld als charachter

/[-a-c]/ # '-' or 'a' or 'b' or 'c'

Klassen kunnen negatief zijn als u symbolen voorafgaat met ^

/[^a-c]/ # Not 'a', 'b' or 'c'

Er zijn enkele snelkoppelingen voor wijdverbreide klassen en speciale charachters, plus regeleinden

^  # Start of line
$  # End of line
\A # Start of string
\Z # End of string, excluding any new line at the end of string
\z # End of string
.  # Any single character
\s # Any whitespace character
\S # Any non-whitespace character
\d # Any digit
\D # Any non-digit
\w # Any word character (letter, number, underscore)
\W # Any non-word character
\b # Any word boundary

\n zal eenvoudig worden begrepen als een nieuwe regel

Om te ontsnappen aan gereserveerde tekens, zoals / of [] en anderen, gebruikt u backslash (slash)

\\ # => \
\[\] # => []

Reguliere uitdrukkingen in case-statements

U kunt testen of een string overeenkomt met verschillende reguliere expressies met behulp van een schakeloptie.

Voorbeeld

case "Ruby is #1!"
when /\APython/
    puts "Boooo."
when /\ARuby/
    puts "You are right."
else 
    puts "Sorry, I didn't understand that."
end

Dit werkt omdat hoofdletters en kleine letters worden gecontroleerd op gelijkheid met de operator === , niet met de operator == . Wanneer een regex zich aan de linkerkant van een vergelijking bevindt met === , zal het een string testen om te zien of deze overeenkomt.

Een Regexp definiëren

Een Regexp kan op drie verschillende manieren in Ruby worden gemaakt.

• schuine strepen gebruiken: / /

• %r{}

• met behulp van Regex.new

  #The following forms are equivalent
  regexp_slash = /hello/
  regexp_bracket = %r{hello}
  regexp_new = Regexp.new('hello')
  
  string_to_match = "hello world!"
  
  #All of these will return a truthy value
  string_to_match =~ regexp_slash    # => 0
  string_to_match =~ regexp_bracket  # => 0
  string_to_match =~ regexp_new      # => 0
  

bij elkaar passen? - Booleaans resultaat

Retourneert true of false , wat aangeeft of de regexp overeenkomt of niet zonder $~ en andere gerelateerde variabelen bij te werken. Als de tweede parameter aanwezig is, geeft deze de positie in de tekenreeks aan om met zoeken te beginnen.

/R.../.match?("Ruby")    #=> true
/R.../.match?("Ruby", 1) #=> false
/P.../.match?("Ruby")    #=> false

Ruby 2.4+

Algemeen snel gebruik

Reguliere expressies worden vaak in methoden als parameters gebruikt om te controleren of andere tekenreeksen aanwezig zijn of om tekenreeksen te zoeken en / of te vervangen.

Je ziet vaak het volgende:

string = "My not so long string"
string[/so/] # gives so
string[/present/] # gives nil
string[/present/].nil? # gives true

Je kunt dit dus eenvoudigweg gebruiken om te controleren of een string een substring bevat

puts "found" if string[/so/]

Meer geavanceerd maar nog steeds kort en snel: zoek naar een specifieke groep met behulp van de tweede parameter, 2 is de tweede in dit voorbeeld omdat nummering begint bij 1 en niet 0, een groep is wat tussen haakjes staat.

string[/(n.t).+(l.ng)/, 2] # gives long

Ook vaak gebruikt: zoeken en vervangen door sub of gsub , \1 geeft de eerst gevonden groep, \2 de tweede:

string.gsub(/(n.t).+(l.ng)/, '\1 very \2') # My not very long string

Het laatste resultaat wordt onthouden en kan op de volgende regels worden gebruikt

$2 # gives long