Die Programmiersprache Ruby

Blog| Forum| Wiki  

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
Anfang!
a
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
b
Ende!
1
2
3
4
5
begin
  raise "???"
ensure
  puts "..."
end

Output:

1
2
...
???
  • 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
if a
  puts a
end
1
2
3
4
5
ary = [1, 2, 3]
for i in ary
  print i, ", "
end
#=> 1, 2, 3
1
2
module MeinModul
end
  • 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
  • when
    • Teil des case-Blocks.
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__