|
Als Schlüsselwort oder Reserviertes Wort bezeichnet man einen Ausdruck, der eine eigene Bedeutung hat und nicht als Variablen-, Methoden-, Klassen-, Modul- oder Konstantenname verwendet werden kann. Die Schlüsselwörter in Ruby sind:
1
2
3
4
5
|
def hello
puts "Hello world!"
end
alias greet hello
greet #=> Hello world! |
- and
- Ein logischer Operator, der Ausdrücke verknüpft. Er entspricht der Kurzforn &&, hat aber eine niedrigere Priorität.
1
2
3
|
if a && b or c && !a and d
#Entspricht
if ((a and b) or (c and (not a))) and d |
- begin
- BEGIN
- Enthält einen Codeblock, der vor allem anderen im Programm ausgeführt wird.
1
2
|
puts "a"
BEGIN{puts "Anfang!"} |
Output:
1
2
3
4
5
6
|
x = 1
loop do
break if x >= 5
x += 2
end
puts x #=> 5 |
1
2
3
4
5
6
|
case x
when 1 then "x war 1"
when 2 then "x war 2"
else
"x war was anderes."
end |
1
2
3
4
5
6
|
class A
def inspect
puts "'Ne Instanz von A"
end
end
p A.new #=> 'Ne Instanz von A |
1
2
3
|
def foo
puts "Hello world!"
end |
|
defined? Kernel #=> constant |
- do
- Leitet einen Codeblock ein. Entspricht {.
1
2
3
4
5
|
loop do
break
end
#Gleich wie
loop{break} |
- else
- Teil des if- oder case-Blocks. Wenn alle Bedingungen fehlgeschlagen sind, wird der else-Teil ausgeführt.
1
2
3
4
5
6
7
8
9
10
|
if a == 1
puts 1
else
puts Math::E
end
case b
when 1 then puts 1
else puts Math::E
end |
- elsif
- Teil des if-Blocks. Wenn die vorige Bedingung false war, wird der folgende elsif-Teil ausgewertet.
1
2
3
4
5
6
7
|
if a == 1
puts 1
elsif u == "i"
puts "i"
elsif xy =~ /abc/
puts "abc"
end |
- end
- Ende eines Codeblocks. Im Falle von do..end entspricht es }.
1
2
3
4
5
6
7
8
|
loop{break}
#Gleich wie
loop do
end
def a
puts "a"
end |
- END
- Enthält einen Codeblock, der nach Abschluss aller anderen Operationen kurz vor Beenden des Programms ausgeführt wird.
1
2
|
END{puts "Ende!"}
puts "b" |
Output:
1
2
3
4
5
|
begin
raise "???"
ensure
puts "..."
end |
Output:
- false
- Pseudovariable und einzige Instanz von FalseClass. Boolescher Operator. Achtung! Entspricht nicht 0!
- for
- Beginn der for..in-Schleife. Entspricht in den meisten Fällen der Iteration mit each.
1
2
3
4
5
|
ary = [1, 2, 3]
for i in ary
print i, ", "
end
#=> 1, 2, 3 |
- if
- Start des if/elsif/else-Bedingungsblocks. Wertet einen Ausdruck aus, wenn er true ist, wird der zugehörige Codeblock ausgeführt.
1
2
3
4
5
|
ary = [1, 2, 3]
for i in ary
print i, ", "
end
#=> 1, 2, 3 |
- next
- Unterbricht die Ausführung einer Schleife und führt die nächste Auswertung der Schleifenbedingung durch.
|
10.times{|zahl| next if zahl % 2 == 0} |
- nil
- Steht für "Gar nichts". Pseudovariable, einzige Instanz von NilClass. Ist immer false.
|
unless nil then puts "False oder nil!" end #=> False oder nil! |
- not
- Negiert den folgenden Ausdruck. Entspricht der Kurzform !.
- or
- Ein logischer Operator, der Ausdrücke verknüpft. Entspricht der Kurzform ||, hat aber eine niedrigere Priorität. Für ein Codebeispiel, siehe and weiter oben.
- redo
- Läuft die aktuelle "Runde" einer Schleife noch einmal durch.
1
2
3
4
5
6
|
x = 1
10.times do
x += 1
redo if x.odd?
end
puts x #=> 20 |
- rescue
- Teil des begin/rescue-Blocks. Wird innerhalb eines begin-Blocks eine Exception geworfen, kann diese mit rescue aufgefangen werden, sodass das Programm nicht sofort abbricht.
1
2
3
4
5
|
begin
raise(TypeError, "TypeError")
rescue TypeError
puts "TypeError abgefangen"
end |
- retry
- Teil des begin/rescue-Blocks. Wird innerhalb des rescue-Blocks retry aufgerufen, wird der begin-Block wiederholt.
1
2
3
4
5
6
7
8
9
10
11
|
x = false
begin
if x
puts "Kein Problem"
else
raise(TypeError)
end
rescue TypeError
x = true
retry
end |
- return
- Beendet eine Methode und gibt den ihm mitgegebenen Wert zurück. Wird return kein Wert zugeordnet, wird der letzte in der Methode zurückgegebene Wert verwendet.
1
2
3
4
5
6
|
def a
return "a"
#Das hier wird nie durchlaufen:
puts "b"
end
puts a #=> a |
- self
- Verweis auf das aktuell agierende Objekt.
1
2
3
4
5
6
|
class A
def b
puts self
end
end
A.new.b #=> <A:ObjectId> |
- super
- Führt die gleichnamige Methode der Superklasse aus, und übergibt ihr dabei standardmäßig die Argumente der Childmethode. Um dies zu ändern, können super Argumente mitgegeben werden.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class Superclass
def foo(arg)
puts arg
end
end
class Subclass1 < Superclass
def foo(arg)
super
end
end
class Subclass2 < Superclass
def foo(arg)
super("ABC")
end
end
x = Subclass1.new
y = Subclass2.new
x.foo("XYZ") #=> XYZ
y.foo("ÄÖÜ") #=> ABC |
- then
- Teil der if/elsif/else/end-Anweisung und des case-Blocks. Kann weggelassen werden, wenn die Anweisung nicht in einer Zeile steht.
1
2
3
4
5
6
7
|
if x then
puts x
end
#Gleich wie
if x
puts x
end |
- true
- Pseudovariable und einzige Instanz von TrueClass. Boolescher Operator. Achtung! Jedes Objekt in Ruby (außer nil und false) ist automatisch true, sodass es zwar 1 entspricht, aber ebenso 0.
- undef
- Gegenteil von def. Entfernt eine bereits definierte Methode.
1
2
3
4
5
6
|
def foo
puts "Hello"
end
foo #=> Hello
undef foo
foo #=> NameError |
- unless
- Entspricht dem Aufruf eines if-Blocks mit
if not.
1
2
3
4
5
6
7
|
unless x
puts "Nix x!"
end
#Gleich wie
if not x
puts "Nix x!"
end |
- until
- Anfang der until-Schleife. Wird der Ausdruck true, endet die Schleife.
1
2
3
4
5
|
x = 1
until x > 2
x += 1
end
puts x #=> 3 |
1
2
3
4
|
case x
when 1 then puts "x war 1"
when 2 then puts "x war 2"
end |
- while
- Beginn der while-Schleife. Solange der Ausdruck true ist, läuft die Schleife. Für Endlosschleifen kann man auch den Iterator loop benutzen.
1
2
3
4
5
|
x = 1
while x < 3
x += 1
end
puts x #=> 2 |
- yield
- Führt den Codeblock einer Iteratormethode aus. yield können Argumente mitgegeben werden, die dann als Blockargumente in der Methode auftauchen. Wirft einen LocalJumpError, falls der Methode kein Codeblock mitgegeben wurde.
1
2
3
4
|
def foo
yield
end
foo{puts "a"} #=> a |
- __FILE__
- Pseudovariable, die den Pfad zum aktuell laufenden Programm enthält. Nicht zu verwechseln mit $0!
- __LINE__
|
|
