Cómo verificar si una cadena contiene una subcadena en Ruby

Tengo una variable de cadena con contenido:

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"

En la cadena tengo que encontrar una subcadena:

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

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

¿Cómo puedo encontrarlo? Necesito determinar si la subcadena está presente o no.

Puedes usar el include?método:

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

Si el caso es irrelevante, entonces una expresión regular que no distingue entre mayúsculas y minúsculas es una buena solución:

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

Esto también funcionará para cadenas de varias líneas.

Vea la clase Regexp de Ruby para más información.

También puedes hacer esto ...

my_string = "Hello world"

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

# => 'It has "Hello"'

Este ejemplo utiliza el #[]método de Ruby String .

Ampliando la respuesta de Clint Pachl:

La coincidencia de expresiones regulares en Ruby regresa nilcuando la expresión no coincide. Cuando lo hace, devuelve el índice del personaje donde ocurre la coincidencia. Por ejemplo:

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

Es importante tener en cuenta que solo en Ruby nily la expresión booleana se falseevalúa como falsa. Todo lo demás, incluida una matriz vacía, un hash vacío o el entero 0, se evalúa como verdadero.

Es por eso que el /foo/ejemplo anterior funciona y por qué.

if "string" =~ /regex/

funciona como se esperaba, solo ingresa la parte 'verdadera' del ifbloque si se produce una coincidencia.

Una expresión más sucinta que la respuesta aceptada anterior que está disponible en Rails (desde 3.1.0 y superior) es .in?:

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

También creo que es más legible.

Consulte la in?documentación para más información.

Tenga en cuenta nuevamente que solo está disponible en Rails , y no en Ruby puro.

Camino 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')

Puede usar el método de referencia de elemento de cadena que es[]

Dentro de []puede ser una subcadena literal, un índice o una expresión regular:

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

Dado que niles funcionalmente el mismo falsey cualquier subcadena devuelta []es trueque puede usar la lógica como si usara el método .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" 

Solo asegúrese de no confundir un índice con una subcadena:

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

También puedes usar una expresión regular:

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

¿Cómo verificar si una cadena contiene una subcadena en Ruby?

Cuando dices 'comprobar', supongo que quieres que se devuelva un booleano, en cuyo caso puedes usarlo String#match?. match?acepta cadenas o expresiones regulares como su primer parámetro, si es el primero, se convierte automáticamente en una expresión regular. Entonces su caso de uso sería:

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

String#match?tiene el beneficio adicional de un segundo argumento opcional que especifica un índice desde el cual buscar la cadena. Por defecto, esto está configurado en 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

Esto lo ayudará a verificar si la cadena contiene una subcadena o no

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