Controleren of een tekenreeks een substring in Ruby

Ik heb een tekenreeksvariabele met inhoud:

varMessage =   
            "hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"
            "/my/name/is/balaji.so\n"
            "call::myFunction(int const&)\n"
            "void::secondFunction(char const&)\n"
             .
             .
             .
            "this/is/last/line/liobrary.so"

In de reeks moet ik een sub-reeks vinden:

"hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"
"/my/name/is/balaji.so\n"
"call::myFunction(int const&)\n"

Hoe kan ik het vinden? Ik moet bepalen of de substring aanwezig is of niet.

Antwoord 1, Autoriteit 100%

U kunt de include?methode:

my_string = "abcdefg"
if my_string.include? "cde"
   puts "String includes 'cde'"
end

Antwoord 2, Autoriteit 7%

Als Case irrelevant is, dan een Case-ongevoelige reguliere expressie is een goede oplossing:

'aBcDe' =~ /bcd/i  # evaluates as true

Dit zal ook werken voor multi-line strings.

Zie Ruby’s Regexp klasse voor meer informatie.

Antwoord 3, Autoriteit 4%

U kunt dit ook doen …

my_string = "Hello world"
if my_string["Hello"]
  puts 'It has "Hello"'
else
  puts 'No "Hello" found'
end
# => 'It has "Hello"'

Dit voorbeeld maakt gebruik van Ruby’s String #[]methode.

Antwoord 4, Autoriteit 2%

Uitbreiding op het antwoord van Clint Pachl:

Regex-matching in Ruby Retourneert nilwanneer de uitdrukking niet overeenkomt. Wanneer het dat doet, retourneert het de index van het personage waar de match plaatsvindt. Bijvoorbeeld:

"foobar" =~ /bar/  # returns 3
"foobar" =~ /foo/  # returns 0
"foobar" =~ /zzz/  # returns nil

Het is belangrijk om op te merken dat in Ruby alleen nilen de Boolean-expressie falseevalueren naar false. Al het andere, inclusief een lege array, lege hash of de integer 0, evalueert naar True.

Daarom is de /foo/voorbeeld hierboven werken en waarom.

if "string" =~ /regex/

Werkt zoals verwacht, alleen het ‘TRUE’ deel van de ifblokkeren als er een overeenkomst is opgetreden.

Antwoord 5, Autoriteit 2%

Een meer beknopte idioom dan het geaccepteerde antwoord hierboven is dat beschikbaar is in rails (van 3.1.0 en hoger) is .in?:

my_string = "abcdefg"
if "cde".in? my_string
  puts "'cde' is in the String."
  puts "i.e. String includes 'cde'"
end

Ik denk ook dat het meer leesbaar is.

Zie de in?Documentatie voor meer informatie.

Noteer opnieuw dat het alleen beschikbaar is in rails , en niet pure robijn.

Antwoord 6

Ternaire Way

my_string.include?('ahr') ? (puts 'String includes ahr') : (puts 'String does not include ahr')

OF

puts (my_string.include?('ahr') ? 'String includes ahr' : 'String not includes ahr')

Antwoord 7

U kunt de String Element Referencemethode die []

. is

Binnen de []kan een letterlijke substring, een index of een regex zijn:

> s='abcdefg'
=> "abcdefg"
> s['a']
=> "a"
> s['z']
=> nil

Aangezien nilfunctioneel hetzelfde is als falseen elke substring die wordt geretourneerd door []trueis, kunt u gebruik de logica alsof je de methode .include?gebruikt:

0> if s[sub_s]
1>    puts "\"#{s}\" has \"#{sub_s}\""
1> else 
1*    puts "\"#{s}\" does not have \"#{sub_s}\""
1> end
"abcdefg" has "abc"
0> if s[sub_s]
1>    puts "\"#{s}\" has \"#{sub_s}\""
1> else 
1*    puts "\"#{s}\" does not have \"#{sub_s}\""
1> end
"abcdefg" does not have "xyz" 

Zorg er wel voor dat u een index niet verwart met een subtekenreeks:

> '123456790'[8]    # integer is eighth element, or '0'
=> "0"              # would test as 'true' in Ruby
> '123456790'['8']  
=> nil              # correct

U kunt ook een regex gebruiken:

> s[/A/i]
=> "a"
> s[/A/]
=> nil

Antwoord 8

Hoe controleer je of een string een substring bevat in Ruby?

Als je ‘check’ zegt, neem ik aan dat je een boolean wilt retourneren. In dat geval kun je String#match?. match?accepteert strings of regexs als de eerste parameter, als het de eerste is, wordt het automatisch geconverteerd naar een regex. Dus uw gebruiksscenario zou zijn:

str = 'string'
str.match? 'strings' #=> false
str.match? 'string'  #=> true
str.match? 'strin'   #=> true
str.match? 'trin'    #=> true
str.match? 'tri'     #=> true

String#match?heeft het extra voordeel van een optioneel tweede argument dat een index specificeert van waaruit de string moet worden gezocht. Standaard is dit ingesteld op 0.

str.match? 'tri',0   #=> true
str.match? 'tri',1   #=> true
str.match? 'tri',2   #=> false

Antwoord 9

user_input = gets.chomp
user_input.downcase!
if user_input.include?('substring')
  # Do something
end

Hiermee kunt u controleren of de tekenreeks een subtekenreeks bevat of niet

puts "Enter a string"
user_input = gets.chomp  # Ex: Tommy
user_input.downcase!    #  tommy
if user_input.include?('s')
    puts "Found"
else
    puts "Not found"
end