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.gif) ![[visible space]](visible_space.gif) : 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.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) hello![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) " |
|
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:
|
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''.
|
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.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) " |
|
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.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) ![[visible space]](visible_space.gif) 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 ` ' 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.
|
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
|
|