Syntax Spezialitäten erläutert

unless

Äquivalent zu

if not

@

Bezeichner für eine Instanzvariable oder Methodenname eines unären Operators.

1
2
3

def register_observer(observer)
  @observers.push observer
end

Ein Beispiel für den unären Operator gibt es unter Pitfalls.

$

Bezeichner für eine globale Variable.

||= (oder gleich)

1
2
3
4

# Abkuerzung für "variable = ... unless variable"
vorname    = "Richard"
vorname  ||= "Schmitz" # vorname bleibt "Richard"
nachname ||= "Schmitz" # nachname war bislang nil, deshalb jetzt "Schmitz"

Am gebräuchlichsten ist wohl die Verwendung in Modulen, wenn die Initialisierung von Instanzvariablen nicht oder nur mit Verrenkungen bei der Instanzierung sichergestellt werden kann:

1
2
3
4
5
6

module ObserveAable
  def notify_observers
   @observers ||=[] # sicherstellen das @observers nicht nil ist
   @observers.each {|observer| observer.update } 
  end
end

Doppelpunkt

Erstellt ein Symbol. Der Symbolstring kann als interpolierter String geschrieben werden, um Ersetzungen zu ermöglichen oder Sonderzeichen zu escapen.

1
2
3

a = :foobar
b = :"#{a}\n"
:"foobar\n" == b

[]

Das Literal für Arrays. Verhält sich wie Array.new, führt aber nicht zu einem Aufruf von Array.new und Array#initialize.

[1,2,3,4] == Array.new(1,2,3,4) # => true

{}

Entweder das Literal für Hashes. Verhält sich wie Array.new, führt aber nicht zu einem Aufruf von Hash.new und Hash#initialize.

{:name => "Richard",:alter=> 6} == Hash.new(:name => "Richard", :alter => 6) # => true

oder begrenzen Blöcke, ähnlich do ... end. Klammern haben jedoch eine höhere Präzedenz.

array.each { |element| puts element }

* und & In Methodendeklarationen

1
2
3
4
5
6
7
8
9

def foo(*bar) # alle mit komma separierten parameter werden beim Aufruf in ein Array verpackt
  p bar
end
foo(1,2,3,4,5,6,7) # => [1,2,3,4,5,6,7]
def foo(&block) # Parameter der mit & beginnt bezeichnet das mit einem Block übergebene Proc-Object
  puts block.arity?
  block.call
end
foo { puts "block_called" } # => 0, "block_called"

 ! und ? in Methodendennamen

• ! Bezeichnet Methoden "die etwas verändern" anstatt nur Werte zurückzugeben. Die Verwendung nicht zwingend, aber bei eigenen Methodendefinitionen sollte man sich daran halten

1
2
3
4
5
6
7
8

# mit Ausrufezeichen
array.reject! { |e| e <= 2 } # => [3,4]
array # => [3,4]

# ohne Ausrufezeichen
array = [1,2,3,4]
array.reject { |e| e <= 2 }  # => [3,4]
array # => [1,2,3,4]

• ? Bezeichnet Methoden die true oder false zurückgeben. Ebenfalls eine Konvention an die man sich halten sollte.

array.empty? # true or false

->(a,b) (Ruby 1.9)

Das Literal für anonyme Funktionen, auch "Picky Lambda" genannt. Folgende Ausdrücke sind äquivalent:

1
2
3

->(a,b){ puts a, b }

lambda {|a,b| puts a, b }

Wie auch [] und {} führt -> jedoch nicht zum Aufruf der Methode Kernel#lambda.

.() (Ruby 1.9)

Alias für #call, der Methode zum Aufrufen einer anonymen Funktion:

1
2
3
4
5
6
7

class A
  def call(a,b)
    [a,b]
  end
end

A.new.(1,2) #=> [a, b]

Von der Verwendung ist abzuraten, da es ausser 4 gesparten Zeichen keinerlei Vorteile bringt und eine Inkompatibilität zu 1.8 einführt.

Siehe auch

• Pitfalls
• Tricks