Jak sprawdzić, czy ciąg znaków zawiera podciąg w Ruby

Mam zmienną łańcuchową z zawartością:

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"

W ciągu muszę znaleźć podciąg:

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

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

Jak mogę to znaleźć? Muszę ustalić, czy podciąg jest obecny, czy nie.

Możesz użyć include?metody:

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

Jeśli wielkość liter jest nieistotna, dobrym rozwiązaniem jest niewrażliwe na wielkość liter wyrażenie regularne :

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

Będzie to również działać w przypadku ciągów wieloliniowych.

Aby uzyskać więcej informacji, zobacz klasę Ruby's Regexp .

Możesz także to zrobić ...

my_string = "Hello world"

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

# => 'It has "Hello"'

W tym przykładzie użyto #[]metody String Ruby .

Rozwijając odpowiedź Clinta Pachla:

Dopasowywanie nilwyrażeń regularnych w Ruby zwraca, gdy wyrażenie nie pasuje. Kiedy to zrobi, zwraca indeks znaku, w którym ma miejsce dopasowanie. Na przykład:

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

Ważne jest, aby pamiętać, że tylko w języku Ruby nilwyrażenie boolowskie ma falsewartość false. Wszystko inne, w tym pusta tablica, pusta wartość skrótu lub liczba całkowita 0, ma wartość true.

Właśnie dlatego /foo/powyższy przykład działa i dlaczego.

if "string" =~ /regex/

działa zgodnie z oczekiwaniami, wpisując „prawdziwą” część ifbloku tylko w przypadku dopasowania.

Bardziej zwięzły idiom niż zaakceptowana powyżej odpowiedź dostępna w Railsach (od 3.1.0 i wyżej) to .in?:

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

Myślę też, że jest bardziej czytelny.

Więcej informacji znajduje się w in?dokumentacji.

Zauważ jeszcze raz, że jest dostępny tylko w Railsach , a nie w czystym Ruby.

Sposób trójskładnikowy

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

LUB

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

Możesz użyć metody String Element Reference , która jest[]

Wewnątrz []może znajdować się dosłowny podciąg, indeks lub wyrażenie regularne:

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

Ponieważ nilfunkcjonalnie jest taki sam, jak falsei każdy zwrócony podciąg []to truemożesz użyć logiki tak, jakbyś używał metody .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" 

Tylko upewnij się, że nie pomylisz indeksu z łańcuchem podrzędnym:

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

Możesz także użyć wyrażenia regularnego:

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

Jak sprawdzić, czy ciąg znaków zawiera podciąg w Ruby?

Kiedy mówisz „sprawdź”, zakładam, że chcesz zwrócić wartość logiczną, w którym to przypadku możesz użyć String#match?. match?akceptuje ciągi lub wyrażenia regularne jako swój pierwszy parametr, jeśli jest to pierwszy parametr, wówczas jest automatycznie konwertowany na wyrażenie regularne. Twój przypadek użycia to:

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

String#match?ma dodatkową zaletę opcjonalnego drugiego argumentu, który określa indeks, z którego należy przeszukiwać ciąg. Domyślnie jest to ustawione na 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

Pomoże to sprawdzić, czy ciąg zawiera podciąg, czy nie

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