ruby-mine

Da Fragen aufgetaucht sind, beleuchten wir das neue Feature von Ruby 1.9 mal genauer. Nehmen wir uns eine Funktion, die alle möglichen Arten von Argumenten hat:

def foo(a, b = :default1, c = :default2, *d, e, &f)
  [a, b, c, d, e, f]
end

Die Regeln

• Es gibt vier Arten von Argumenten, und zwar:
  • Pflichtargumente (ohne Präfix), hier: a und e
  • Optionale Argumente (mit Standardwert, arg=value), hier: b und c
  • Rest-Argumente (“catch-all”, mit *-Präfix), hier: d
  • Block-Argumente (mit &-Präfix, verhalten sich wie optionale Argumente), hier: f

Wichtig: Keines dieser Argumente hat etwas mit der offenen Hash-Notation (BluesBrother.find :all, :limit => 2) zu tun. Das ist einfach nur das letzte Argument, was übergeben wird. Wo es landet, bestimmt die Signatur.

Pflichtargumente müssen immer angegeben werden, und werden der Reihe nach – von links nach rechts – zugewiesen. foo hat 2 Pflichtargumente; wenn man die Methode mit weniger Argumenten aufruft, gibt es einen ArgumentError:

foo 1  # => ArgumentError

Übergibt man exakt die Mindestanzahl an Argumenten, erhalten alle optionalen Argumente ihren Standardwert, das Rest-Argument erhält [], und die Pflichtargumente werden von links nach rechts und (neu) von rechts nach links zugewiesen (je nachdem, ob sie vor oder nach den optionalen Argumenten stehen):

foo 1, 2                    # => [1, :default1, :default2, [], 2, nil]

Wenn mehr Argumente angegeben werden, als es Pflichtargumente gibt, werden die optionalen Argumente von links nach rechts zugewiesen; verbleibende optionale Argumente erhalten ihren Standardwert, und das Rest-Argument erhält wieder []:

foo 1, 2                    # => [1, :default1, :default2, [], 2, nil]
foo 1, 2, 3                 # => [1, 2, :default2, [], 3, nil]
foo 1, 2, 3, 4              # => [1, 2, 3, [], 4, nil]

e, das letzte Pflichtargument, erhält also immer den letzten Wert.

Sind dann immer noch Argumente übrig, landen sie der Reihe nach im Rest-Argument:

foo 1, 2, 3, 4, 5           # => [1, 2, 3, [4], 5, nil]
foo 1, 2, 3, 4, 5, 6        # => [1, 2, 3, [4, 5], 6, nil]

Ein Block-Argument ist immer ein optionales Argument (Standardwert: nil), das den Block enthält, wenn einer angegeben wurde. Es muss immer am Ende stehen, sowohl in der Methodensignatur als auch beim Aufruf. Übergeben kann man es entweder mit {}/do…end oder mit dem &-Präfix.

foo 1 {} rescue ArgumentError   # => ArgumentError
foo 1, 2                    {}  # => [1, :default1, :default2, [], 2, #<Proc:0x3d101c@-:15>]
foo 1, 2, 3                 {}  # => [1, 2, :default2, [], 3, #<Proc:0x3d0d74@-:16>]
foo 1, 2, 3, 4              {}  # => [1, 2, 3, [], 4, #<Proc:0x3d0ae0@-:17>]
foo 1, 2, 3, 4, 5           {}  # => [1, 2, 3, [4], 5, #<Proc:0x3d084c@-:18>]
foo 1, 2, 3, 4, 5, 6        {}  # => [1, 2, 3, [4, 5], 6, #<Proc:0x3d05a4@-:19>]

Einschränkungen

• Die Reihenfolge ist fest:
  1. beliebig viele Pflichtargumente
  2. beliebig viele optionale Argumente
  3. maximal ein Rest-Argument
  4. beliebig viele Pflichtargumente (neu)
  5. maximal ein Block-Argument
• Block-Argumente können keinen Standardwert haben.
• Die Pflichtargumente am Ende der Signatur können nicht zur Berechnung von Standardwerten benutzt werden. Das ist so gewollt.