So überprüfen Sie, ob eine Zeichenfolge in Ruby eine Teilzeichenfolge enthält

Ich habe eine Stringvariable mit Inhalt:

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"

In der Zeichenfolge muss ich eine Unterzeichenfolge finden:

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

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

Wie kann ich es finden? Ich muss feststellen, ob der Teilstring vorhanden ist oder nicht.

Sie können die include?Methode verwenden:

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

Wenn der Fall irrelevant ist, ist ein regulärer Ausdruck ohne Berücksichtigung der Groß- und Kleinschreibung eine gute Lösung:

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

Dies funktioniert auch für mehrzeilige Zeichenfolgen.

Weitere Informationen finden Sie in Rubys Regexp- Klasse.

Sie können dies auch tun ...

my_string = "Hello world"

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

# => 'It has "Hello"'

In diesem Beispiel wird die Ruby-String- #[]Methode verwendet.

Erweiterung der Antwort von Clint Pachl:

Die Regex-Übereinstimmung in Ruby wird zurückgegeben, nilwenn der Ausdruck nicht übereinstimmt. Wenn dies der Fall ist, wird der Index des Zeichens zurückgegeben, in dem die Übereinstimmung stattfindet. Zum Beispiel:

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

Es ist wichtig zu beachten, dass nur in Ruby nilund der boolesche Ausdruck falseals falsch ausgewertet werden. Alles andere, einschließlich eines leeren Arrays, eines leeren Hash oder der Ganzzahl 0, wird als wahr ausgewertet.

Deshalb /foo/funktioniert das obige Beispiel und warum.

if "string" =~ /regex/

funktioniert wie erwartet und gibt nur dann den 'wahren' Teil des ifBlocks ein, wenn eine Übereinstimmung aufgetreten ist.

Eine prägnantere Redewendung als die oben akzeptierte Antwort, die in Rails (ab 3.1.0 und höher) verfügbar ist, lautet .in?:

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

Ich denke auch, dass es besser lesbar ist.

in?Weitere Informationen finden Sie in der Dokumentation.

Beachten Sie erneut, dass es nur in Rails und nicht in reinem Ruby verfügbar ist .

Ternärer Weg

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

ODER

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

Sie können die String Element Reference- Methode verwenden[]

In der []kann sich entweder ein Literal-Teilstring, ein Index oder ein Regex befinden:

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

Da dies nilfunktional dasselbe ist wie falseund jeder Teilstring, von dem zurückgegeben []wird true, können Sie die Logik so verwenden, als ob Sie die Methode verwenden .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" 

Stellen Sie nur sicher, dass Sie einen Index nicht mit einer Unterzeichenfolge verwechseln:

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

Sie können auch einen regulären Ausdruck verwenden:

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

Wie überprüfe ich, ob eine Zeichenfolge einen Teilstring in Ruby enthält?

Wenn Sie 'check' sagen, möchten Sie vermutlich einen Booleschen Wert zurückgeben. In diesem Fall können Sie ihn verwenden String#match?. match?Akzeptiert Zeichenfolgen oder reguläre Ausdrücke als ersten Parameter. Wenn dies der erstere ist, wird er automatisch in einen regulären Ausdruck konvertiert. Ihr Anwendungsfall wäre also:

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

String#match?hat den zusätzlichen Vorteil eines optionalen zweiten Arguments, das einen Index angibt, von dem aus die Zeichenfolge durchsucht werden soll. Standardmäßig ist dies auf eingestellt 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

Auf diese Weise können Sie überprüfen, ob die Zeichenfolge Teilzeichenfolgen enthält oder nicht

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