Comment vérifier si une chaîne contient une sous-chaîne en Ruby

J'ai une variable chaîne avec du contenu:

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"

Dans la chaîne, je dois trouver une sous-chaîne:

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

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

Comment le trouver? J'ai besoin de déterminer si la sous-chaîne est présente ou non.

Vous pouvez utiliser la include?méthode:

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

Si la casse n'est pas pertinente, alors une expression régulière insensible à la casse est une bonne solution:

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

Cela fonctionnera également pour les chaînes multi-lignes.

Voir la classe Regexp de Ruby pour plus d'informations.

Vous pouvez également le faire ...

my_string = "Hello world"

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

# => 'It has "Hello"'

Cet exemple utilise la #[]méthode String de Ruby .

Développant la réponse de Clint Pachl:

La correspondance d' nilexpressions régulières dans Ruby revient lorsque l'expression ne correspond pas. Dans ce cas, il retourne l'index du caractère où la correspondance se produit. Par exemple:

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

Il est important de noter que dans Ruby uniquement nilet que l'expression booléenne est falsefausse. Tout le reste, y compris un tableau vide, un hachage vide ou le nombre entier 0, est évalué comme vrai.

C'est pourquoi l' /foo/exemple ci-dessus fonctionne et pourquoi.

if "string" =~ /regex/

fonctionne comme prévu, n'entrant dans la partie «vraie» du ifbloc que si une correspondance s'est produite.

Un idiome plus succinct que la réponse acceptée ci-dessus qui est disponible dans Rails (à partir de 3.1.0 et supérieur) est .in?:

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

Je pense aussi que c'est plus lisible.

Consultez la in?documentation pour plus d'informations.

Notez à nouveau qu'il n'est disponible que dans Rails , et non en Ruby pur.

Voie ternaire

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

OU

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

Vous pouvez utiliser la méthode String Element Reference qui est[]

À l'intérieur du []peut être une sous-chaîne littérale, un index ou une expression régulière:

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

Puisque nilest fonctionnellement identique à falseet que toute sous-chaîne renvoyée l' []est, truevous pouvez utiliser la logique comme si vous utilisiez la méthode .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" 

Assurez-vous simplement de ne pas confondre un index avec une sous-chaîne:

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

Vous pouvez également utiliser une expression régulière:

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

Comment vérifier si une chaîne contient une sous-chaîne en Ruby?

Lorsque vous dites «vérifier», je suppose que vous souhaitez renvoyer un booléen, auquel cas vous pouvez l'utiliser String#match?. match?accepte les chaînes ou les expressions régulières comme premier paramètre, si c'est le premier, il est automatiquement converti en expression régulière. Votre cas d'utilisation serait donc:

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

String#match?a l'avantage supplémentaire d'un deuxième argument facultatif qui spécifie un index à partir duquel rechercher la chaîne. Par défaut, il est défini sur 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

Cela vous aidera à vérifier si la chaîne contient ou non une sous-chaîne

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