ruby multiple variable assignment

Ruby 2.7 Reference SAVE UKRAINE

In Ruby, assignment uses the = (equals sign) character. This example assigns the number five to the local variable v :

Assignment creates a local variable if the variable was not previously referenced.

Abbreviated Assignment

You can mix several of the operators and assignment. To add 1 to an object you can write:

This is equivalent to:

You can use the following operators this way: + , - , * , / , % , ** , & , | , ^ , << , >>

There are also ||= and &&= . The former makes an assignment if the value was nil or false while the latter makes an assignment if the value was not nil or false .

Here is an example:

Note that these two operators behave more like a || a = 0 than a = a || 0 .

Multiple Assignment

You can assign multiple values on the right-hand side to multiple variables:

In the following sections any place “variable” is used an assignment method, instance, class or global will also work:

You can use multiple assignment to swap two values in-place:

If you have more values on the right hand side of the assignment than variables on the left hand side, the extra values are ignored:

You can use * to gather extra values on the right-hand side of the assignment.

The * can appear anywhere on the left-hand side:

But you may only use one * in an assignment.

Array Decomposition

Like Array decomposition in method arguments you can decompose an Array during assignment using parenthesis:

You can decompose an Array as part of a larger multiple assignment:

Since each decomposition is considered its own multiple assignment you can use * to gather arguments in the decomposition:

OneBite.Dev - Coding blog in a bite size

assign multiple variables in Ruby

Code snippet on how to assign multiple variables in Ruby

This code assigns the values 10, 20, and 30, to the variables a, b and c respectively. The code can be broken down into 3 parts. The first part is the variables. The code starts with the variables a, b and c on the left side of the equals sign. These are the variables that are being set to the values on the right side of the equation. The second part is the equals sign =. This sign indicates that each of the variables on the left is being assigned to the values on the right. The third part is the values 10, 20, and 30. These are the values that are being assigned to the variables on the left. This code assigns each variable on the left a different value on the right, but the same values could be used for multiple variables if the same values are desired.

Multiple Assignment and Decomposition in

About multiple assignment and decomposition.

Decomposition refers to the act of extracting the elements of a collection, such as an Array or Hash . Decomposed values can then be assigned to variables within the same statement.

Multiple assignment is the ability to assign multiple variables to decompose values within one statement. This allows for code to be more concise and readable, and is done by separating the variables to be assigned with a comma such as first, second, third = [1, 2, 3] .

The splat operator( * ), and double splat operator, ( ** ), are often used in decomposition contexts. Splat operator, ( * ), can be used to combine multiple arrays into one array by decomposing each into a new common array . Double splat operator, ( ** ), can be used to combine multiple hashes into one hash by decomposing each into a new common hash . This is syntax used to differentiate from multiple values accepted as a positional argument, to one where we accept any/many key word arguments.

When the splat operator, ( * ), is used without a collection, it packs (or composes) a number of values into an array . This is often used in multiple assignment to group all "remaining" elements that do not have individual assignments into a single variable.

It is common in Ruby to use this decomposing/composing behavior when using or defining methods that take an arbitrary number of positional or keyword arguments. You will often see these arguments defined as def some_method(*arguments, **keyword_arguments) and the arguments used as some_method(*some_array, **some_hash) .

*<variable_name> and **<variable_name> should not be confused with * and ** . While * and ** are used for multiplication and exponentiation, respectively, *<variable_name> and **<variable_name> are used as composition and decomposition operators.

Multiple assignment

Multiple assignment allows you to assign multiple variables in one line. To separate the values, use a comma , :

Multiple assignment is not limited to one data type:

Multiple assignment can be used to swap elements in arrays . This practice is pretty common in sorting algorithms . For example:

This is also known as "Parallel Assignment", and can be used to avoid a temporary variable.

If there are more variables than values, the extra variables will be assigned nil :

If there are more values than variables, the extra values will be ignored:

Decomposition

In Ruby, it is possible to decompose the elements of arrays / hashes into distinct variables. Since values appear within arrays in a index order, they are unpacked into variables in the same order:

If there are values that are not needed then you can use _ to indicate "collected but not used":

Deep decomposing

Decomposing and assigning values from arrays inside of an array ( also known as a nested array ), works in the same way a shallow decomposing does, but needs delimited decomposition expression ( () ) to clarify the values context or position:

You can also deeply unpack just a portion of a nested array :

If the decomposition has variables with incorrect placement and/or an incorrect number of values, you will get a syntax error :

Experiment here, and you will notice that the first pattern dictates, not the available values on the right hand side. The syntax error is not tied to the data structure.

Decomposing an array with the single splat operator ( * )

When [decomposing an array ][decomposition] you can use the splat operator ( * ) to capture the "leftover" values. This is clearer than slicing the array ( which in some situations is less readable ). For example, we can extract the first element and then assign the remaining values into a new array without the first element:

We can also extract the values at the beginning and end of the array while grouping all the values in the middle:

We can also use * in deep decomposition:

Decomposing a Hash

Decomposing a hash is a bit different than decomposing an array . To be able to unpack a hash you need to convert it to an array first. Otherwise there will be no decomposing:

To coerce a Hash to an array you can use the to_a method:

If you want to unpack the keys then you can use the keys method:

If you want to unpack the values then you can use the values method:

Composition

Composing is the ability to group multiple values into one array that is assigned to a variable. This is useful when you want to decomposition values, make changes, and then composition the results back into a variable. It also makes it possible to perform merges on 2 or more arrays / hashes .

Composition an array with splat operator( * )

Composing an array can be done using the splat operator, ( * ). This will pack all the values into an array .

Composition a hash with double splat operator( ** )

Composing a hash is done by using the double splat operator( ** ). This will pack all key / value pairs from one hash into another hash, or combine two hashes together.

Usage of splat operator( * ) and double splat operator( ** ) with methods

Composition with method parameters.

When you create a method that accepts an arbitrary number of arguments, you can use *arguments or **keyword_arguments in the method definition. *arguments is used to pack an arbitrary number of positional (non-keyworded) arguments and **keyword_arguments is used to pack an arbitrary number of keyword arguments.

Usage of *arguments :

Usage of **keyword_arguments :

If the method defined does not have any defined parameters for keyword arguments( **keyword_arguments or <key_word>: <value> ) then the keyword arguments will be packed into a hash and assigned to the last parameter.

*arguments and **keyword_arguments can also be used in combination with one another:

You can also write arguments before and after *arguments to allow for specific positional arguments. This works the same way as decomposing an array.

Arguments have to be structured in a specific order:

def my_method(<positional_arguments>, *arguments, <positional_arguments>, <key-word_arguments>, **keyword_arguments)

If you don't follow this order then you will get an error.

You can write positional arguments before and after *arguments :

You can also combine positional arguments, *arguments, key-word arguments and **keyword_arguments:

Writing arguments in an incorrect order will result in an error:

Decomposing into method calls

You can use splat operator ( * ) to unpack an array of arguments into a method call:

You can also use double splat operator( ** ) to unpack a hash of arguments into a method call:

Learn Multiple Assignment and Decomposition

Ruby Quicktips

Multiple assignment.

You can assign multiple values to multiple variables like this:

F.e. this can be useful for splitting names:

Read more on assignment in Ruby .

What’s even more astonishing to me is the fact that you can easily swap two variables’ values without explicitly using a...

You can use HTML tags for formatting. Wrap code in <code> tags and multiple lines of code in <pre><code> tags.

The Ruby Programming Language by David Flanagan, Yukihiro Matsumoto

Get full access to The Ruby Programming Language and 60K+ other titles, with a free 10-day trial of O'Reilly.

There are also live events, courses curated by job role, and more.

Assignments

An assignment expression specifies one or more values for one or more lvalues. lvalue is the term for something that can appear on the lefthand side of an assignment operator. (Values on the righthand side of an assignment operator are sometimes called rvalues by contrast.) Variables, constants, attributes, and array elements are lvalues in Ruby. The rules for and the meaning of assignment expressions are somewhat different for different kinds of lvalues, and each kind is described in detail in this section.

There are three different forms of assignment expressions in Ruby. Simple assignment involves one lvalue, the = operator, and one rvalue. For example:

Abbreviated assignment is a shorthand expression that updates the value of a variable by applying some other operation (such as addition) to the current value of the variable. Abbreviated assignment uses assignment operators like += and *= that combine binary operators with an equals sign:

Finally, parallel assignment is any assignment expression that has more than one lvalue or more than one rvalue. Here is a simple example:

Parallel assignment is more complicated when the number of lvalues is not the same as the number of rvalues or when there is an array on the right. Complete details follow.

The value of an assignment expression is the value (or an array of the values) assigned. Also, the assignment operator is “right-associative”—if multiple assignments appear in a single expression, they are evaluated from right to left. This means that the assignment can be chained to assign the same value to multiple variables:

Note that this is not a case of parallel assignment—it is two simple assignments, chained together: y is assigned the value 0 , and then x is assigned the value (also 0 ) of that first assignment.

Assignment and Side Effects

More important than the value of an assignment expression is the fact that assignments set the value of a variable (or other lvalue) and thereby affect program state. This effect on program state is called a side effect of the assignment.

Many expressions have no side effects and do not affect program state. They are idempotent . This means that the expression may be evaluated over and over again and will return the same value each time. And it means that evaluating the expression has no effect on the value of other expressions. Here are some expressions without side effects:

It is important to understand that assignments are not idempotent:

Some methods, such as Math.sqrt , are idempotent: they can be invoked without side effects. Other methods are not, and this largely depends on whether those methods perform assignments to nonlocal variables.

Assigning to Variables

When we think of assignment, we usually think of variables, and indeed, these are the most common lvalues in assignment expressions. Recall that Ruby has four kinds of variables: local variables, global variables, instance variables, and class variables. These are distinguished from each other by the first character in the variable name. Assignment works the same for all four kinds of variables, so we do not need to distinguish between the types of variables here.

Keep in mind that the instance variables of Ruby’s objects are never visible outside of the object, and variable names are never qualified with an object name. Consider this assignment:

The lvalues in this expression are not variables; they are attributes, and are explained shortly.

Assignment to a variable works as you would expect: the variable is simply set to the specified value. The only wrinkle has to do with variable declaration and an ambiguity between local variable names and method names. Ruby has no syntax to explicitly declare a variable: variables simply come into existence when they are assigned. Also, local variable names and method names look the same—there is no prefix like $ to distinguish them. Thus, a simple expression such as x could refer to a local variable named x or a method of self named x . To resolve this ambiguity, Ruby treats an identifier as a local variable if it has seen any previous assignment to the variable. It does this even if that assignment was never executed. The following code demonstrates:

Assigning to Constants

Constants are different from variables in an obvious way: their values are intended to remain constant throughout the execution of a program. Therefore, there are some special rules for assignment to constants:

Assignment to a constant that already exists causes Ruby to issue a warning. Ruby does execute the assignment, however, which means that constants are not really constant.

Assignment to constants is not allowed within the body of a method. Ruby assumes that methods are intended to be invoked more than once; if you could assign to a constant in a method, that method would issue warnings on every invocation after the first. So, this is simply not allowed.

Unlike variables, constants do not come into existence until the Ruby interpreter actually executes the assignment expression. A nonevaluated expression like the following does not create a constant:

Note that this means a constant is never in an uninitialized state. If a constant exists, then it has a value assigned to it. A constant will only have the value nil if that is actually the value it was given.

Assigning to Attributes and Array Elements

Assignment to an attribute or array element is actually Ruby shorthand for method invocation. Suppose an object o has a method named m= : the method name has an equals sign as its last character. Then o.m can be used as an lvalue in an assignment expression. Suppose, furthermore, that the value v is assigned:

The Ruby interpreter converts this assignment to the following method invocation:

That is, it passes the value v to the method m= . That method can do whatever it wants with the value. Typically, it will check that the value is of the desired type and within the desired range, and it will then store it in an instance variable of the object. Methods like m= are usually accompanied by a method m , which simply returns the value most recently passed to m= . We say that m= is a setter method and m is a getter method. When an object has this pair of methods, we say that it has an attribute m . Attributes are sometimes called “properties” in other languages. We’ll learn more about attributes in Ruby in Accessors and Attributes .

Assigning values to array elements is also done by method invocation. If an object o defines a method named []= (the method name is just those three punctuation characters) that expects two arguments, then the expression o[x] = y is actually executed as:

If an object has a []= method that expects three arguments, then it can be indexed with two values between the square brackets. The following two expressions are equivalent in this case:

Abbreviated Assignment

Abbreviated assignment is a form of assignment that combines assignment with some other operation. It is used most commonly to increment variables:

+= is not a real Ruby operator, and the expression above is simply an abbreviation for:

Abbreviated assignment cannot be combined with parallel assignment: it only works when there is a single lvalue on the left and a single value on the right. It should not be used when the lvalue is a constant because it will reassign the constant and cause a warning. Abbreviated assignment can, however, be used when the lvalue is an attribute. The following two expressions are equivalent:

Abbreviated assignment even works when the lvalue is an array element. These two expressions are equivalent:

Note that this code uses -= instead of += . As you might expect, the -= pseudooperator subtracts its rvalue from its lvalue.

In addition to += and -= , there are 11 other pseudooperators that can be used for abbreviated assignment. They are listed in Table 4-1 . Note that these are not true operators themselves, they are simply shorthand for expressions that use other operators. The meanings of those other operators are described in detail later in this chapter. Also, as we’ll see later, many of these other operators are defined as methods. If a class defines a method named + , for example, then that changes the meaning of abbreviated assignment with += for all instances of that class.

Table 4-1. Abbreviated assignment pseudooperators

The ||= Idiom

As noted at the beginning of this section, the most common use of abbreviated assignment is to increment a variable with += . Variables are also commonly decremented with -= . The other pseudooperators are much less commonly used. One idiom is worth knowing about, however. Suppose you are writing a method that computes some values, appends them to an array, and returns the array. You want to allow the user to specify the array that the results should be appended to. But if the user does not specify the array, you want to create a new, empty array. You might use this line:

Think about this for a moment. It expands to:

If you know the || operator from other languages, or if you’ve read ahead to learn about || in Ruby, then you know that the righthand side of this assignment evaluates to the value of results , unless that is nil or false . In that case, it evaluates to a new, empty array. This means that the abbreviated assignment shown here leaves results unchanged, unless it is nil or false , in which case it assigns a new array.

The abbreviated assignment operator ||= actually behaves slightly differently than the expansion shown here. If the lvalue of ||= is not nil or false , no assignment is actually performed. If the lvalue is an attribute or array element, the setter method that performs assignment is not invoked.

Parallel Assignment

Parallel assignment is any assignment expression that has more than one lvalue, more than one rvalue, or both. Multiple lvalues and multiple rvalues are separated from each other with commas. lvalues and rvalues may be prefixed with * , which is sometimes called the splat operator , though it is not a true operator. The meaning of * is explained later in this section.

Most parallel assignment expressions are straightforward, and it is obvious what they mean. There are some complicated cases, however, and the following subsections explain all the possibilities.

Same number of lvalues and rvalues

Parallel assignment is at its simplest when there are the same number of lvalues and rvalues:

In this case, the first rvalue is assigned to the first lvalue; the second rvalue is assigned to the second lvalue; and so on.

These assignments are effectively performed in parallel, not sequentially. For example, the following two lines are not the same:

One lvalue, multiple rvalues

When there is a single lvalue and more than one rvalue, Ruby creates an array to hold the rvalues and assigns that array to the lvalue:

You can place an * before the lvalue without changing the meaning or the return value of this assignment.

If you want to prevent the multiple rvalues from being combined into a single array, follow the lvalue with a comma. Even with no lvalue after that comma, this makes Ruby behave as if there were multiple lvalues:

Multiple lvalues, single array rvalue

When there are multiple lvalues and only a single rvalue, Ruby attempts to expand the rvalue into a list of values to assign. If the rvalue is an array, Ruby expands the array so that each element becomes its own rvalue. If the rvalue is not an array but implements a to_ary method, Ruby invokes that method and then expands the array it returns:

The parallel assignment has been transformed so that there are multiple lvalues and zero (if the expanded array was empty) or more rvalues. If the number of lvalues and rvalues are the same, then assignment occurs as described earlier in Same number of lvalues and rvalues . If the numbers are different, then assignment occurs as described next in Different numbers of lvalues and rvalues .

We can use the trailing-comma trick described above to transform an ordinary nonparallel assignment into a parallel assignment that automatically unpacks an array on the right:

Different numbers of lvalues and rvalues

If there are more lvalues than rvalues, and no splat operator is involved, then the first rvalue is assigned to the first lvalue, the second rvalue is assigned to the second lvalue, and so on, until all the rvalues have been assigned. Next, each of the remaining lvalues is assigned nil , overwriting any existing value for that lvalue:

If there are more rvalues than lvalues, and no splat operator is involved, then rvalues are assigned—in order—to each of the lvalues, and the remaining rvalues are discarded:

The splat operator

When an rvalue is preceded by an asterisk, it means that that value is an array (or an array-like object) and that its elements should each be rvalues. The array elements replace the array in the original rvalue list, and assignment proceeds as described above:

In Ruby 1.8, a splat may only appear before the last rvalue in an assignment. In Ruby 1.9, the list of rvalues in a parallel assignment may have any number of splats, and they may appear at any position in the list. It is not legal, however, in either version of the language, to attempt a “double splat” on a nested array:

Array, range and hash rvalues can be splatted. In general, any rvalue that defines a to_a method can be prefixed with a splat. Any Enumerable object, including enumerators (see Enumerators ) can be splatted, for example. When a splat is applied to an object that does not define a to_a method, no expansion is performed and the splat evaluates to the object itself.

When an lvalue is preceded by an asterisk, it means that all extra rvalues should be placed into an array and assigned to this lvalue. The value assigned to that lvalue is always an array, and it may have zero, one, or more elements:

In Ruby 1.8, a splat may only precede the last lvalue in the list. In Ruby 1.9, the lefthand side of a parallel assignment may include one splat operator, but it may appear at any position in the list:

Note that splats may appear on both sides of a parallel assignment expression:

Finally, recall that earlier we described two simple cases of parallel assignment in which there is a single lvalue or a single rvalue. Note that both of these cases behave as if there is a splat before the single lvalue or rvalue. Explicitly including a splat in these cases has no additional effect.

Parentheses in parallel assignment

One of the least-understood features of parallel assignment is that the lefthand side can use parentheses for “subassignment.” If a group of two or more lvalues is enclosed in parentheses, then it is initially treated as a single lvalue. Once the corresponding rvalue has been determined, the rules of parallel assignment are applied recursively—that rvalue is assigned to the group of lvalues that was in parentheses. Consider the following assignment:

This is effectively two assignments executed at the same time:

But note that the second assignment is itself a parallel assignment. Because we used parentheses on the lefthand side, a recursive parallel assignment is performed. In order for it to work, b must be a splattable object such as an array or enumerator.

Here are some concrete examples that should make this clearer. Note that parentheses on the left act to “unpack” one level of nested array on the right:

The value of parallel assignment

The return value of a parallel assignment expression is the array of rvalues (after being augmented by any splat operators).

Parallel Assignment and Method Invocation

As an aside, note that if a parallel assignment is prefixed with the name of a method, the Ruby interpreter will interpret the commas as method argument separators rather than as lvalue and rvalue separators. If you want to test the return value of a parallel assignment, you might write the following code to print it out:

This doesn’t do what you want, however; Ruby thinks you’re invoking the puts method with three arguments: x , y=1 , and 2 . Next, you might try putting the parallel assignment within parentheses for grouping:

This doesn’t work, either; the parentheses are interpreted as part of the method invocation (though Ruby complains about the space between the method name and the opening parenthesis). To actually accomplish what you want, you must use nested parentheses:

This is one of those strange corner cases in the Ruby grammar that comes as part of the expressiveness of the grammar. Fortunately, the need for syntax like this rarely arises.

Get The Ruby Programming Language now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

It’s yours, free.

Check it out now on O’Reilly

Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial
• How to iterate over a Hash in Ruby?
• How to convert a number to Binary in Ruby?
• How to tell Ruby program to wait for some amount of time?
• Closures in Ruby
• How to convert Array to Hash in Ruby?
• Monkey Patching in Ruby
• How To Convert Data Types in Ruby?
• How to Sort a Hash in Ruby?
• How to Check if an Array Contains a Value in Ruby?
• True, False, and Nil In Ruby
• How to check if a variable is nil in Ruby?
• How to Sort an Array alphabetically in Ruby?
• How can we access the entries of a Hash in Ruby?
• The autoload Method in Ruby
• How to Remove Last Character from String in Ruby?
• How to remove all nil elements from an Array in Ruby permanently?
• How to Convert a String to Lower or Upper Case in Ruby?
• How to convert String to Boolean in Ruby?
• How to execute shell command in Ruby?

How to Return Multiple Values in Ruby?

This article focuses on discussing the different ways to return multiple values in Ruby .

Table of Content

Using an Array

Using a hash, using parallel assignment.

In this method, multiple values are packed into an array, which is then returned from the method.

return [value1, value2, …]

Below is the Ruby program to return multiple values using an array.

Explanation:

In this example, we call the method which returns the array in the variable result , individual elements of the array are accessed using array indexing ( result[0] , result[1] , result[2] ), and then printed.

In this method, multiple values packed into a hash with keys representing the values, and then the hash is returned from the method

return { key1: value1, key2: value2, … }

Below is the Ruby program to return multiple values using a hash.

In this example r eturn_multiple_values method returns a hash {:a => 1, :b => 2, :c => 3} , where keys represent values. After which we store the returned hash in the variable result ,and access the individual values using hash keys ( :a , :b , :c ), and then printed.

In this method multiple values are returned separately from the method, allowing them to be assigned to multiple variables using parallel assignment.

return value1, value2

Below is the Ruby program to return multiple values using parallel assignment.

In this example return_multiple_values method returns three values separately (1, 2, 3) . After which we store the returned values are assigned to variables a , b , and c using parallel assignment. Then, each variable is printed.

Please Login to comment...

Similar reads.

• 10 Ways to Use Slack for Effective Communication
• 10 Ways to Use Google Docs for Collaborative Writing
• NEET MDS 2024 Result: Toppers List, Category-wise Cutoff, and Important Dates
• NDA Admit Card 2024 Live Updates: Download Your Hall Ticket Soon on upsc.gov.in!
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Ruby Tricks, Idiomatic Ruby, Refactorings and Best Practices

Conditional assignment.

Ruby is heavily influenced by lisp. One piece of obvious inspiration in its design is that conditional operators return values. This makes assignment based on conditions quite clean and simple to read.

There are quite a number of conditional operators you can use. Optimize for readability, maintainability, and concision.

If you're just assigning based on a boolean, the ternary operator works best (this is not specific to ruby/lisp but still good and in the spirit of the following examples!).

If you need to perform more complex logic based on a conditional or allow for > 2 outcomes, if / elsif / else statements work well.

If you're assigning based on the value of a single variable, use case / when A good barometer is to think if you could represent the assignment in a hash. For example, in the following example you could look up the value of opinion in a hash that looks like {"ANGRY" => comfort, "MEH" => ignore ...}