
During your first week in a programming course (or the second semester
if it was a party school), you may have had to write code to swap the
values in two variables:
int a = 1;
int b = 2;
int temp;
temp = a;
a = b;
b = temp;

You can do this much more cleanly in Ruby:
Ruby assignments are effectively performed in parallel, so the values
assigned are not affected by the assignment itself. The values on the
righthand side are evaluated in the order in which they appear before any
assignment is made to variables or attributes on the left. A somewhat
contrived example illustrates this. The second line assigns to the
variables a , b , and c the values of the expressions
x , x+=1 , and x+=1 , respectively.
x = 0

� 
0

a, b, c = x, (x += 1), (x += 1)

� 
[0, 1, 2]

When an assignment has more than one lvalue, the assignment expression
returns an array of the rvalues.
If an assignment contains more lvalues than rvalues, the excess
lvalues are
set to nil . If a multiple assignment contains more rvalues than
lvalues, the extra rvalues are ignored. As of Ruby 1.6.2, if an
assignment has one lvalue and multiple rvalues, the rvalues are
converted to an array and assigned to the lvalue.
You can collapse and expand arrays using Ruby's parallel assignment
operator. If the last lvalue is preceded by an asterisk, all the
remaining rvalues will be collected and assigned to that lvalue as an
array. Similarly, if the last rvalue is an array, you can prefix it
with an asterisk, which effectively expands it into its constituent
values in place. (This is not necessary if the rvalue is the only
thing on the righthand sidethe array will be expanded
automatically.)
a = [1, 2, 3, 4]

b, c = a 
� 
b == 1, 
c == 2 
b, *c = a 
� 
b == 1, 
c == [2, 3, 4] 
b, c = 99, a 
� 
b == 99, 
c == [1, 2, 3, 4] 
b, *c = 99, a 
� 
b == 99, 
c == [[1, 2, 3, 4]] 
b, c = 99, *a 
� 
b == 99, 
c == 1 
b, *c = 99, *a 
� 
b == 99, 
c == [1, 2, 3, 4] 

