Come verificare se una stringa contiene una sottostringa in Ruby

Ho una variabile stringa con contenuto:

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"

Nella stringa devo trovare una sottostringa:

"hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"

"/my/name/is/balaji.so\n"
"call::myFunction(int const&)\n"

Come posso trovarlo? Devo determinare se la sottostringa è presente o meno.

Puoi usare il include?metodo:

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

Se il caso è irrilevante, un'espressione regolare senza distinzione tra maiuscole e minuscole è una buona soluzione:

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

Questo funzionerà anche con stringhe multilinea.

Vedi la classe Regexp di Ruby per maggiori informazioni.

Puoi anche farlo ...

my_string = "Hello world"

if my_string["Hello"]
  puts 'It has "Hello"'
else
  puts 'No "Hello" found'
end

# => 'It has "Hello"'

Questo esempio usa il #[]metodo String di Ruby .

Espandendo la risposta di Clint Pachl:

La corrispondenza del Regex in Ruby ritorna nilquando l'espressione non corrisponde. Quando lo fa, restituisce l'indice del personaggio in cui si verifica l'incontro. Per esempio:

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

È importante notare che solo in Ruby nile l'espressione booleana vengono falsevalutate come false. Tutto il resto, incluso un array vuoto, un hash vuoto o il numero intero 0, viene considerato vero.

Ecco perché l' /foo/esempio sopra funziona e perché.

if "string" =~ /regex/

funziona come previsto, inserendo la parte "vera" del ifblocco solo se si verifica una corrispondenza.

Un linguaggio più succinto della risposta accettata sopra che è disponibile in Rails (dalla 3.1.0 in poi) è .in?:

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

Penso anche che sia più leggibile.

Vedere la in?documentazione per ulteriori informazioni.

Nota di nuovo che è disponibile solo in Rails e non in puro Ruby.

Modo ternario

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

O

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

È possibile utilizzare il metodo String Element Reference che è[]

All'interno []può esserci una sottostringa letterale, un indice o una regex:

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

Poiché nilè funzionalmente uguale falsee qualsiasi sottostringa restituita []è trueche è possibile utilizzare la logica come se si utilizza il metodo .include?:

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" 

Assicurati solo di non confondere un indice con una sottostringa:

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

Puoi anche usare un regex:

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

Come verificare se una stringa contiene una sottostringa in Ruby?

Quando dici "check", presumo che tu voglia restituire un booleano, nel qual caso puoi usarlo String#match?. match?accetta stringhe o regex come primo parametro, se è il primo viene automaticamente convertito in regex. Quindi il tuo caso d'uso sarebbe:

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

String#match?ha il vantaggio aggiuntivo di un secondo argomento facoltativo che specifica un indice da cui cercare la stringa. Per impostazione predefinita, questo è impostato su 0.

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

user_input = gets.chomp
user_input.downcase!

if user_input.include?('substring')
  # Do something
end

Questo ti aiuterà a verificare se la stringa contiene o meno una sottostringa

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