Die Programmiersprache Ruby (German Edition)

Array zugewiesen.
    Der abgekürzte Wertzuweisungsoperator
||=
verhält sich eigentlich etwas anders als die hier gezeigte Langfassung. Wenn der Lvalue von
||=
nicht
nil
oder
false
ist, wird in Wirklichkeit keine Wertzuweisung ausgeführt. Wenn der Lvalue ein Attribut oder ein Array-Element ist, wird die Setter-Methode, die die Wertzuweisung ausführt, nicht aufgerufen.
    ----
    Tabelle 4.1 Pseudooperatoren für die abgekürzte Wertzuweisung
    Wertzuweisung
Langform
x += y
x = x + y
x -= y
x = x – y
x *= y
x = x * y
x /= y
x = x / y
x %= y
x = x % y
x **= y
x = x ** y
x &&= y
x = x && y
x ||= y
x = x || y
x &= y
x = x & y
x |= y
x = x | y
x ^= y
x = x ^ y
x <<= y
x = x << y
x >>= y
x = x >> y
    4.5.5 Parallele Wertzuweisung
    Parallele Wertzuweisung ist jeder Wertzuweisungsausdruck, der mehr als einen Lvalue, mehr als einen Rvalue oder beides besitzt. Mehrere Lvalues und mehrere Rvalues werden durch Kommata voneinander getrennt. Lvalues und Rvalues können ein
*
als Präfix erhalten, das manchmal als Splat-Operator bezeichnet wird, obwohl es kein echter Operator ist. Die Bedeutung von
*
wird weiter unten in diesem Abschnitt erläutert.
    Die meisten parallelen Wertzuweisungsausdrücke sind einfach, und es ist offensichtlich, was sie bedeuten. Es gibt jedoch auch einige komplizierte Fälle, und die nachfolgenden Unterabschnitte erläutern alle Möglichkeiten.
    4.5.5.1 Dieselbe Anzahl von Lvalues und Rvalues
    Parallele Wertzuweisung ist am einfachsten, wenn die Anzahl der Lvalues und Rvalues identisch ist:
x, y, z = 1, 2, 3 # x=1; y=2; z=3
    In diesem Fall wird der erste Rvalue dem ersten Lvalue zugewiesen, der zweite Rvalue dem zweiten Lvalue und so weiter.
    Die Wertzuweisungen werden tatsächlich parallel ausgeführt, nicht nacheinander. Die beiden folgenden Zeilen sind beispielsweise nicht identisch:
x,y = y,x # Parallel: Wert der beiden Variablen vertauschen.
x = y; y = x # Sequentiell: Beide Variablen haben denselben Wert.
    4.5.5.2 Ein Lvalue, mehrere Rvalues
    Bei einem einzelnen Lvalue und mehreren Rvalues erzeugt Ruby ein Array, das die Rvalues enthält, und weist dem Lvalue dieses Array zu:
x = 1, 2, 3 # x = [1,2,3]
    Sie können ein
*
vor dem Lvalue platzieren, ohne die Bedeutung oder den Rückgabewert dieser Wertzuweisung zu ändern.
    Wenn Sie verhindern möchten, dass die Rvalues zu einem einzelnen Array kombiniert werden, setzen Sie ein Komma hinter den Lvalue. Sogar ohne Lvalue hinter dem Komma sorgt dies dafür, dass Ruby sich so verhält, als seien mehrere Lvalues vorhanden:
x, = 1, 2, 3 # x = 1; restliche Werte werden verworfen.
    4.5.5.3 Mehrere Lvalues, ein einzelner Array-Rvalue
    Bei mehreren Lvalues und nur einem einzelnen Rvalue versucht Ruby, den Rvalue zu einer Liste zuzuweisender Werte zu erweitern. Wenn der Rvalue ein Array ist, entpackt Ruby das Array, so dass jedes Element zu einem eigenen Rvalue wird. Wenn der Rvalue kein Array ist, sondern eine
to_ary
-Methode implementiert, ruft Ruby diese Methode auf und entpackt dann das Array, das sie zurückliefert:
x, y, z = [1, 2, 3] # Dasselbe wie x,y,z = 1,2,3
    Die parallele Wertzuweisung wurde so umgewandelt, dass es mehrere Lvalues und keinen (wenn das entpackte Array leer war) oder mehrere Rvalues gibt. Wenn die Anzahl der Lvalues und Rvalues identisch ist, dann findet die Wertzuweisung so statt wie oben unter „4.5.5.4 Unterschiedliche Anzahl von Lvalues und Rvalues“ beschrieben. Wenn die Anzahl unterschiedlich ist, wird die Wertzuweisung durchgeführt wie weiter unten in „4.5.5.4 Unterschiedliche Anzahl von Lvalues und Rvalues“ beschrieben.
    Wir können den oben beschriebenen Trick mit dem abschließenden Komma einsetzen, um eine einfache, nicht parallele Wertzuweisung in eine parallele Wertzuweisung umzuwandeln, die ein Array auf der rechten Seite automatisch auspackt:
x = [1,2] # x wird [1,2]: keine parallele Zuweisung
x, = [1,2] # x wird 1: parallel durch abschließendes Komma
    4.5.5.4 Unterschiedliche Anzahl von Lvalues und Rvalues
    Wenn es mehr Lvalues als Rvalues gibt und kein Splat-Operator verwendet wird, wird der erste Rvalue dem ersten Lvalue zugewiesen, der zweite Rvalue dem zweiten Lvalue und so weiter, bis alle Rvalues zugewiesen wurden. Danach wird jedem der verbleibenden Lvalues
nil
zugewiesen, wobei ein gegebenenfalls existierender Wert des jeweiligen Lvalue überschrieben wird:
x, y, z = 1, 2 # x=1; y=2; z=nil
    Wenn es mehr Rvalues als Lvalues gibt und kein Splat-Operator verwendet wird, dann werden Rvalues der Reihe nach den