Bir dizenin Ruby'de bir alt dize içerip içermediğini kontrol etme

İçeriği olan bir dize değişkeni var:

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"

Dize bir alt dize bulmak zorunda:

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

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

Nasıl bulabilirim? Alt dize olup olmadığını belirlemek gerekir.

include?Yöntemi kullanabilirsiniz :

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

Durum ilgisizse, büyük / küçük harf duyarsız bir düzenli ifade iyi bir çözümdür:

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

Bu, çok satırlı dizelerde de çalışır.

Daha fazla bilgi için Ruby'nin Regexp sınıfına bakın .

Bunu da yapabilirsiniz ...

my_string = "Hello world"

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

# => 'It has "Hello"'

Bu örnekte Ruby'nin String #[]yöntemi kullanılmıştır.

Clint Pachl'ın cevabına genişleyen:

nilİfade eşleşmediğinde Ruby'deki normal ifade eşleşmesi döndürülür . Bu gerçekleştiğinde, eşleşmenin gerçekleştiği karakterin dizinini döndürür. Örneğin:

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

Yalnızca Ruby'de nilve boole ifadesinin falseyanlış olarak değerlendirildiğini belirtmek önemlidir . Boş bir Dizi, boş Karma veya Tamsayı 0 dahil olmak üzere diğer her şey doğru olarak değerlendirilir.

Bu yüzden /foo/yukarıdaki örnek işe yarıyor ve neden.

if "string" =~ /regex/

beklendiği gibi çalışır, yalnızca ifbir eşleşme gerçekleştiğinde bloğun 'true' kısmını girer .

Rails'te (3.1.0 ve üstü) bulunan yukarıdaki kabul edilen cevaptan daha özlü bir deyim .in?:

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

Ayrıca daha okunabilir olduğunu düşünüyorum.

Daha in?fazla bilgi için belgelere bakın .

Sadece Rails'te mevcut olduğunu ve saf Ruby'de olmadığını unutmayın.

Üçlü yol

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

VEYA

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

Dize öğesi başvurusu yöntemini kullanabilirsiniz.[]

Kutunun içinde []değişmez bir alt dize, bir dizin veya bir normal ifade olabilir:

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

Yana nilişlevsel aynıdır falseve dönen herhangi alt dize []olduğunu truesen yöntemi kullanmak sanki sen mantığı kullanabilirsiniz .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" 

Bir dizini bir alt dizeyle karıştırmamaya dikkat edin:

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

Bir normal ifadeyi de kullanabilirsiniz:

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

Bir dizenin Ruby'de bir alt dize içerip içermediğini nasıl kontrol edebilirim?

'Kontrol' dediğinizde, kullanabileceğiniz bir boole döndürülmesini istediğinizi varsayalım String#match?. match?dizeleri veya normal ifadeleri ilk parametresi olarak kabul eder, eğer eski ise otomatik olarak normal ifadeye dönüştürülür. Yani kullanım durumunuz:

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

String#match?, dizeyi aramak için kullanılacak bir dizini belirten isteğe bağlı ikinci bir bağımsız değişkenin ek avantajına sahiptir. Varsayılan olarak bu, olarak ayarlanır 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

Bu, dizenin alt dize içerip içermediğini kontrol etmenize yardımcı olur

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