functions - ¿Cómo comprobar si una cadena contiene una subcadena en Ruby?

ruby class string

Question

Tengo una variable de cadena con contenido de la siguiente manera:

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 anterior tengo que encontrar una cadena secundaria es decir

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


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

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

Answer 1

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

Cuando dices ''verificar'', asumo que quieres un booleano devuelto, ¿en qué caso puedes usar String#match? . match? acepta cadenas o expresiones regulares como su primer parámetro, si es el primero, entonces se convierte automáticamente en una expresión regular. Entonces tu 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. De forma predeterminada, esto se establece en 0 .

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

Answer 2

Ampliando la respuesta de Clint Pachl:

La coincidencia de expresiones regulares en Ruby devuelve nulo cuando la expresión no coincide. Cuando lo hace, devuelve el índice del carácter donde ocurre la coincidencia. Por ejemplo

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

Es importante tener en cuenta que en Ruby solo nil y la expresión booleana falso se evalúan como falso. 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 ejemplo / foo / anterior funciona, y por qué

if "string" =~ /regex/

Funciona como se espera. Solo se ingresa la parte ''verdadera'' del bloque if si ocurrió una coincidencia.

Answer 3

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

Answer 4

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

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

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

Como nil es funcionalmente lo mismo que false y cualquier subcadena devuelta de [] es true , 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 cadena secundaria:

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

También puede utilizar una expresión regular:

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

Answer 5

Puede utilizar la include? método:

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

Answer 6

Si el caso es irrelevante, entonces una expresión regular que no distinga 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.

Ver clase Regexp de Ruby.

Answer 7

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"''

Answer 8

Un idioma más conciso que el de la respuesta aceptada que está disponible en Rails (desde 3.1.0 y superior) es .in? .

P.ej:

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.

cf http://apidock.com/rails/v3.1.0/Object/in%3F

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

Answer 9

user_input = gets.chomp
user_input.downcase!

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

Esto te ayudará a verificar si la cadena contiene subcadenas 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