it-swarm.com.de

Wie kann man in Ruby prüfen, ob ein String einen Teilstring enthält?

Ich habe eine String-Variable mit folgendem 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 obigen Zeichenfolge muss ich eine Unterzeichenfolge finden, d. h.

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


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

Wie kann ich es finden? Ich muss nur feststellen, ob die Teilzeichenfolge vorhanden ist oder nicht.

681
BSalunke

Sie können die Methode include? verwenden:

_my_string = "abcdefg"
if my_string.include? "cde"
   puts "String includes 'cde'"
end
_
1267
Adam Lear

Wenn case irrelevant ist, ist ein case-insensitiver regulärer Ausdruck eine gute Lösung:

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

Dies funktioniert auch für mehrzeilige Zeichenfolgen.

Siehe Rubys Regexp Klasse.

81
Clint Pachl

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"'
40
Oto Brglez

Erweiterung der Antwort von Clint Pachl:

Die Regex-Übereinstimmung in Ruby gibt nil zurück, wenn der Ausdruck nicht übereinstimmt. Wenn dies der Fall ist, wird der Index des Zeichens zurückgegeben, bei dem die Übereinstimmung auftritt. Zum Beispiel

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

Es ist wichtig zu beachten, dass in Ruby nur nil und der boolesche Ausdruck false zu false ausgewertet werden. Alles andere, einschließlich eines leeren Arrays, eines leeren Hashs oder der Ganzzahl 0, wird als wahr ausgewertet.

Deshalb funktioniert das/foo/Beispiel oben und warum

if "string" =~ /regex/

funktioniert wie erwartet. Geben Sie den 'true'-Teil des if-Blocks nur ein, wenn eine Übereinstimmung aufgetreten ist.

30
acib708

Ein prägnanteres Idiom als die oben akzeptierte Antwort, die in Rails (ab 3.1.0) verfügbar ist, ist .in?.

Z.B:

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.

vgl. http://apidock.com/Rails/v3.1.0/Object/in%3F

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

19
stwr667

Ternäre Weise

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

OR

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

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

Innerhalb des [] kann es sich entweder um eine Literal-Teilzeichenfolge, einen Index oder eine Regex handeln:

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

Da nil funktional mit false identisch ist und jeder von [] zurückgegebene Teilstring true ist, können Sie die Logik so verwenden, als würden Sie die Methode .include? verwenden:

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 einfach 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
9
dawg
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 eine Teilzeichenfolge 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
2
Prabhakar

Wie kann man in Ruby prüfen, ob ein String einen Teilstring enthält?

Wenn Sie 'check' sagen, möchten Sie vermutlich einen Booleschen Wert zurückgeben. In diesem Fall können Sie String#match? verwenden. _match?_ akzeptiert Zeichenfolgen oder reguläre Ausdrücke als ersten Parameter. Wenn es der erstere ist, wird er automatisch in eine reguläre Ausdrücke 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?_ bietet den zusätzlichen Vorteil eines optionalen zweiten Arguments, das einen Index angibt, anhand dessen die Zeichenfolge durchsucht werden soll. Standardmäßig ist dies auf _0_ eingestellt.

_str.match? 'tri',0   #=> true
str.match? 'tri',1   #=> true
str.match? 'tri',2   #=> false
_
1
Sagar Pandya