Mit Strings arbeiten

Die String-Methode ==vergleicht den Inhalt von zwei Zeichenketten. <=> ist für Sortierverfahren geeignet: Das Ergebnis ist bei Gleichheit $0$, $+1$ falls die linke Seite im Alphabet nach der rechten Seite kommt, $-1$ falls sie vorher kommt.

"Ruby" == "Ruby"          #-> true
"Ru"+"by" == "Ruby"       #-> true
"Ruby" <=> "Ruby"         #-> 0
"Ruby" <=> "Objective-C"  #-> 1
"Ruby" <=> "ruby"         #-> -1

index(einString, offset) liefert die Position des ersten Teilstrings zurück, der mit einString übereinstimmt. Ist einString nicht im angesprochenen String-Objekt enthalten, ist das Ergebnis nil. rindex beginnt seine Suche vom Ende der Zeichenkette (r wie ``rechts'').

str="Es regnet und es regnet"
str.index('s')        #-> 1
str.index('s',5)      #-> 15
str.index("regnet")   #-> 3
str.rindex("regnet")  #-> 17
str.index("Sonne")    #-> nil

Mit + werden Zeichenketten aneinander gehängt. Dabei wird jedes Mal ein neues String-Objekt erzeugt, was bei großen Strings relativ lange dauert. Die Alternative << ändert nur das bereits bestehende String-Objekt (den Empfänger) ab, wodurch die Ausführung erheblich beschleunigt wird, siehe Kapitel 32.3.

str = ''
for i in 1 .. 3
    str += "hallo\n"
    p str.id      # eindeutige Objektnummer
end  #-> 84282920 84282680 84282608

str = ''
3.times {
  str << "hallo\n"
  p str.id        # eindeutige Objektnummer
}    #-> 84260612 84260612 84260612

Zu den empfängermodifizierenden Operatoren gehört auch die Methode *, mit der Strings wiederholt werden:

"ta" *2  #-> "tata"
"ta" *3  #-> "tatata"

chomp entfernt die Steuerzeichen für den Zeilenwechsel (\n) am Ende einer Zeile. Etwas rabiater ist die verwandte Methode chop, die generell das letzte Zeichen abschneidet. Das praktische strip entfernt Whitespace (siehe Tabelle 5.2 auf Seite ) sowohl am Anfang als auch am Ende einer Zeichenkette.

str = "Hi\n"     #-> "Hi\n"
str.chomp        #-> "Hi"
str.chomp.chomp  #-> "Hi"
str.chop         #-> "Hi"
str.chop.chop    #-> "H"
"  Hi  \n".strip #-> "Hi"

Um zählen zu lassen, wie oft Buchstaben aus einem Vorrat in einem String vorkommen, wird count(vorrat) eingesetzt. In den Argumenten können Buchstabenbereiche festgelegt werden, mit einem \^ am Anfang werden Buchstaben von der Zählung ausgeschlossen.

str="Bond, James Bond"
str.count "aeiou"      #-> 4
str.count "a-z"        #-> 10
str.count "a-z", "^n"  #-> 8

Zum Löschen von Buchstabenaus einem String benutzt delete die gleiche Syntax wie count:

str="Bond, James Bond"
str.delete "o"             #-> "Bnd, James Bnd"
str.delete "a-z"           #-> "B, J B"
str.delete "a-z", "^n"     #-> "Bn, J Bn"

Wir erinnern nochmals daran, dass mit "`!"' markierte Methoden kein neues String-Exemplar erzeugen, sondern das bereits vorhandene Objekt modifizieren.

split teilt eine Zeichenkette anhand eines Trennmusters in Substrings auf, die in einem Array zurückgeliefert werden. Wird kein Muster angegeben, setzt Ruby den Wert der Systemvariablen $; ein, enthält $; den Wert nil, wird an Whitespace getrennt. Ein zweites optionales Argument gibt an, wie viele Teile höchstens entstehen sollen.

str="a 1 2 3"
str.split             #-> ["a", "1", "2", "3"]
str.split(' ')        #-> ["a", "1", "2", "3"]
str.split(' ', 1)     #-> ["a 1 2 3"]
str.split(' ', 2)     #-> ["a", "1 2 3"]

In Perl wird mit splitoft eine Liste von Strings erzeugt, über die dann iteriert wird. Ruby fasst dieses Idiom im Methodenaufruf each(trenner) {|teil| block} zusammen. Die Teile der entsprechend dem Trennstring zerlegten Zeichenkette werden einzeln an den Codeblock übergeben.

Als Standardwert wird für den Trennstring der Inhalt der Systemvariablen $/eingesetzt.

str="12 34 55"
str.each {|s| p s}   #-> "12" "34" "55"
str.each(' ') { |s|
  p s.to_i + 1
}                    #-> 13 35 56

Schließlich gibt es noch die Methode scan(muster), bei der mit dem muster die einzelnen Elemente beschrieben werden.

"abc".scan('.') { |z| p z.succ } #-> "b" "c" "d"

Mit to_i können Strings in ganze Zahlen umgewandelt werden und to_f erzeugt aus einem String eine Fließkommazahl.

"2".to_i      #-> 2
"2.1".to_i    #-> 2
"2.1".to_f    #-> 2.1
"2a".to_i     #-> 2
"ab".to_i     #-> 0

Möchte man im letzten Beispiel an Stelle des Standardwerts 0 eine Fehlermeldung erhalten, kann man die Methode Integer verwenden:

Integer("1")    #-> 1
Integer("2.5")  #-> ArgumentError ...
Integer("ab")   #-> ArgumentError ...

Eine weitere Möglichkeit verwendet reguläre Ausdrücke (siehe Kapitel 5):

if string =~ /^[+-]?\d+$/
    p 'ist ein Integer'
else
    p 'ist kein Integer'
end

if string =~ /^-?(?:\d+(?:\.\d*)?|\.\d+)$/
    p 'ist eine Dezimalzahl'
else
    p 'ist keine Dezimalzahl'
end

Die String-Methoden sub, sub!, gsub und gsub! ersetzen einen Teil einer Zeichenkette durch einen anderen String. Das Besondere an den Methoden mit ! im Namen ist, dass sie den Empfänger direkt modifizieren. Bei den anderen Funktionen wird eine Kopie des Objekts bearbeitet und zurückgegeben. Die g-Funktionen führen globale Ersetzungen durch, während die einfachen Funktionen nur den ersten Treffer ersetzen.

Alle sub-Methoden können auf zwei Arten aufgerufen werden:

• sub(muster, neu) führt Ersetzungen mit regulären Ausdrücken durch.

• gsub(muster) {|match| block} ermöglicht tiefere Eingriffe, da der Codeblock für jeden Treffer ausgeführt wird.

Das Muster kann ein normaler String sein, wird aber häufiger ein regulärer Ausdruck sein, mehr dazu in Kapitel 5.

str="James Bond (007)"
str.sub(/Bond/, "Porter")
   #-> "James Porter (007)"
str.sub!(/([aeiou])/, '<\1>')
   #-> "J<a>mes Bond (007)"
str.gsub('[0-9]') { | m |
  if m.to_i > 0
    m.to_i * 2
  else
    "Null "
  end
}  #-> "J<a>mes Bond (Null Null 14)"

Footnotes

... ==

== und <=>

... index(einString, offset)

index sucht von vorn, rindex von hinten

... +

Strings verketten mit + und <<

... Operatoren

Strings wiederholen

...chomp

chomp, chop und strip

... zählen

Buchstaben zählen mit count

... Buchstaben

delete und delete!

...split

Auftrennen mit split

... split

Teilstrings abarbeiten mit each

... to_i

in Zahlen umwandeln

... String-Methoden

Ersetzen mit sub und gsub