Programmierung in Ruby

Der Leitfaden der Pragmatischen Programmierer

class String
Parent: Object
Version: 1.6

Index:

new % * + << <=> == === =~ [ ] [ ]= ~ capitalize capitalize! center chomp chomp! chop chop! concat count crypt delete delete! downcase downcase! dump each each_byte each_line empty? gsub gsub! hash hex include? index intern length ljust next next! oct replace reverse reverse! rindex rjust scan size slice slice! split squeeze squeeze! strip strip! sub sub! succ succ! sum swapcase swapcase! to_f to_i to_s to_str tr tr! tr_s tr_s! unpack upcase upcase! upto


Ein String-Objekt enthält und manipuliert eine beliebige Sequenz von Bytes, die typischerweise lesbare Zeichen repräsentieren. String-Objekte können mit Hilfe von String.new oder mit Symbolen erstellt werden (vgl. hierzu ``Die Sprache Ruby'' im Abschnitt ``Basistypen'').

Wegen Alias-Problemen sollten Anwender von Strings die Methoden kennen, die den Inhalt eines String-Objekts verändern. Typischerweise modifizieren Methoden, deren Namen mit ``!'' enden, den Empfänger der Nachricht, während solche ohne ``!'' ein neues String-Objekt zurückgeben. Wie immer gibt es Ausnahmen, wie z.B. String#[]=.
mixins
Comparable: <, <=, ==, >=, >, between?
Enumerable: collect, detect, each_with_index, entries, find, find_all, grep, include?, map, max, member?, min, reject, select, sort, to_a

class methods
new String.new( einString ) -> einNeuerString

Gibt ein neues String-Objekt zurück, das eine Kopie von einString enthält.

instance methods
% str % arg-> einString

Format---Verwendet str als Formatangabe und gibt das Ergebnis von dessen Anwendung auf arg zurück. Wenn die Formatangabe mehr als eine Ersetzung enthält, muss arg ein Array mit den zu ersetzenden Werten enthalten. Siehe Kernel::sprintf in diesem Kapitel, Abschnitt ``Module'' für Details zur Formatangabe.

"%05d" % 123 » "00123"
"%-5s: %08x" % [ "ID", self.id ] » "ID[visible space][visible space][visible space]:[visible space]200cd648"

* str * einInteger-> einString

Kopie---Gibt einen neuen String mit einInteger Kopien des Empfänger zurück.

"Ho! " * 3 » "Ho! Ho! Ho! "

+ str + einString-> einNeuerString

Zusammenziehung---Gibt einen neuen String zurück, der einString angehängt an str zurück gibt.

"Hello from " + self.to_s » "Hello from main"

<< str << eineFixnum-> str
str << einObjekt-> str
Anhängen---Hängt das übergebene Objekt an str. Wenn das Objekt eine Fixnum zwischen 0 and 255 ist, wird es vor dem Anhängen in ein Zeichen umgewandelt.

a = "hello "
a << "world" » "hello world"
a << 33 » "hello world!"
a » "hello world!"

<=> str <=> einString-> -1, 0, +1

Vergleich---Gibt -1 zurück, wenn str kleiner, 0 wenn str gleich und +1 wenn str größer als einString ist. Wenn die Strings verschieden lang sind und sie bis zum Ende des kürzeren Strings identisch sind, gilt der längere String als größer als der kürzere. Wenn die Variable $=false ist, wird der Vergleich auf der Basis der binären Werte der Strings durchgeführt. Wenn $= nicht false ist, wird der Vergleich unabhängig von der Groß-/Kleinschreibung durchgeführt[Länderspezifische Zeichen werden ignoriert, wenn ein Groß-/Kleinschreibungs-unabhängiger Vergleich durchgeführt wird, so dass ``ö'' auf ``Ö'' keinen Treffer gibt.].

<=> ist die Basis für die Methoden <, <=, >, >= und between?, die aus dem Modul Comparable eingebunden werden. Die Methode String#== benutzt Comparable#== nicht.

"abcdef" <=> "abcde" » 1
"abcdef" <=> "abcdef" » 0
"abcdef" <=> "abcdefg" » -1
"abcdef" <=> "ABCDEF" » 1
$= = true
"abcdef" <=> "ABCDEF" » 0

== str == einObjekt-> true oder false

Gleichheit---Wenn einObjekt kein String ist, gibt die Methode false zurück. Sonst wird true zurück gegeben, wenn str<=>einObjekt Null ergibt.

=== str === einObjekt-> true oder false

Fallgleichheit---Synonym für String#==.

=~ str =~ einObjekt-> einFixnum oder nil

Vergleich---Wenn einObjekt ein Regexp- oder ein String-Objekt ist, wird es als Muster für einen Vergleich mit str herangezogen. Gibt die Position des ersten übereinstimmenden Zeichens bzw. nil zurück. Sonst wird einObjekt.=~ aufgerufen, wobei str als Argument übergeben wird. Die Standardimplementierung in Object gibt false zurück.

"cat o' 9 tails" =~ "\\d" » 7
"cat o' 9 tails" =~ /\d/ » 7
"cat o' 9 tails" =~ 9 » false

[ ] str[ eineFixnum ] -> eineFixnum oder nil
str[ eineFixnum, eineFixnum ] -> einString oder nil
str[ einBereich ] -> einString oder nil
str[ einRegAusdr ] -> einString oder nil
str[ einString ] -> einString oder nil

Elementreferenz---Wenn nur ein Fixnum-Wert übergeben wird, gibt die Methode den Code des Zeichen an der genannten Position zurück. Wenn zwei Fixnum-Objekte übergeben werden, wird der Teilstring, der an der zuerst übergebenen Position beginnt, bis zur Länge des zweiten übergebenen Parameters zurück gegeben. Ist der Parameter ein Bereich (Range), wird ein Teilstring mit den entsprechenden Zeichen zurückgegeben. In allen drei Fällen bewirken negative Offsets, dass die Positionsangabe relativ zum Ende von str erfolgt. Die Methode gibt nil zurück, wenn der angegebene Offset ausserhalb des String-Bereichs liegt, die Länge negativ ist oder der Beginn des Bereichs größer ist als sein Ende.

Wenn ein Regexp-Objekt übergeben wird, gibt die Methode den Trefferbereich aus str zurück. Ein String als Argument wird zurückgegeben wenn er in str auftritt. In beiden Fällen wird nil zurückgegeben, wenn kein Treffer erzielt wird.

a = "hello there"
a[1] » 101
a[1,3] » "ell"
a[1..3] » "ell"
a[-3,2] » "er"
a[-4..-2] » "her"
a[-2..-4] » nil
a[/th[aeiou]/] » "the"
a["lo"] » "lo"
a["bye"] » nil

[ ]= str[ eineFixnum ] = eineFixnum
str[ eineFixnum ] = einString
str[ eineFixnum, eineFixnum ] = einString
str[ einBereich ] = einString
str[ einRegAusdr ] = einString
str[ einString ] = einString

Elementzuweisung---Ersetzt einen Teil oder den gesamten Inhalt von str. Der betroffene Teil des Strings wird mit denselben Kriterien wie bei String#[] ermittelt. Wenn der ersetzende String nicht dieselbe Länge hat wie der durch ihn ersetzte Text, wird der String automatisch entsprechende angepasst. Die Varianten, die den Fixnum-Typ akzeptieren, werfen einen IndexError wenn der Wert ausserhalb des Geltungsbereichs liegt; die Range-Variante wirft einen RangeError, und die Regexp- bzw. String-Variante ignorieren die Zuweisung ohne Rückmeldung.
a = "hello"; a[2]       = 96;    a » "he`lo"
a = "hello"; a[2, 4]    = "xyz"; a » "hexyz"
a = "hello"; a[-4, 2]   = "xyz"; a » "hxyzlo"
a = "hello"; a[2..4]    = "xyz"; a » "hexyz"
a = "hello"; a[-4..-2]  = "xyz"; a » "hxyzo"
a = "hello"; a[/[el]+/] = "xyz"; a » "hxyzo"
a = "hello"; a["l"]     = "xyz"; a » "hexyzlo"
a = "hello"; a["ll"]    = "xyz"; a » "hexyzo"
a = "hello"; a["bad"]   = "xyz"; a » "hello"
a = "hello"; a[2, 0]    = "xyz"; a » "hexyzllo"

~ ~str-> eineFixnum oder nil

Equivalent mit $_ =~ str.

capitalize str.capitalize -> einString

Gibt eine Kopie von str mit dem ersten Buchstaben in Großschrift und dem Rest in Kleinschrift zurück.

"hello".capitalize » "Hello"
"HELLO".capitalize » "Hello"
"123ABC".capitalize » "123abc"

capitalize! str.capitalize! -> str oder nil

Modifiziert str indem der erste Buchstabe in Großschrift und der Rest in Kleinschrift gesetzt wird. Gibt nil zurück, wenn keine Änderungen gemacht wurden.
a = "hello"
a.capitalize! » "Hello"
a » "Hello"
a.capitalize! » nil

center str.center( einInteger ) -> einString

Wenn einInteger größer als die Länge von str ist, gibt die Methode einen neuen String der Länge einInteger zurück, in dem der Inhalt von str mit Leerzeichen zentriert ausgerichtet wird; sonst wird str zurück gegeben.

"hello".center(4) » "hello"
"hello".center(20) » "[visible space][visible space][visible space][visible space][visible space][visible space][visible space]hello[visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space]"

chomp str.chomp( einString=$/ ) -> einString
Gibt einen neuen String zurück, in dem das angegebene Satz-Trennzeichen vom Ende von str entfernt wurde (sofern vorhanden).

"hello".chomp » "hello"
"hello\n".chomp » "hello"
"hello \n there".chomp » "hello \n there"
"hello".chomp("llo") » "he"

chomp! str.chomp!( einString=$/ ) -> str oder nil

Verändert str selbst wie in String#chomp beschrieben und gibt str oder nil zurück.
chop str.chop -> einString

Gibt einen neuen String zurück, in dem das letzte Zeichen entfernt wurde. Wenn der String mit \r\n endet, werden beide Zeichen entfernt. Die Anwendung von chop auf einen leeren String gibt einen leeren String zurück. String#chomp ist oft die sicherere Alternative, weil es einen String, der nicht mit dem Zeilentrennezeichen endet, unverändert lässt.

"string\r\n".chop » "string"
"string\n\r".chop » "string\n"
"string\n".chop » "string"
"string".chop » "strin"
"x".chop.chop » ""

chop! str.chop! -> str oder nil

Verändert str selbst wie in String#chop beschrieben und gibt str zurück. Wenn str leer ist, wird nil zurück gegeben. Siehe auch String#chomp!.

concat str.concat( eineFixnum ) -> str
str.concat( einObjekt ) -> str

Synonym für String#<<.

count str.count( [einString]+ ) -> eineFixnum

Jeder einString-Parameter legt einen Satz von zu zählenden Zeichen fest. Die Schnittmenge dieser Zeichen definiert die zu zählenden Zeichen in str. Jeder einString, der mit einem Dach (^) beginnt, wird nicht beachtet. Die Sequenz c1--c2 meint alle Zeichen zwischen c1 und c2.

a = "hello world"
a.count "lo" » 5
a.count "lo", "o" » 2
a.count "hello", "^l" » 4
a.count "ej-m" » 4

crypt str.crypt( einString ) -> einString

Wendet ein Einwegverschlüsselung auf str mit Hilfe der Standardbibliotheksfunktion crypt. Das Argument ist der Salt-String, der zwei Zeichen aus der Menge [a-zA-Z0-9./] umfasst.

delete str.delete( [einString]+ ) -> einString

Gibt eine Kopie von str zurück, in der alle Zeichen aus der Schnittmenge der Argumente gelöscht sind. Die Methode benutzt dieselben Regeln umd den Satz von Zeichen zu bilden wie String#count.

"hello".delete "l","lo" » "heo"
"hello".delete "lo" » "he"
"hello".delete "aeiou", "^e" » "hell"
"hello".delete "ej-m" » "ho"

delete! str.delete!( [einString]+ ) -> str oder nil

Führt die delete-Operation auf str aus und den String oder nil (wenn str nicht verändert wurde) zurück.
downcase str.downcase -> einString

Gibt eine Kopie von str zurück, in der alle Großbuchstaben durch die entsprechenden Kleinbuchstaben ersetzt sind. Die Methode ändert keine länderspezifischen Zeichen---nur die Zeichen ``A'' bis ``Z'' werden berücksichtigt.

"hEllO".downcase » "hello"

downcase! str.downcase! -> str oder nil

Ersetzt alle Großbuchstaben in str durch Kleinbuchstaben, gibt nil zurück, wenn keine Änderungen gemacht wurden.
dump str.dump -> einString

Erstellt eine Version von str in der alle nicht-druckbaren Zeichen durch \nnn ersetzt und alle speziellen Zeichen entfernt wurden.

each str.each( einString=$/ ) {| substr | block }-> str

Teilt str unter Berücksichtigung des angegebenen Parameters als Datensatz-Trennzeichen (Standardwert ist $/) und gibt die Teilstrings an den Codeblock weiter. Wenn das Trennzeichen die Länge Null hat, wird der String bei \n-Zeichen (Zeilenumbruch) geteilt, ausser mehrere Zeilenumbrüche folgen aufeinander.

print "Example one\n"
"hello\nworld".each {|s| p s}
print "Example two\n"
"hello\nworld".each('l') {|s| p s}
print "Example three\n"
"hello\n\n\nworld".each('') {|s| p s}
ergibt:
Example one
"hello\n"
"world"
Example two
"hel"
"l"
"o\nworl"
"d"
Example three
"hello\n\n\n"
"world"

each_byte str.each_byte {| eineFixnum | block }

-> str

Gibt jedes Byte in str an den gegebene Codeblock weiter.

"hello".each_byte {|c| print c, ' ' }
ergibt:
104 101 108 108 111

each_line str.each_line( einString=$/ ) {| substr | block }-> str

Synonym für String#each.

empty? str.empty? -> true oder false

Gibt true zurück, wenn str die Länge Null hat.

"hello".empty? » false
"".empty? » true

gsub str.gsub( muster, ersatz ) -> einString
str.gsub( muster ) {| match | block }-> einString

Gibt eine Kopie von str zurück, in der jedes Auftreten von muster entweder mit ersatz oder mit dem Ergebnis des Codeblocks ersetzt wurde. Wenn ein String als Ersatz verwendet wird können spezielle Variablen aus dem Vergleich (z.B. $& und $1) nicht in ihn eingesetzt werden, da die Substitution in den String erfolgt, bevor der Mustervergleich beginnt. Jedoch können die Sequenzen \1, \2 usw. benutzt werden, um aufeinanderfolgende Gruppen im Vergleich zu interpolieren. Diese Sequenzen sind in der untenstehenden Tabelle aufgeführt.

Backslash-Sequenzen in Substitutions-Strings
Sequenz Eingesetzter Text
\1, \2, ... \9 Der Wert des nten gruppierten Teilausdrucks
\& Der letzte Treffer
\` Der Teil des Strings vor dem Treffer
\' Der Teil des Strings nach dem Treffer
\+ Die Treffergruppe mit dem höchsten Index

In der Block-Form wird der aktuelle Treffer als Parameter weitergegeben und Varaiblen wie z.B. $1, $2, $`, $& und $' werden richtig gesetzt. Der vom Block zurückgegebene Wert wird nach jedem Aufruf für den Treffer eingesetzt.

Das Ergebnis erbt den ``tainted''-Status (vgl. dazu das Kapitel ``Ruby im Tresor sichern'') oder bereits gelieferte Ersatzstrings.

"hello".gsub(/[aeiou]/, '*') » "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>') » "h<e>ll<o>"
"hello".gsub('.') {|s| s[0].to_s + ' '} » "104 101 108 108 111 "

gsub! str.gsub!( muster, replacement ) -> str oder nil
str.gsub!( muster ) {| match | block }-> str oder nil

Führt die Ersetzungen von String#gsub auf dem Empfänger aus und gibt str bzw. nil zurück, wenn keine Ersetzungen vorgenommen wurden.
hash str.hash -> eineFixnum

Erstellt einen Fixnum-Hash-Wert für str. Wenn $=true ist, unterscheidet das Hash nicht zwischen Groß- und Kleinschreibung.

$= = true
hash = { 'cat' => 'Feline', 'dog' => 'canine' }
hash['cat'] » "Feline"
hash['cAt'] » "Feline"
$= = false
hash.rehash     # re-calculate hash values » {"dog"=>"canine", "cat"=>"Feline"}
hash['cat'] » "Feline"
hash['cAt'] » nil

hex str.hex -> einInteger

Behandelt die ersten Zeichen von str als einen String von Hexadezimalzahlen (mit einem optionalen Vorzeichen und einem optionalen 0x) und gibt die korresponierende Zahl zurück. Bei Fehlern wird Null zurückgegeben.

"0x0a".hex » 10
"-1234".hex » -4660
"0".hex » 0
"wombat".hex » 0

include? str.include? einString-> true oder false
str.include? eineFixnum-> true oder false

Gibt true zurück, wenn str den angegebenen String oder das Zeichen enthält.

"hello".include? "lo" » true
"hello".include? "ol" » false
"hello".include? ?h » true

index str.index( einString[, einOffset] ) -> eineFixnum oder nil
str.index( eineFixnum[, einOffset] ) -> eineFixnum oder nil
str.index( einRegAusdr[, einOffset] ) -> eineFixnum oder nil

Gibt den Index des ersten Auftretens des übergebenen Strings / Zeichens / Treffers des regulären Ausdrucks in str zurück. Die Methode gibt nil zurück, wenn nichts gefunden wurde. Wird ein zweiter Parameter angegeben, so sucht die Methode erst ab dieser Position in str.

"hello".index('e') » 1
"hello".index('lo') » 3
"hello".index('a') » nil
"hello".index(101) » 1
"hello".index(/[aeiou]/, -3) » 4

intern str.intern -> einSymbol

Gibt das zu str korrespondierende Symbol-Objekt zurück, wobei das Symbol erstllt wird, wenn es nicht zuvor exisiert hat. Siehe Symbol#id2name im Abschnitt ``Symbol''.

"Koala".intern » :Koala

length str.length -> einInteger

Gibt die Länge von str zurück.

ljust str.ljust( einInteger ) -> einString

Wenn einInteger größer als die Länge von str ist, wird ein neuer String der Länge einInteger zurück gegeben, in dem str links ausgerichtet ist; der verbleibende Raum wird mit Leerzeichen gefüllt. Sonst wird str zurück gegeben.

"hello".ljust(4) » "hello"
"hello".ljust(20) » "hello[visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space]"

next str.next -> einString

Synonym für String#succ.

next! str.next! -> str

Synonym für String#succ!.

oct str.oct -> einInteger

Behandelt str als einen String von Oktalzahlen (mit einem optionalen Vorzeichen) und gibt die korrespondierende Zahl (dezimal) zurück. Die Methode gibt 0 zurück, wenn die Konversion scheitert.

"123".oct » 83
"-377".oct » -255
"bad".oct » 0
"0377bad".oct » 255

replace str.replace( einString ) -> str

Ersetzt den Inhalt und den ``tainted''-Status (vgl. Kapitel ``Ruby im Tresor sichern'') von str durch die entsprechenden Werte aus einString.

s = "hello" » "hello"
s.replace "world" » "world"

reverse str.reverse -> einString

Gibt einen neuen String zurück, der die Zeichen von str in umgekehrter Reihenfolge enthält.

"stressed".reverse » "desserts"

reverse! str.reverse! -> str

Kehrt die Reihenfolge der Zeichen in str selbst um.
rindex str.rindex( einString[, eineFixnum] ) -> eineFixnum oder nil
str.rindex( eineFixnum[, eineFixnum] ) -> eineFixnum oder nil
str.rindex( einRegAusdr[, eineFixnum] ) -> eineFixnum oder nil

Gibt den Index des letzten Auftretens des übergebenen Strings / Zeichens / Treffers des regulären Ausdrucks in str zurück. Die Methode gibt nil zurück, wenn nichts gefunden wurde. Wird ein zweiter Parameter angegeben, so sucht die Methode nur bis zu dieser Position in str--darauf folgende Zeichen werden nicht berücksichtigt.

"hello".rindex('e') » 1
"hello".rindex('l') » 3
"hello".rindex('a') » nil
"hello".rindex(101) » 1
"hello".rindex(/[aeiou]/, -2) » 1

rjust str.rjust( einInteger ) -> einString

Wenn einInteger größer als die Länge von str ist, wird ein neuer String der Länge einInteger zurück gegeben, in dem str rechts ausgerichtet ist; der verbleibende Raum wird mit Leerzeichen gefüllt. Sonst wird str zurück gegeben.

"hello".rjust(4) » "hello"
"hello".rjust(20) » "[visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space][visible space]hello"

scan str.scan( muster ) -> einArray
str.scan( muster ) {| match, ...| block }-> str

Beide Formen iterieren str und suchen das Muster (das vom Regexp oder String-Typ ist). Für jeden Treffer wird ein Ergebnis erstellt und entweder an das Ergebnis-Array angehängt oder an den Block weitergegeben. Wenn das Muster keine Gruppen enthält, besteht jedes einzelne Ergebnis aus dem gefundenen String, $&. Anderenfalls ist jedes Ergebnis wiederum ein Array , das einen Eintrag je Gruppe enthält.

a = "cruel world"
a.scan(/\w+/) » ["cruel", "world"]
a.scan(/.../) » ["cru", "el ", "wor"]
a.scan(/(...)/) » [["cru"], ["el "], ["wor"]]
a.scan(/(..)(..)/) » [["cr", "ue"], ["l ", "wo"]]

And the block form:

a.scan(/\w+/) {|w| print "<<#{w}>> " }
print "\n"
a.scan(/(.)(.)/) {|a,b| print b, a }
print "\n"
ergibt:
<<cruel>> <<world>>
rceu lowlr

size str.size -> einInteger

Synonym für String#length.

slice str.slice( eineFixnum ) -> eineFixnum oder nil
str.slice( eineFixnum, eineFixnum ) -> einString oder nil
str.slice( einBereich ) -> einString oder nil
str.slice( einRegAusdr ) -> einString oder nil
str.slice( einString ) -> einString oder nil

Synonym für String#[ ].

a = "hello there"
a.slice(1) » 101
a.slice(1,3) » "ell"
a.slice(1..3) » "ell"
a.slice(-3,2) » "er"
a.slice(-4..-2) » "her"

a.slice(-2..-4) » nil
a.slice(/th[aeiou]/) » "the"
a.slice("lo") » "lo"
a.slice("bye") » nil

slice! str.slice!( eineFixnum ) -> eineFixnum oder nil
str.slice!( eineFixnum, eineFixnum ) -> einString oder nil
str.slice!( einBereich ) -> einString oder nil
str.slice!( einRegAusdr ) -> einString oder nil
str.slice!( einString ) -> einString oder nil

Entfernt den angegebenen Teil aus str und gibt den ausgeschnittenen Teil zurück. Die Formen, die eine Fixnum akzeptieren, werfen einen IndexError wenn der Wert ausserhalb des Gletungsbereichs liegt; die Range-Form wirft einen RangeError und die Regexp- und String-Form ignorieren den Methodenaufruf stillschweigend.
string = "this is a string"
string.slice!(2) » 105
string.slice!(3..6) » " is "
string.slice!(/s.*t/) » "sa st"
string.slice!("r") » "r"
string » "thing"

split str.split( muster=$;, [grenze] ) -> einArray

Teilt str auf der Basis des Trenners in Teilstrings und gibt diese als Array von Teilstrings zurück.

Wenn muster ein String ist, wird sein Inhalt als Trennzeichen zur Aufteilung von str verwendet. Wenn muster ein einfaches Leerzeichen ist, wird str bei Leerzeichen mit genau einem führenden Leerzeichen geteilt, egal wie viele Leerzeichen darauf eigentlich folgen.

Ist muster vom Regexp-Typ, wird str dort geteilt, wo der reguläre Ausdruck einen Treffer erzeugt. Wo immer das Muster einen String von Länge Null trifft wird str in einzelne Zeichen aufgeteilt.

Wenn muster weggelassen wird, ist der Wert von $; ausschlaggebend. Wenn $; gleich nil ist (was standardmässig der Falls ist), wird str bei Leerzeichen getrennt wie wenn `[visible space]' angegeben wäre.

Wenn der Parameter grenze weggelassen wird, werden anhängende Null-Felder unterdrückt. Wenn grenze eine positive Zahl ist, wird maximal diese Anzahl von Feldern zurückgegeben (wenn grenze 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.

" now's  the time".split » ["now's", "the", "time"]
" now's  the time".split(' ') » ["now's", "the", "time"]
" now's  the time".split(/ /) » ["", "now's", "", "the", "time"]
"1, 2.34,56, 7".split(/,\s*/) » ["1", "2.34", "56", "7"]
"hello".split(//) » ["h", "e", "l", "l", "o"]
"hello".split(//, 3) » ["h", "e", "llo"]
"hi mom".split(/\s*/) » ["h", "i", "m", "o", "m"]

"mellow yellow".split("ello") » ["m", "w y", "w"]
"1,2,,3,4,,".split(',') » ["1", "2", "", "3", "4"]
"1,2,,3,4,,".split(',', 4) » ["1", "2", "", "3,4,,"]
"1,2,,3,4,,".split(',', -4) » ["1", "2", "", "3", "4", "", ""]

squeeze str.squeeze( [einString]* ) -> einNeuerString

Bildet unter Verwendung der in String#count beschriebenen Methode einen Satz von Zeichen aus dem (den) Parameter(n) einString. Gibt einen neuen String zurück, in dem Folgen gleicher Zeichen durch ein einziges Zeichen ersetzt sind. Wenn kein(e) Argument(e) übergegeben werden, werden alle Folgen gleicher Zeichen durch ein einzelnes Zeichen ersetzt.

"yellow moon".squeeze » "yelow mon"
"  now   is  the".squeeze(" ") » " now is the"
"putters shoot balls".squeeze("m-z") » "puters shot balls"

squeeze! str.squeeze!( [einString]* ) -> str oder nil

Verdichtet str selbst und gibt entweder str oder nil zurück, wenn keine Änderungen vorgenommen wurden.
strip str.strip -> einString

Gibt eine Kopie von str zurück, in der vorn- bzw. hintenstehende Leerzeichen gelöscht wurden.

"    hello    ".strip » "hello"
"\tgoodbye\r\n".strip » "goodbye"

strip! str.strip! -> str oder nil

Entfernt vorn- und hintenstehende Leerzeichen aus str selbst. Die Methode gibt nil zurück, wenn str nicht verändert wurde.
sub str.sub( muster, ersatz ) -> einString
str.sub( muster ) {| match | block }-> einString

Gibt eine Kopie von str zurück, in der das erste Auftreten von muster entweder durch replacement oder durch den Wert des Codeblocks ersetzt wurde. Wenn die String-Form der Methode benutzt wurde, sind spezielle Variablen wie z.B. $& nicht hilfreich, da die Ersetzung in den String vor der Muster-Suche geschieht. Die Sequenzen \1, \2, die in der Tabelle 22.7 (vgl. String#hex) aufgeführt sind, können verwendet werden.

In der Blockform wird der aktuelle Treffer als Parameter weitergegeben und Variablen wie $1, $2, $`, $& und $' werden entsprechend gesetzt. Der vom Codeblock zurückgegebene Wert wird für den Treffer des jeweiligen Aufrufs eingesetzt.

"hello".sub(/[aeiou]/, '*') » "h*llo"
"hello".sub(/([aeiou])/, '<\1>') » "h<e>llo"
"hello".sub('.') {|s| s[0].to_s + ' ' } » "104 ello"

sub! str.sub!( muster, replacement ) -> str oder nil
str.sub!( muster ) {| match | block }-> str oder nil

Führt die Ersetzungen von String#sub auf str selbst aus und gibt str oder nil zurück, wenn keine Ersetzungen vorgenommen wurden.
succ str.succ -> einString
Gibt den Nachfolger von str zurück. Dieser wird durch die Inkrementierung von Zeichen beginnend mit dem am weitesten rechts stehenden alphanumerischen Zeichen (oder dem am weitesten rechts stehenden Zeichen, wenn keine alphanumerischen existieren) im String berechnet. Die Inkrementierung einer Zahl führt immer zu einer neuen Zahl so wie die Inkrementierung eines Buchstabens immer wieder zu einem Buchstaben in derselben Schreibweise (groß/klein) führt. Die Inkrementierung von nicht-alphanumerischen Zeichen verwendet die Reihung des zugrunde liegenden Zeichensatzes.

Wenn das Inkrement einen ``Übertrag'' generiert, wird das links davon stehende Zeichen ebenfalls inkrementiert. Dies wird solange nach links weitergeführt bis kein ``Übertrag'' mehr erzeugt wird; dabei wird nötigenfalls ein weiteres Zeichen angefügt.

"abcd".succ » "abce"
"THX1138".succ » "THX1139"
"<<koala>>".succ » "<<koalb>>"
"1999zzz".succ » "2000aaa"
"ZZZ9999".succ » "AAAA0000"
"***".succ » "**+"

succ! str.succ! -> str

Equivalent mit String#succ, jedoch wird der Empfänger selbst geändert.
sum str.sum( eineFixnum=16 ) -> einInteger

Gibt eine einfache n-bit Prüfsumme der Zeichen in str zurück, wobei n ein optionaler, standardmässig auf 16 gesetzter Parameter ist. Das Ergebnis ist schlicht die Summe der binären Werte jedes Zeichens in str modulo 2n - 1. Dies stellt keine besonders gute Prüfsumme dar.

swapcase str.swapcase -> einString

Gibt eine Kopie von str mit einer vertauschten Groß- und Kleinschreibung der Zeichen zurück (große Buchstaben werden zu kleinen Buchstaben und umgekehrt).

"Hello".swapcase » "hELLO"
"cYbEr_PuNk11".swapcase » "CyBeR_pUnK11"

swapcase! str.swapcase! -> str oder nil

Equivalent mit String#swapcase, jedoch wird der Empfänger stattdessen modifiziert. Die Methode gibt str zurück, oder nil wenn keine Änderungen vorgenommen wurden.
to_f str.to_f -> eineGleitkommazahl

Gibt das Ergebnis der Interpretation der führenden Zeichen in str als Gleitkommazahl zurück. Weitere Zeichen nach dem Ende einer gültigen Zahl werden ignoriert. Wenn keine gültige Zahl am Beginn von str steht, wird 0.0 zurück gegeben. Diese Methode wirft nie einen Fehler.

"123.45e1".to_f » 1234.5
"45.67 degrees".to_f » 45.67
"thx1138".to_f » 0.0

to_i str.to_i -> einInteger

Gibt das Ergebnis der Interpretation der führenden Zeichen in str als ganze Zahl zurück. Weitere Zeichen nach dem Ende einer gültigen Zahl werden ignoriert. Wenn keine gültige Zahl am Beginn von str steht, wird 0 zurück gegeben. Diese Methode wirft nie einen Fehler.

"12345".to_i » 12345
"99 red balloons".to_i » 99
"0x0a".to_i » 0
"hello".to_i » 0

to_s str.to_s -> str

Gibt den Empfänger zurück.

to_str str.to_str -> str

Synonym für String#to_s. to_str wird von Methoden wie z.B. String#concat verwendet, im ihre Argumente in einen String zu verwandeln. Anders als to_s, die von praktisch allen Klassen unterstützt wird, wird to_str normalweise nur von Klassen implementiert, die sich wie Strings verhalten. Hierzu gehören aus dem Satz der eingebauten Klassen nur Exception und String.

tr str.tr( vonString, nachString ) -> einString

Gibt eine Kopie von str zurück, in dem die Zeichen aus vonString durch die entsprechenden in nachString ersetzt sind. Wenn nachString kürzer als vonString ist, wird er mit seinem letzten Zeichen aufgefüllt. Beide Strings können die c1--c2 Notation verwenden, um Bereiche von Zeichen zu benennen. Ebenso kann vonString mit einem ^ beginnen, um alle Zeichen ausser diesen anzuzeigen.

"hello".tr('aeiou', '*') » "h*ll*"
"hello".tr('^aeiou', '*') » "*e**o"
"hello".tr('el', 'ip') » "hippo"
"hello".tr('a-y', 'b-z') » "ifmmp"

tr! str.tr!( vonString, nachString ) -> str oder nil

Übersetzt str selbst und verwendet dazu die Regeln aus String#tr. Die Methode gibt str zurück oder nil wenn keine Änderungen vorgenommen wurden.
tr_s str.tr_s( vonString, nachString ) -> einString

Wendet die unter String#tr beschriebenen Übersetzungsregeln auf eine Kopie von str an und entfernt danach alle doppelten Zeichen aus den Regionen im String, die durch die Ersetzung betroffen waren.

"hello".tr_s('l', 'r') » "hero"
"hello".tr_s('el', '*') » "h*o"
"hello".tr_s('el', 'hx') » "hhxo"

tr_s! str.tr_s!( vonString, nachString ) -> str oder nil

Wendet das Vorgehen aus String#tr_s auf str selbst an und gibt str zurück bzw. nil, wenn keine Änderungen gemacht wurden
unpack str.unpack( format ) -> einArray

Dekodiert str (der binäre Daten enthalten kann) entsprechend dem Formatstring und gibt eine Array der extrahierten Werte zurück. Der Format-String besteht aus einer Sequenz von ein-Zeichen-Anweisungen, die in Tabelle 22.8 (s. unten) zusammengefasst sind. Jede Anweisung kann von einer Zahl gefolgt werden, die angibt, wie oft diese Anweisung ausgeführt werden soll. Ein Stern (``*'') verbraucht alle verbleibenden Elemente. Die Anweisungen sSiIlL können jeweils von einem Unterstrich (``_'') gflgt sein, um die native Größe auf der zugrunde liegenden Plattform für den jeweiligen Typ zu verwenden; anderenfalls wird eine Plattform-unabhängige, konsistente Größe verwendet. Leerzeichen im Formatstring werden ignoriert. Siehe auch Array#pack im Abschnitt ``Array'' dieses Kapitels.

Anweisungen für String#unpack
Format Funktion Rückgabe
A String mit entfernten endständigen Nullen und Leerzeichen. String
a String. String
B Extrahiere die Bits aus jedem Zeichen (msb zuerst). String
b Extrahiere die Bits aus jedem Zeichen (lsb zuerst). String
C Extrahiere ein Zeichen als ganze Zahl ohne Vorzeichen. Fixnum
c Extrahiere ein Zeichen als ganze Zahl. Fixnum
d Behandle sizeof(double)-Zeichen als native double-Zahl. Float
E Behandle sizeof(double)-Zeichen als eine double-Zahl in little-endian Bytefolge.2 Float
e Behandle sizeof(float)-Zeichen als eine Gleitkommazahl in little-endian Bytefolge.2 Float
f Behandle sizeof(float)-Zeichen als native Gleitkommazahl. Float
G Behandle sizeof(double)-Zeichen als double-Zahl in network Bytefolge.2 Float
g Behandle sizeof(float)-Zeichen als eine Gleitkommazahl in network Bytefolge.2 Float
H Extrahiere hex-Halbbytes aus jedem Zeichen (höchst-signifikantes zuerst). String
h Extrahiere hex-Halbbytes aus jedem Zeichen (geringst-signifikantes zuerst). String
I Behandle sizeof(int)1 aufeinanderfolgende Zeichen als eine native ganze Zahl ohne Vorzeichen. Integer
i Behandle sizeof(int)1 aufeinanderfolgende Zeichen als eine native ganze Zahl mit Vorzeichen. Integer
L Behandle vier1 aufeinanderfolgende Zeichen als eine native lange Ganzzahl ohne Vorzeichen. Integer
l Behandle vier1 aufeinanderfolgende Zeichen als eine native lange Ganzzahl mit Vorzeichen. Integer
M Extrahiere einen druckbaren String mit Anführungszeichen. String
m Extrahiere einen base64-kodierten String. String
N Behandle vier Zeichen als eine lange Zahl ohne Vorzeichen in network-Bytefolge.2 Fixnum
n Behandle zwei Zeichen als kurze Zahl ohne VOrzeichen in network-Bytefolge.2 Fixnum
P Behandle sizeof(char *) Zeichen als Zeiger und gib len Zeichen von dem referenzierten Ort aus. String
p Behandle sizeof(char *) Zeichen als Zeiger auf einen Null-terminierten String. String
S Behandle zwei1 aufeinanderfolgende Zeichen als eine kurze Zahl ohne Vorzeichen in nativer Bytefolge. Fixnum
s Behandle zwei1 aufeinanderfolgende Zeichen als eine kurze Zahl mit Vorzeichen in nativer Bytefolge. Fixnum
U Extrahiere UTF-8 Zeichen als Ganzzahlen ohne Vorzeichen. Integer
u Extrahiere einen UU-kodierten String. String
V Behande vier Zeichen als eine lange Zahl ohne Vorzeichen in little-endian Bytefolge.2 Fixnum
v Behandle zwei Zeichen als kurze Zahl ohne Vorzeichen in little-endian Bytefolge.2 Fixnum
X Gehe ein Zeichen zurück. ---
x Gehe ein Zeichen vor. ---
Z String mit entfernten endständigen Nullen. String
@ Überspringe die in len angegebene Anzahl an Zeichen. ---

1 Können durch Anhängen von ``_'' an die Anweisung modifiziert werden.

2 Die Bytefolge zeigt an, an welcher Stelle das höchst-signifikante Byte einer Zahl steht, die mehr als ein Byte im Speicher belegt. Es gibt zwei Möglichkeiten, die Bytefolge zu wählen:
little-endian byte order
Das höchst signifikante Byte steht weiter oben im Speicher als das geringst-signifikante Byte.
big-endian byte order
Das höchst signifikante Byte steht als erstes im Speicher, geringer sigifikante dahinter.
Der Begriff ``network byte order'' ist identisch mit ``big-endian byte order''.

"abc \0\0abc \0\0".unpack('A6Z6') » ["abc", "abc "]
"abc \0\0".unpack('a3a3') » ["abc", " \000\000"]
"aa".unpack('b8B8') » ["10000110", "01100001"]
"aaa".unpack('h2H2c') » ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') » [-2, 65534]
"now=20is".unpack('M*') » ["now is"]
"whole".unpack('xax2aX2aX1aX2a') » ["h", "e", "l", "l", "o"]

upcase str.upcase -> einString

Gibt eine Kopie von str zurück, in der alle Kleinbuchstaben durch die entsprechenden Großbuchstaben ersetzt wurden. Die Operation ist nicht Länder-spezifisch---nur die Zeichen ``a'' bis ``z'' sind betroffen.

"hEllO".upcase » "HELLO"

upcase! str.upcase! -> str oder nil

Setzt den Inhalt von str in Großschrift; gibt nil zurück, wenn keine Änderungen gemacht wurden.
upto str.upto( einString ) {| s | block }-> str

Iteriert durch aufeinanderfolgende Werte, beginnend bei str bis einString inklusive, wobei jeder Wert an den Block weitergegeben wird. Die Methode String#succ wird eingesetzt, um die Nachfolgewerte zu erzeugen.

"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
  print s, ' '
end
ergibt:
a8 a9 b0 b1 b2 b3 b4 b5 b6
a8 a9 b0 b1 b2 b3 b4 b5 b6


Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Übersetzung: Carsten Schinzer
Für das englische Original:
© 2000 Addison Wesley Longman, Inc. Released under the terms of the Open Publication License V1.0. That reference is available for download.
Diese Lizenz sowie das Original vom Herbst 2001 bilden die Grundlage der Übersetzung
Es wird darauf hingewiesen, dass sich die Lizenz des englischen Originals inzwischen geändert hat.
Für die deutsche Übersetzung:
© 2002 Jürgen Katins
Der Copyright-Eigner stellt folgende Lizenzen zur Verfügung:
Nicht-freie Lizenz:
This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/). Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.
Freie Lizenz:
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".