4.5 Zeichenketten 

Zeichenketten sind einer der wichtigste Datentypen aus dem Programmieralltag. Wir müssen sie auf unterschiedlichste Arten verarbeiten. Wir müssen Zeichenketten zerlegen, miteinander verknüpfen und analysieren; innerhalb von Zeichenketten suchen, Zeichen ersetzen usw. Aber auch das meiste davon ist in Ruby ganz einfach.

8-Bit-Bytes

Zeichenketten in Ruby sind Instanzen der Klasse String, die sehr viele Methoden zur Verfügung stellt, um mit Zeichenketten arbeiten zu können. Einige von diesen Methoden werden Sie in diesem Kapitel kennenlernen. Ruby-Strings werden als Folge von 8-Bit-Bytes gespeichert. Allerdings ist die Folgerung daraus, dass ein Zeichen einem Byte entspricht, nicht ganz richtig. Es gibt Zeichen, die durch zwei Bytes repräsentiert werden. Aber damit wollen wir uns erst später beschäftigen.

Ruby-Strings sind dynamisch, veränderbar und flexibel. Also eigentlich ähnlich dem, was wir aus anderen dynamischen Programmiersprachen wie Perl, Python und PHP kennen. Lassen Sie uns also einfach beginnen, indem wir eine Interactive Ruby Shell (irb) öffnen und uns anhand folgenden Beispiele die Zeichenketten in Ruby genauer ansehen:

irb --simple-prompt
>> string1 = 'das ist ein string'
=> "das ist ein string"
>> string2 = 'wie geht 's'
=> "wie geht's"

Zeichenketten und Hochkommata

Zeichenketten können in Ruby entweder in doppelte oder einfache Hochkommata gesetzt werden, wobei beide innerhalb der anderen vorkommen können, ohne durch einen Backslash maskiert werden zu müssen. Der Unterschied besteht darin, dass innerhalb der doppelten Hochkommata sog. Escape-Sequenzen (Zeichen, die einen Backslash enthalten, der nicht zum Maskieren des nachfolgenden Zeichens interpretiert werden darf), z. B. \ n für nächste Zeile oder \ t für Tabulator, ausgewertet werden. Möchte man also Escape-Sequenzen innerhalb doppelter Hochkommata ausgeben, muss man sie durch einen Backslash maskieren: \\n

Am häufigsten werden die doppelten Hochkommata genutzt:

>> puts '1.Zeile n2.Zeile'
1.Zeile n2.Zeile
=> nil
>> puts "1.Zeile n2.Zeile"
1.Zeile
2.Zeile
=> nil
>> puts "1.Zeile  n2.Zeile"
1.Zeile n2.Zeile
=> nil
>> puts "Text in 'Hochkommata'"
Text in 'Hochkommata'
=> nil
>> puts 'Text in "Hochkommata"'
Text in "Hochkommata"
=> nil

Literale

Es gibt auch eine alternative Form, die mit einer allgemein begrenzenden Syntax arbeitet, um literale Strings zu erzeugen.

Diese Literale beginnen mit %q oder %Q, gefolgt von einem Begrenzer, der ein beliebiges Zeichen sein kann. Wenn der Begrenzer ein öffnendes Klammerzeichen ist

((,[,{ oder <), endet das Literal beim dazugehörigen schließenden Klammerzeichen, wobei im Literal enthaltene Klammerpaare mitgezählt werden. Bei allen anderen Begrenzern endet das Literal beim nächsten Auftreten des Begrenzers. Auf diese Art und Weise erzeugte Strings dürfen über mehrere Zeilen gehen.

Der Unterschied zwischen %q und %Q besteht darin, das %q einen String erzeugt, der sich verhält wie ein String innerhalb einfacher Hochkommata und %Q einen String, der sich verhält wie ein String innerhalb doppelter Hochkommata. Allerdings erfolgt das entsprechende Maskieren der Sonderzeichen automatisch:

>> string1 = %q[Peter fragte "Wie geht's Dir?"]
=> "Peter fragte  \"Wie geht´s Dir?\""
>> puts string1
Peter fragte "Wie geht's Dir?"
=> nil
>> string2 = %q(Das ist kein Zeilenumbruch \n)
=> "Das ist kein Zeilenumbruch \\n"
>> puts string2
Das ist kein Zeilenumbruch \n
=> nil
>> string3 = %Q<Aber das \nhier>
=> "Aber das \nhier"
>> puts string3
Aber das
hier
=> nil

here-document 

Mehrzeiliger Text

Eine weitere Möglichkeit, Zeichenketten zu erzeugen, die über mehrere Zeilen gehen, ist das sog. here-document . Ein here-document erzeugen Sie, indem Sie Ihren mehrzeiligen Text zwischen zwei von Ihnen frei wählbaren Begrenzern definieren, wobei dem öffnenden Begrenzer ein << - Symbol vorangestellt ist:

irb(main):001:0> string = <<EOF
irb(main):002:0" Dieser Text ist  ein mehrzeiliger
irb(main):003:0" Text, der innerhalb eines here-documents
irb(main):004:0" definiert wurde.
irb(main):005:0" EOF
=> "Dieser Text ist  ein mehrzeiliger \nText, der innerhalb
       eines here-documents \ndefiniert wurde. \n"
irb(main):006:0> puts string
Dieser Text ist  ein mehrzeiliger
Text, der innerhalb eines here-documents
definiert wurde.
=> nil

Keine Leerzeichen am Ende

Achten Sie bitte unbedingt darauf, dass Sie keine Leerzeichen an den Ende-Begrenzer anhängen. Aktuelle Ruby-Versionen erkennen dann den Ende-Begrenzer nicht mehr.

Standardmäßig verhält sich ein here-document wie ein String in doppelten Hochkommata. Das heißt, Escape-Sequenzen werden interpretiert und es ist möglich, Ruby-Ausdrücke zu integrieren. Wenn Sie allerdings das öffnende Begrenzungszeichen in einfache Hochkommata setzen, erzeugen Sie ein here-document, das sich wie ein String innerhalb einfacher Hochkommata verhält:

irb(main):013:0> string = <<'EOF'
irb(main):014:0' das ist kein tab  \t
irb(main):015:0' und das ist keine neue Zeile  \n
irb(main):016:0' EOF
=> "das ist kein tab  \\t nund das ist keine neue Zeile  \\n\n"
irb(main):017:0> puts string
das ist kein tab  \t
und das ist keine neue Zeile  \n
=> nil

Einrückung

Wird dem öffnenden Begrenzungszeichen ein Bindestrich vorangestellt, ist es möglich, das schließende Begrenzungszeichen einzurücken. Aber Vorsicht: Nur die führenden Leerzeichen vor dem schließenden Begrenzungszeichen werden entfernt, nicht die in den vorangehenden Zeilen!

irb(main):007:0> string = <<-EOF
irb(main):008:0"    Dies ist ein Text,
irb(main):009:0"    der mit fuehrenden
irb(main):010:0"    Leerzeichen beginnt.
irb(main):011:0"    EOF
=> "   Dies ist ein Text, \n   der mit fuehrenden \n   ..."
irb(main):012:0> puts string
    Dies ist ein Text,
    der mit fuehrenden
    Leerzeichen beginnt.
=> nil

Ausdrücke in Zeichenketten 

Ruby-Ausdrücke können innerhalb doppelter Hochkommata, here-dokumenten und Regulären Ausdrücken mit #{Ausdruck} in einen String eingefügt werden, ohne dass der Datentyp der Ruby-Ausdrücke angepasst werden muss. Das heißt, eine Variable vom Typ Fixnum kann auf diese Art und Weise ohne Konvertierung zum Typ String innerhalb einer Zeichenkette ausgegeben werden. Dies ist aber nur scheinbar so, weil Ruby im Hintergrund die Konvertierungsmethode to_s des Ausdruck-Objekts aufruft, das heißt, der eingefügte Ruby-Ausdruck wird automatisch in einen String konvertiert.

>> preis = 12
=> 12
>> mwst = 0.19
=> 0.19
>> gesamt = preis * (1+mwst)
=> 14.28
>> puts "Gesamtpreis betraegt #{gesamt} Euro"
Gesamtpreis betraegt 14.28 Euro
=> nil
>> puts "Gesamtpreis betraegt #{preis * (1+mwst)} Euro"
Gesamtpreis betraegt 14.28 Euro
=> nil

Die Methode length 

Die Methode length liefert die Länge (Größe) eines Strings. Genau genommen gibt sie die Anzahl der Bytes einer Zeichenkette zurück:

>> string = "Ruby on Rails"
=> "Ruby on Rails"
>> string.length
=> 13

Rückgabewert ist ein Objekt

Der Rückgabewert einer Methode ist auch wieder ein Objekt, auf das die Methoden seiner Klasse angewendet werden können. In unserem Beispiel ist der Rückgabewert 13 ein Objekt der Klasse Fixnum:

>> string.length.class
=> Fixnum
>> string.length.next
=> 14

Nun könnte man davon ausgehen, dass die Länge einer Zeichenkette gleich der Anzahl ihrer Bytes ist. In unserem Beispiel mit der Zeichenkette »Ruby on Rails« ist dem ja auch so. Aber es gibt Zeichenketten, bei denen das nicht so ist:

>> "Müller".length
=> 7

Die deutschen Umlaute werden in UTF-8 durch zwei Bytes repräsentiert. Da die Methode length die Anzahl der Bytes zurückgibt, ist diese in diesem Fall größer als die Länge der Zeichenkette. In anderen Sprachen, zum Beispiel im Französischen, gibt es auch Zeichen, die durch zwei Bytes repräsentiert werden.

Lösen können Sie das Problem wie folgt:

$KCODE = "UTF8"
require "jcode"
puts "Müller".jlength
# => 6

Die Methode split 

Teilstrings

Mit der Methode split können Sie eine Zeichenkette auf der Basis eines bestimmten Trennzeichens in Teilstrings teilen und diese in einem Array zurückgeben. Der Methode split können zwei optionale Parameter übergeben werden, das Trennzeichen und die Anzahl der Felder. Ist das Trennzeichen nicht gesetzt, wird der String bei Leerzeichen getrennt:

>> string1 = "Die Blumen wurden heute noch nicht gegossen."
=> "Die Blumen wurden heute noch nicht gegossen."
>> string1.split
=> ["Die", "Blumen", "wurden", "heute", "noch", "nicht",
    "gegossen."]
>> string2 = "aepfel, birnen und bananen"
=> "aepfel, birnen und bananen"
>> liste = string2.split(", ")
=> ["aepfel", "birnen und bananen"]
>> busse = "Linienbus und Reisebus und Minibus"
=> "Linienbus und Reisebus und Minibus"
>> busse.split("und")
=> ["Linienbus ", " Reisebus ", " Minibus"]
>> busse.split(/ und /)
=> ["Linienbus", "Reisebus", "Minibus"]

Parameter

Wenn der Parameter für die Anzahl der Felder weggelassen wird, werden anhängende Null-Felder unterdrückt. Wenn er eine positive Zahl ist, wird maximal diese Anzahl von Feldern zurückgegeben (wenn die Anzahl der Felder gleich 1 ist, wird der gesamte String als einziges Element des Arrays zurückgegeben). Wenn der Parameter negativ ist, gibt es keine Begrenzung der zurückgegebenen Felder, und anhängende Null-Felder werden nicht unterdrückt:

>> str = "one,two,three,,"
=> "one,two,three,,"
>> str.split(",")
=> ["one", "two", "three"]
>> str.split(",",2)
=> ["one", "two,three,,"]
>> str.split(",",4)
=> ["one", "two", "three", ","]
>> str.split(",",8)
=> ["one", "two", "three", "", ""]
>> str.split(",",-1)
=> ["one", "two", "three", "", ""]

Zeichenketten formatieren 

sprintf

Die Formatierung einer Zeichenkette übernimmt in Ruby wie in C die Methode sprintf . Der Methode übergeben Sie eine Zeichenkette und ein oder mehrere Argumente als Parameter.

>> name = "Manon"
=> "Manon"
>> alter = 30
=> 30
>> string = sprintf("Hallo, %s... Du bist %d Jahre alt.",
   name, alter)
=> "Hallo, Manon... Du bist 30 Jahre alt."

Sie haben recht. Das wäre auch ohne die sprintf -Methode möglich gewesen, indem wir die beiden Ausdrücke name und alter in den String eingebunden hätten. Aber mit sprintf können wir den String formatieren. Es ist z. B. möglich, die Anzahl der Dezimalstellen festzulegen, führende Nullen einzufügen oder zu unterdrücken und vieles mehr.

Die Klasse String stellt auch Methoden zur Verfügung, um eine Zeichenkette zu formatieren:

>> string = "R2D2"
=> "R2D2"
>> string.ljust(16)
=> "R2D2            "
>> string.center(16)
=> "      R2D2      "
>> string.rjust(16)
=> "            R2D2"

ljust, center, rjust

Sie können den Methoden ljust, center und rjust einen Parameter mit der Länge des Ergebnis-Strings übergeben. Die Methode füllt dann die überschüssigen Zeichen automatisch mit Leerschritten auf. Wird ein Zeichen oder eine Zeichenkette als zweiter Parameter angegeben, werden die überschüssigen Zeichen damit aufgefüllt:

>> string = "Captain Schmeltzle"
=> "Captain Schmeltzle"
>> string.ljust(30, "*")
=> "Captain Schmeltzle************"
>> string.center(30, "-")
=> "------Captain Schmeltzle------"
>> string.rjust(30, "Mr")
=> "MrMrMrMrMrMrCaptain Schmeltzle"

Groß- und Kleinschrift 

downcase, upcase

Mit der Methode downcase können Sie alle Buchstaben einer Zeichenkette in Kleinbuchstaben und mit der Methode upcase in Großbuchstaben umwandeln:

>> string = "Ein schoener Tag"
=> "Ein schoener Tag"
>> string.downcase
=> "ein schoener tag"
>> string.upcase
=> "EIN SCHOENER TAG"

capitalize

Die Methode capitalize wandelt den ersten Buchstaben einer Zeichenkette in einen Großbuchstaben und den Rest der Zeichenkette in Kleinbuchstaben um:

>> string.capitalize
=> "Ein schoener tag"

swapcase

Mit der Methode swapcase können Sie alle Kleinbuchstaben innerhalb einer Zeichenkette in Großbuchstaben umwandeln und umgekehrt:

>> string = "EIN schoener TAG"
=> "EIN schoener TAG"
>> string.swapcase
=> "ein SCHOENER tag"

Jede der Methoden upcase, downcase, capitalize und swapcase hat eine äquivalente Methode, die das Objekt, auf das die Methode angewendet wird, verändert. Die Methoden heißen genauso, enden aber mit einem !.

>> string = "Ein schoener Tag"
=> "Ein schoener Tag"
>> string.downcase
=> "ein schoener tag"
>> puts string
Ein schoener Tag
=> nil
>> string.downcase!
=> "ein schoener tag"
>> puts string
ein schoener tag
=> nil
>> string.upcase
=> "EIN SCHOENER TAG"
>> puts string
ein schoener tag
=> nil
>> string.upcase!
=> "EIN SCHOENER TAG"
>> puts string
EIN SCHOENER TAG
=> nil
>> string.capitalize!
=> "Ein schoener tag"
>> puts string
Ein schoener tag
=> nil
>> string.swapcase!
=> "eIN SCHOENER TAG"
>> puts string
eIN SCHOENER TAG
=> nil

Teilstrings 

[]

Mit der Methode [] können Sie einen Teilstring aus einer Zeichenkette ermitteln. Übergeben Sie der Methode eine Zahl, liefert sie den ASCII-Code des Zeichens an dieser Position zurück:

>> string = "Hallo Welt"
=> "Hallo Welt"
>> string[1]
=> 97

Es wird ein Teilstring zurückgeliefert, wenn die Startposition und die Länge angegeben wird:

>> string[6,4]
=> "Welt"

Wenn Sie einen Bereich angeben, wird der entsprechende Teilstring zurückgeliefert:

>> string[0..4]
=> "Hallo"

Von rechts nach links

In den bis jetzt beschriebenen drei Fällen bedeutet ein negativer Wert, dass vom Ende des Strings aus gezählt wird:

>> string[-2]
=> 108
>> string[-4,4]
=> "Welt"
>> string[-4..-1]
=> "Welt"

Die Methode liefert nil als Ergebnis, wenn die übergebenen Parameter außerhalb des Strings liegen, die Länge negativ ist oder der Anfang des Bereichs größer als die Länge des Strings ist:

>> string[3,-2]
=> nil
>> string[25..30]
=> nil
>> string[15,4]
=> nil

Rückgabewerte

Wird ein Regulärer Ausdruck übergeben, wird der passende Teilstring zurückgeliefert. Wird zusammen mit dem regulären Ausdruck ein numerischer Parameter übergeben, wird der passende Teil des Teilstrings zurückgeliefert. Wird ein String als Parameter übergeben, wird dieser String auch zurückgeliefert, wenn er in der Zeichenkette enthalten war. In beiden Fällen wird nil zurückgeliefert, wenn es keine Übereinstimmung gab:

>> string = "Hallo Welt"
=> "Hallo Welt"
>> string[/[aeiou](.)\1/]
=> "all"
>> string[/[aeiou](.)\1/, 0]
=> "all"
>> string[/[aeiou](.)\1/, 1]
=> "l"
>> string[/[aeiou](.)\1/, 2]
=> nil
>> string['lo']
=> "lo"
>> string['ciao']
=> nil

In Zeichenketten suchen 

index

Neben der eben beschriebenen Technik des Suchens und Ersetzens innerhalb von Zeichenketten gibt es noch weitere Möglichkeiten, um innerhalb von Zeichenketten zu suchen. Die Methode index liefert die Startposition des gesuchten Teilstrings, Zeichens oder regulären Ausdrucks zurück. Als zweiten optionalen Parameter können Sie die Startposition für die Suche übergeben. Wenn das Gesuchte nicht innerhalb der Zeichenkette gefunden wird, liefert index nil zurück:

>> "Zeitschrift".index('i')
=> 2
>> "Zeitschrift".index('schrift')
=> 4
>> "Zeitschrift".index(/[aeiou]/, -5)
=> 8
>> "Zeitschrift".index('y')
=> nil

rindex

Die Methode rindex (right index) startet die Suche von rechts nach links. Man könnte auch sagen, sie sucht das letzte Vorkommen des Suchmusters innerhalb der Zeichenkette. Die Nummerierung der gefundenen Position erfolgt von links nach rechts. Als zweiten optionalen Parameter können Sie auch hier die Startposition für die Suche übergeben. Wenn das Gesuchte nicht innerhalb der Zeichenkette gefunden wird, liefert auch die Methode rindex nil zurück:

>> "Zeitschrift".rindex('i')
=> 8
>> "Zeitschrift".rindex('schrift')
=> 4
>> "Zeitschrift".rindex(/[aeiou]/, -5)
=> 2
>> "Zeitschrift".rindex('y')
=> nil

include

Die Methode include liefert true, wenn das übergebene Suchmuster in der Zeichenkette enthalten ist:

>> "zeitschrift".include? "schrift"
=> true
>> "zeitschrift".include? "zeitung"
=> false

scan

Mit der Methode scan können Sie nach einem bestimmten Muster, das ein Regulärer Ausdruck oder eine Zeichenkette sein kann, in einer gegebenen Zeichenkette suchen. Das Ergebnis wird in einem Array zurückgeliefert:

Beispiel mit einem String als Muster:

>> s = "Es ist noch Sommer da"
=> "Es ist noch Sommer da"
>> s.scan("o")
=> ["o", "o"]
>> s.scan("e")
=> ["e"]

Beispiel mit einem Regulären Ausdruck als Muster:

>> s.scan(/ w+/)
=> ["Es", "ist", "noch", "Sommer", "da"]

Um die Ergebnisse weiterzuverarbeiten, kann ein Block angegeben werden:

>> s.scan(/ w+/) {|x| puts x}
Es
ist
noch
Sommer
da
=> "Es ist noch Sommer da"

Etwas einer Zeichenkette hinzufügen 

concat

Sie können den << - Operator nutzen, um einen String einem anderen String hinzuzufügen. Es können auch mehrere Operationen hintereinander ausgeführt werden. Statt des << - Operators kann auch die Methode concat eingesetzt werden. Zahlen zwischen 0 und 255 werden in ein Zeichen umgewandelt:

>> a = "hallo"
=> "hallo"
>> a << " Welt"
=> "hallo Welt"
>> a << 33
=> "hallo Welt!"
>> a.concat(33)
=> "hallo Welt!!"

Angehängte Zeichen löschen 

chop

Die Methode chop entfernt das letzte Zeichen einer Zeichenkette. Handelt es sich bei diesem Zeichen um das Zeichen für eine neue Zeile (\n) und steht davor das Zeichen für einen Carriage Return (\r), wird dieses Zeichen automatisch mit entfernt. Der Grund für dieses Verhalten liegt darin, dass es keine einheitliche Regelung dafür gibt, wie eine neue Zeile definiert ist. Unter Unix wird eine neue Zeile durch ein \n dargestellt, unter DOS oder Windows durch einen Carriage Return \r gefolgt von einem \n . Die Methode chop entfernt in jedem Fall das letzte Zeichen, auch wenn es sich dabei nicht um eine neue Zeile handelt. Wendet man chop auf einen leeren String an, wird ein leerer String zurückgeliefert.

>> "string\r\n".chop
=> "string"
>> "string\n\r".chop
=> "string\n"
>> "string\n".chop
=> "string"
>> "string".chop
=> "strin"
>> "x".chop.chop
=> ""

chop!

Auch für die chop - Methode gibt es eine äquivalente Methode mit einem Ausrufezeichen am Ende (chop!), die das Ausgangsobjekt verändert.

chomp

Die Methode chomp ist öfter die sicherere Alternative, da sie die Zeichenkette unverändert lässt, wenn diese nicht mit einer neuen Zeile endet oder Sie ihr nicht ein Suchmuster übergeben, das sie entfernen soll:

>> "hallo".chomp
=> "hallo"
>> "hallo\n".chomp
=> "hallo"
>> "hallo\r\n".chomp
=> "hallo"
>> "hallo\n\r".chomp
=> "hallo\n"
>> "hallo\r".chomp
=> "hallo"
>> "hallo \n ihr da".chomp
=> "hallo \n ihr da"
>> "hallo".chomp("llo")
=> "ha"

Leerräume löschen 

strip

Die Methode strip entfernt führende und angehängte Leerräume (Whitespaces), wie Leerzeichen, Tabulatoren und Zeichen für eine neue Zeile:

>> "    hallo    ".strip
=> "hallo"
>> "\thallo   \r\n".strip
=> "hallo"

lstrip, rstrip

Wenn wir die Leerräume nur am Anfang oder am Ende eines Strings entfernen möchten, können wir die Methoden lstrip und rstrip einsetzen:

>> str = "     abc     "
=> "     abc     "
>> str.lstrip
=> "abc     "
>> str.rstrip
=> "     abc"

Für die drei Methoden strip, lstrip und rstrip gibt es auch jeweils eine Methode, die das Ausgangsobjekt verändert (strip!, lstrip! und rstrip!).

Zeichenketten wiederholen 

In Ruby übernimmt der Multiplikations-Operator die Funktion, Zeichenketten zu wiederholen. Wird ein String n-mal multipliziert, ist das Ergebnis eine n-fach aneinandergereihte Kopie vom Ausgangsstring:

>> str = "abc "*3
=> "abc abc abc "
>> str = ("a"*3 + " " + "b"*3 + " " + "c"*3)*3
=> "aaa bbb cccaaa bbb cccaaa bbb ccc"

Komma-separierte Daten analysieren 

Mit Komma-separierten Daten arbeiten zu müssen, ist eine alltägliche Herausforderung, der wir uns stellen müssen.

Angenommen, es handelt sich bei diesen Daten um einen Datenmix aus Strings und Zahlen und die Strings werden mit doppelten Hochkommata umschlossen, und angenommen, alle Sonderzeichen sind maskiert.

Lösung: Array

Dann ist die Lösung des Problems einfach, weil die Daten wie ein Array aus gemischten Datentypen aufgebaut sind. Wir brauchen die Daten eigentlich nur noch in eckige Klammern einzuschließen und schon können wir sie wie ein Array behandeln und zum Beispiel mit einer each-Schleife über das Array iterieren und die einzelnen Elemente ausgeben:

>> string = '"Manon, Pinho, Joelle", " 30 qm", 3, "Macs"'
=> "\"Manon, Pinho, Joelle\", \" 30 qm\", 3, \"Macs\""
>> data = eval("[" + string + "]")
=> ["Manon, Pinho, Joelle", " 30 qm", 3, "Macs"]
>> data.each {|x| puts "Element = #{x}"}
Element = Manon, Pinho, Joelle
Element =  30 qm
Element = 3
Element = Macs
=> ["Manon, Pinho, Joelle", " 30 qm", 3, "Macs"]

Strings in Zahlen konvertieren 

to_i, to_f

Es gibt zwei Möglichkeiten, eine Zeichenkette in eine Zahl umzuwandeln:

über die beiden Kernel-Methoden Float und Integer oder über die beiden Methoden to_i und to_f, die die Klasse String zur Verfügung stellt.

Die Kernel-Methode Integer wandelt einen ihr übergebenen Wert in eine Fixnum oder Bignum um. Numerische Werte werden direkt umgewandelt, wobei bei Fließkommazahlen die Werte ab dem Komma abgeschnitten werden. Sie können mit Hilfe der Methode Integer numerische Zeichenketten zur Basis 2, 8, 10 oder 16 umwandeln. Um diese Möglichkeit zu nutzen, stellen Sie der Zeichenkette die Werte 0b, 0 oder 0x voran.

>> Integer(567.999)
=> 567
>> Integer("0x1a")
=> 26
>> Integer(Time.new)
=> 1172521153
>> Integer("0b1100101")
=> 101
>> Integer("01100101")
=> 294977
>> Integer("0x1100101")
=> 17826049
>> Integer("hallo")
ArgumentError: invalid value for Integer: "hallo"
	from (irb):8:in `Integer'
	from (irb):8
	from :0

Die Methode to_i wandelt auch numerische Werte direkt um. Bei der Umwandlung von alphanumerischen Zeichenketten wird die Umwandlung beim ersten nicht numerischen Zeichen beendet, und die Methode liefert den bis dahin ermittelten Wert zurück. Beginnt die übergebene Zeichenkette mit einem nicht numerischen Wert, wird 0 zurückgeliefert. Auch mit der Methode to_i können Sie numerische Zeichenketten zur Basis 2, 8, 10 oder 16 umwandeln. Den gewünschten Wert können Sie der Methode übergeben. Standardmäßig werden die Werte zur Basis 10 umgewandelt. Die Methode to_i liefert nie einen Fehler zurück.

>> "56789".to_i
=> 56789
>> "99 Luftballons".to_i
=> 99
>> "hallo".to_i
=> 0
>> "1100101".to_i(10)
=> 1100101
>> "1100101".to_i(2)
=> 101
>> "1100101".to_i(8)
=> 294977
>> "1100101".to_i(16)
=> 17826049

Integer, to_i

Im einfachsten Fall, der Umwandlung eines numerischen Strings in eine Zahl, erzielt man sowohl über Integer als auch über to_i das gleiche Ergebnis:

>> "567".to_i
=> 567
>> Integer("567")
=> 567

Float

Die Kernel-Methode Float wandelt ihr übergebene numerische Werte direkt in eine Fließkommazahl um. Nicht numerische Werte erzeugen einen Fehler. Seit Ruby 1.8 erzeugt auch die Umwandlung von nil einen Fehler, wohingegen die Integer Methode - nil in 0 umwandelt.

>> Float(1)
=> 1.0
>> Float("567.89")
=> 567.89
>> Float("hallo")
ArgumentError: invalid value for Float(): "hallo"
	from (irb):3:in 'Float'
	from (irb):3
	from :0
>> Float(nil)
TypeError: can´t convert nil into Float
	from (irb):4:in 'Float'
	from (irb):4
	from :0

to_f

Die Methode to_f wandelt eine Zeichenkette in eine Fließkommazahl um. Wird to_f auf eine alphanumerische Zeichenkette angewendet, wird die Umwandlung beim ersten nicht numerischen Zeichen beendet und der bis dahin ermittelte Wert zurückgeliefert. Beginnt die Zeichenkette mit einem nicht numerischen Wert, wird 0.0 zurückgeliefert. Die Methode to_f erzeugt nie einen Fehler.

>> "123.45e1".to_f
=> 1234.5
>> "45.67 Grad".to_f
=> 45.67
>> "hallo123".to_f
=> 0.0

Zeichenketten verschlüsseln 

Bestimmte Daten, wie Passwörter oder Ähnliches, möchte man nicht im Klartext speichern, egal wie gut die Zugriffsberechtigungen angelegt und verwaltet werden.

crypt

Die Methode crypt nutzt die gleichnamige Standard-Methode, um einen String zu verschlüsseln. Dazu übergibt man der Methode einen zweistelligen, zufälligen Wert, den sog. Salt-Wert, der die Werte [a-zA-Z0-9./] annehmen kann. Folgendes Beispiel können Sie in Ihrem Editor eingeben und ausführen:

coded = "hfQuWAmLL0tu."

puts "Sprich, Freund , und trete ein!"

print "Password: "

password = gets.chop

if password.crypt("hf") == coded
  puts "Willkommen!"
else
  puts "Tut mir leid Freund, das war das falsche Passwort"
end

Zeichen in einer Zeichenkette zählen 

count

Die Methode count zählt, wie oft die ihr übergebenen Zeichen innerhalb einer Zeichenkette vorkommen:

>> str = "hossa"
=> "hossa"
>> str.count("s")
=> 2
>> str.count("a")
=> 1

Negieren

Sie können die übergebenen Zeichen auch negieren und damit alles außer diesen Zeichen suchen, indem Sie ein Zirkumflex voranstellen:

>> str.count("^s")
=> 3
>> str.count("^a")
=> 4

Mit einem Bindestrich können Sie die Häufigkeit eines Bereichs von Zeichen innerhalb einer Zeichenkette suchen:

>> str.count("a-t")
=> 5
>> str.count("^a-t")
=> 0

Eine Zeichenkette umkehren 

reverse

Eine Zeichenkette kann mit der Methode reverse umgekehrt werden:

>> s = "Ananas"
=> "Ananas"
>> s.reverse
=> "sananA"
>> s
=> "Ananas"
>> s.reverse!
=> "sananA"
>> s
=> "sananA"

reverse!

Auch hier gibt es eine Methode, die das Objekt verändert: reverse!.

Wortreihenfolge umkehren

Wenn Sie nicht die Buchstabenreihenfolge umkehren möchten, sondern die Wortreihenfolge, können Sie mit Hilfe der Methode split die Zeichenkette in ein Array zerlegen. Die Klasse Array kennt auch eine Methode reverse, über die Sie die einzelnen Array-Elemente, sprich die einzelnen Wörter, umkehren können. Mit Hilfe der Methode join können Sie dann daraus wieder eine Zeichenkette erstellen. Und da man in Ruby mehrere Methoden hintereinander anwenden kann, könnte das so aussehen:

>> satz = "Das ist ein Beispiel"
=> "Das ist ein Beispiel"
>> satz.split(" ").reverse.join(" ")
=> "Beispiel ein ist Das"

Doppelte Zeichen entfernen 

squeeze

Doppelte Zeichen innerhalb einer Zeichenkette können Sie mit Hilfe der Methode squeeze entfernen. Wenn Sie der Methode ein Zeichen als Parameter übergeben, werden nur die Duplikate dieses Zeichens entfernt. Die Methode squeeze kennt wie die Methode count auch das vorangestellte Zirkumflex, um den übergebenen Parameter zu negieren, und den Bindestrich, um einen Bereich zu übergeben:

>> "zoo-oolith".squeeze
=> "zo-olith"
>> "Hallo...".squeeze
=> "Halo."
>> "Hallo...".squeeze("l")
=> "Halo..."
>> "Hallo...".squeeze("^l")
=> "Hallo."
>> "Hallo...".squeeze("l-o")
=> "Halo..."

Auch hier gibt es eine Methode squeeze!, die das Objekt verändert.

Bestimmte Zeichen entfernen 

delete

Die Methode delete entfernt die ihr übergebenen Zeichen aus einer Zeichenkette:

>> str = "Aepfel, Birnen, Bananen!"
=> "Aepfel, Birnen, Bananen!"
>> str.delete(",!")
=> "Aepfel Birnen Bananen"
>> str.delete("e")
=> "Apfl, Birnn, Banann!"

Auch die Methode delete kennt wie die Methode count das vorangestellte Zirkumflex, um den übergebenen Parameter zu negieren, und den Bindestrich, um einen Bereich zu übergeben, und es gibt auch eine Methode delete!, die das Objekt verändert.

>> str.delete("^e")
=> "eeee"
>> str.delete("a-e")
=> "Apfl, Birnn, Bnnn!"

Leerräume drucken 

dump

Mit der Methode dump können Sie Leerräume (Whitespaces) wie Tabulatoren oder das Zeichen für eine neue Zeile drucken. Für die Standardeinstellungen von $KCODE verhält sich dump genauso wie die Methode inspect:

s = "es\t\tregnet\tstark\n\n"

puts s
puts s.dump
puts s.inspect

# es regnet stark
# "es\t\tregnet\tstark\n\n"
# "es\t\tregnet\tstark\n\n"

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.