Die Programmiersprache Ruby

Blog| Forum| Wiki  

Als String bezeichnet man eine Kette von Zeichen wie Buchstaben, Zahlen und ähnliche. Diese Zeichen müssen nicht zwangsläufig einen Sinn ergeben, ihre bloße Aneinanderreihung (oder sogar ein einzelnes Zeichen) ist bereits ein String: Der Datentyp String repräsentiert diese Zeichen(-ketten).

1
2
3
4
5
6
"Ich bin ein String!"
'Ich bin ein String!'
String.new("Ich bin ein String!")
String.new('Ich bin ein String')
%q{Ich bin ein String in einfachen Anf��hrungszeichen!}
%Q{Ich bin ein String in doppelten Anf��hrungszeichen!}

Der String ist einer der Grunddatentypen einer jeden Programmiersprache. Viele Sprachen behandeln ihn auch so, stehen ihm nur diesen kleinen Status als sog. "Primitiven Datentypen" zu. Da es in Ruby keine solchen Datentypen gibt und auch ein String als vollwertiges Objekt betrachtet wird, beherrschen auch Strings Methoden:

"Ich bin ein String!".split(/\s+/) #=> ["Ich", "bin", "ein", "String!"]


Inhaltsverzeichnis

Strings als Objektbeschreiber

Strings dienen außerdem zur Beschreibung von Objekten. In der Regel besitzt jedes Ruby-Objekt einen es näher beschreibenden String, welcher durch den Aufruf der Methode inspect abgerufen werden kann. Eigene Klassen müssen diese Methode, die bereits von Object definiert wird, überschreiben, um einen vernünftigen Rückgabewert zu erhalten. Standardmäßigerweise ruft Object#inspect nämlich nur die to_s-Methode des Objekts auf. Diese beiden Methoden können dabei sehr unterschiedlich ausfallen.

1
2
[1, 2, 3].to_s #=> 123
[1, 2, 3].inspect #=> [1, 2, 3]


Einbinden anderer Objekte in Strings

Substitution

Oft stellt sich auch die Frage, wie Strings mit anderen Objekten interagieren, wenn z.B. eine Zahl in einen String eingebunden werden soll. In Ruby ist das kein Problem, normalerweise ist die Konvertierungsmethode to_s unnötig, denn man kann jedes Objekt einfach in einen String hineinsubstituieren[1]:

1
2
3
x = 5
puts "Der Wert der Variablen 'x' war: #{x}."
#=> Der Wert der Variablen 'x' war: 5.

Format-Strings

Ferner unterstützt Ruby Format-Strings wie z.B. C:

1
2
3
4
x = 5
printf("Der Wert der Variablen 'x' war: %i", x) #=> Der Wert der Variablen 'x' war: 5
#Oder mithilfe des %-Operators: 
puts "Der Wert der Variablen 'x' war: %i" % x

ERB-Templates

Noch eine andere, html-artige Möglichkeit stellen ERB-Templates da, welche zum Beispiel in Rails häufig verwendet werden und Variablen auch schon vor deren erstmaliger Verwendung annehmen:

1
2
3
4
5
require "erb"
template = ERB.new("Der Wert der Variablen 'y' war <%= y %>.") #y ist hier noch nicht definiert worden!
y = 7
puts template.result
#=> Der Wert der Variablen 'y' war 7.

Mathematisch

Oder man addiert einfach einen (konvertierten) Wert zu einem String dazu.

"Das sind " + 3.to_s + " Teilst��cke!" #=> Das sind 3 Teilst��cke!

Achtung! Strings werden in mathematischen Operationen NICHT als Zahlen behandelt!

1
2
3
4
5
6
1 + "2" #=> TypeError: can't convert Fixnum into String
1 + "2".to_i #=> 3
#to_i behandelt alles au��er Zahlen allerdings als Null: 
"A".to_i + 2 #=> 2
#F��r solche F��lle sollte man Kernel#Integer benutzen: 
Integer("A") + 2 #=> ArgumentError: invalid value for Integer: "A"


Heredocs

Sie sind einzigartig in Ruby: Heredocs. Diese besonderen Strings verlaufen vertikal und bestehen aus zwei Teilen. Ein Heredoc kann definiert werden, indem man << gefolgt von einem Wort, das den String am Ende auch begrenzt, schreibt. Dabei kann man in einem Heredoc sowohl Strings in einfachen, wie auch in doppelten Anführungsstrichen und sogar als Backticks definieren.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
x = 1
#Folgendes steht in doppelten Anf��hrungszeichen. 
string =<<Gedicht if x == 1
Dunkel war's
der Mond schien helle, 
als ein Auto blitzeschnelle
langsam um die grade Ecke bog.
Gedicht

string =<<'EOF'
Das hier
steht in einfachen
Anf��hrungsstrichen. 
EOF

string =<<"EOF"
Das hier 
steht in 
doppelten Anf��hrungszeichen. 
EOF

string =<<`EOF`
Das hier ist ein 
sehr langer System-
befehl. 
EOF


Sonderzeichen

Eine andere bekannte Sache sind Sonderzeichen. Ein Ruby-String nimmt grundsätzlich eigentlich jedes Zeichen an; nur muss man dem Interpreter klar machen, dass zum Beispiel mit "\" jetzt kein Extrabefehl eingeleitet wird, sondern, dass er es als Zeichen behandeln soll. Das kann man auf verschiedene Art und Weise erreichen:

1
2
3
4
5
6
7
8
9
10
"Dieser Backslash \ wird ignoriert." #=> Dieser Backslash  wird ignoriert.
"Dieser Backslash \n ist ein Sonderzeichen."
#=> Dieser Backslash 
#=> ist ein Sonderzeichen. 
"Dieser Backslash \\ wird als solcher angezeigt." #=> Dieser Backslash \ wird als solcher angezeigt.
#Die meisten Backslash-Sonderbefehle werden in Strings mit einfachen Anf��hrungszeichen ignoriert: 
'Backslash \n 1.' #=> Backslash \n 1.
"Backslash \n 2."
#=> Backslash 
#=> 2.


String#unpack

Für Binärsequenzen gibt es in Ruby keine eigene Klasse. Deshalb werden sie in Strings dargestellt. String besitzt die Methode unpack, welche den Inhalt einer solchen Binärsequenz anhand des ihr mitgegebenen Format-Strings bestimmt. Das Gegenstück zu dieser Methode, also das Erstellen einer Binärsequenz, ist Array#pack, welches genau die selben Parameter annimmt.

Teile von Strings

Referenziert man Teile von Strings, sollte man vorsichtig sein. Ruby speichert (in der Version 1.8.6) Strings intern als Folgen von Bytes; normalerweise kommt dies nicht zum Ausdruck, aber wenn man Methoden wie String#[] verwendet, erhält man nicht sofort ein Zeichen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
"ABC"[1] #=> 66
"ABC"[1, 1] #=> B
x = 0
"ABC".each do |z|
  puts z
  x += 1
end
#=> ABC
puts x #=> 1
#Der String ist als Ganzes behandelt worden!
x = 0
"ABC".each_byte do |b|
  puts b.chr
  x+= 1
end
#=>A
#=>B
#=>C
puts x #=> 3
#Um die einzelnen Teile des Strings zu behandeln, muss ��ber die Bytes iteriert werden.

ASCII-Werte von Zeichen

Ruby bietet zwei Möglichkeiten, den ASCII-Wert eines Zeichens zu ermitteln, und eine Methode, um einen ASCII-Wert in sein Zeichen umzuwandeln.

1
2
3
4
5
6
#In der Version 1.8.6 werden, wie ja schon weiter oben erw��hnt, per [] ASCII-Werte abgegriffen: 
puts "F"[0] #=> 70
#Daneben gibt es die Literalm��glichkeit: 
puts ?F #=> 70
#Andere Richtung: 
puts 70.chr #=> F

Änderungen an der Klasse String zu Ruby 1.9.1

puts "��" #=> invalid multibyte char (US-ASCII)
  • Das Encoding eines einzelnen Strings kann verändert werden:
"abc".encode("Windows-1252")
  • Das Literal ? gibt nicht mehr den ASCII-Wert zurück, stattdessen muss String#ord verwendet werden.
1
2
puts ?F #=> F
puts "F".ord #=> 70
  • String#each wurde entfernt. Stattdessen wurde String#each_char hinzugefügt. each_byte ist nach wie vor vorhanden.
1
2
3
4
"abc".each_char{|c| puts c}
#=> a
#=> b
#=> c
  • Alle Methoden, die bisher den ASCII-Wert eines Zeichens zurückgaben, geben jetzt ein Zeichen zurück:
puts "abc"[0] #=> a


Fußnoten

  • [1]Tatsächlich ruft die Substitutionsmethode per #{..} die to_s-Methode des Rückgabewerts aus dem Code in den geschweiften Klammern auf.

Siehe auch