Die Programmiersprache Ruby (German Edition)

einzelnen Lvalues zugewiesen, und die restlichen Rvalues werden verworfen:
x, y = 1, 2, 3 # x=1; y=2; 3 wird nirgendwo zugewiesen.
    4.5.5.5 Der Splat-Operator
    Wenn einem Rvalue ein Sternchen vorangestellt wird, bedeutet das, dass der Wert ein Array (oder ein Array-artiges Objekt) ist, und dass jedes seiner Elemente ein Rvalue sein soll. Die Array-Elemente ersetzen das Array in der ursprünglichen Liste der Rvalues, und die Wertzuweisung erfolgt wie oben beschrieben:
x, y, z = 1, *[2,3] # Dasselbe wie x,y,z = 1,2,3
    In Ruby 1.8 darf ein Splat nur vor dem letzten Rvalue in einer Wertzuweisung stehen. In Ruby 1.9 darf die Liste der Rvalues eine beliebige Anzahl von Splats enthalten, und sie dürfen an jeder beliebigen Position in der Liste vorkommen. Es ist jedoch in keiner Version der Sprache erlaubt, einen »doppelten Splat« für ein verschachteltes Array zu probieren:
x,y = **[[1,2]] # SyntaxError!
    In Ruby 1.8 kann der Splat-Operator für Array-, Range- und Hash-Rvalues eingesetzt werden. In Ruby 1.9 können Array-, Range- und Enumerator-Rvalues (siehe „5.3.4 Enumeratoren“ ) damit behandelt werden. Wenn Sie einen Splat auf einen Wert einer anderen Klasse anwenden, bleibt der Wert einfach bestehen. Sie können Ihre eigenen Splat-fähigen Klassen definieren. Definieren Sie in Ruby 1.8 eine
to_ary
-Methode, die ein Array von Werten zurückliefert. In Ruby 1.9 müssen Sie die Methode stattdessen
to_splat
nennen.
    Wird einem Lvalue ein Sternchen vorangestellt, dann bedeutet das, dass alle verbleibenden Rvalues in einem Array platziert und diesem Lvalue zugewiesen werden sollen. Der Wert, der diesem Lvalue zugewiesen wird, ist stets ein Array, das keine, ein oder mehrere Elemente enthalten kann:
x,*y = 1, 2, 3 # x=1; y=[2,3]
x,*y = 1, 2 # x=1; y=[2]
x,*y = 1 # x=1; y=[]
    In Ruby 1.8 darf ein Splat nur vor dem letzten Lvalue in der Liste stehen. Auch in Ruby 1.9 darf die linke Seite einer parallelen Wertzuweisung nur einen Splat-Operator enthalten, aber er darf an einer beliebigen Position in der Liste vorkommen:
# Nur Ruby 1.9
*x,y = 1, 2, 3 # x=[1,2]; y=3
*x,y = 1, 2 # x=[1]; y=2
*x,y = 1 # x=[]; y=1
    Beachten Sie, dass Splats auf beiden Seiten eines parallelen Wertzuweisungsausdrucks vorkommen können:
x, y, *z = 1, *[2,3,4] # x=1; y=2; z=[3,4].
    Erinnern Sie sich schließlich daran, dass wir weiter oben zwei einfache Fälle der parallelen Wertzuweisung mit einem einzelnen Lvalue sowie mit einem einzelnen Rvalue beschrieben haben. Beachten Sie, dass beide Fälle sich genauso verhalten, als stünde ein Splat vor dem einzelnen Lvalue beziehungsweise Rvalue. Das explizite Hinzufügen eines Splat hat in diesen Fällen keine zusätzliche Wirkung.
    4.5.5.6 Klammern in der parallelen Wertzuweisung
    Eines der am am schwersten zu verstehenden Features der parallelen Wertzuweisung ist die Tatsache, dass die linke Seite Klammern für »Unterzuweisungen« verwenden kann. Wenn eine Gruppe von zwei oder mehr Lvalues von Klammern umschlossen wird, dann wird sie zunächst als einzelner Wert behandelt. Nachdem der entsprechende Rvalue bestimmt ist, werden die Regeln der parallelen Wertzuweisung rekursiv angewendet – dieser Rvalue wird der Gruppe von Lvalues in den Klammern zugwiesen. Betrachten Sie die folgende Wertzuweisung:
x,(y,z) = a, b
    Dies sind effektiv zwei Wertzuweisungen, die zur selben Zeit ausgeführt werden:
x = a
y,z = b
    Aber beachten Sie, dass die zweite Wertzuweisung selbst eine parallele Zuweisung ist. Da Sie auf der linken Seite Klammern benutzt haben, wird eine rekursive parallele Wertzuweisung ausgeführt. Damit diese funktioniert, muss
b
ein Splat-fähiges Objekt wie etwa ein Array oder ein Enumerator sein.
    Es folgen einige konkrete Beispiele, die das verdeutlichen. Beachten Sie, dass Klammern auf der linken Seite eine Ebene eines verschachtelten Array auf der linken »auspacken«:
x,y,z = 1,[2,3] # Keine Klammern: x=1;y=[2,3];z=nil
x,(y,z) = 1,[2,3] # Klammern: x=1;y=2;z=3
a,b,c,d = [1,[2,[3,4]]] # Keine Klammern: a=1;b=[2,[3,4]];c=d=nil
a,(b,(c,d)) = [1,[2,[3,4]]] # Klammern: a=1;b=2;c=3;d=4
    ----
    Parallele Wertzuweisung und Methodenaufruf
    Beachten Sie nebenbei folgenden Hinweis: Wenn einer parallelen Wertzuweisung der Name einer Methode vorangestellt wird, interpretiert der Ruby-Interpreter die Kommata als Methodenargument-Trennzeichen statt als Lvalue- und Rvalue-Trennzeichen. Wenn Sie den Rückgabewert einer parallelen Wertzuweisung überprüfen möchten, könnten Sie folgenden Code schreiben, um