Arrays in Ruby

Arrays in Ruby

Create Array of Strings

Arrays of strings can be created using ruby's percent string syntax:

array = %w(one two three four)

This is functionally equivalent to defining the array as:

array = ['one', 'two', 'three', 'four']

Instead of%w()you may use other matching pairs of delimiters:%w{...},%w[...]or%w<...>.

It is also possible to use arbitrary non-alphanumeric delimiters, such as:%w!...!, %w#...#or%w@...@.

%Wcan be used instead of%wto incorporate string interpolation. Consider the following:

var = 'hello'

%w(#{var}) # => ["\#{var}"]
%W(#{var}) # => ["hello"]

Multiple words can be interpreted by escaping the space with a .

%w(Colorado California New\ York) # => ["Colorado", "California", "New York"]

Create Array with Array::new

An empty Array ([]) can be created with Array's class method,Array.new:

Array.new    

To set the length of the array, pass a numerical argument:

Array.new 3 #=> [nil, nil, nil]

There are two ways to populate an array with default values:

  • Pass an immutable value as second argument.
  • Pass a block that gets current index and generates mutable values.
Array.new 3, :x #=> [:x, :x, :x]

Array.new(3) { |i| i.to_s } #=> ["0", "1", "2"]

a = Array.new 3, "X" # Not recommended.
a[1].replace "C" # a => ["C", "C", "C"]

b = Array.new(3) { "X" } # The recommended way.
b[1].replace "C" # b => ["X", "C", "X"]

Creating an Array with the literal constructor [ ]

Arrays can be created by enclosing a list of elements in square brackets ([and]). Array elements in this notation are separated with commas:

array = [1, 2, 3, 4]

Arrays can contain any kind of objects in any combination with no restrictions on type:

array = [1, 'b', nil, [3, 4]]

Manipulating Array Elements

Adding elements:

[1, 2, 3] << 4
# => [1, 2, 3, 4]

[1, 2, 3].push(4)
# => [1, 2, 3, 4]

[1, 2, 3].unshift(4)
# => [4, 1, 2, 3]

[1, 2, 3] << [4, 5]
# => [1, 2, 3, [4, 5]]

Removing elements:

array = [1, 2, 3, 4]
array.pop
# => 4
array
# => [1, 2, 3]

array = [1, 2, 3, 4]
array.shift
# => 1
array
# => [2, 3, 4]

array = [1, 2, 3, 4]
array.delete(1)
# => 1
array
# => [2, 3, 4]

array = [1,2,3,4,5,6]
array.delete_at(2) // delete from index 2
# => 3
array
# => [1,2,4,5,6]


array = [1, 2, 2, 2, 3]
array - [2]
# => [1, 3] # removed all the 2s
array - [2, 3, 4]
# => [1] # the 4 did nothing

Combining arrays:

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

[1, 2, 3].concat([4, 5, 6])
# => [1, 2, 3, 4, 5, 6]

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

[1, 2, 3] | [2, 3, 4]
# => [1, 2, 3, 4]

[1, 2, 3] & [3, 4]
# => [3]

You can also multiply arrays, e.g.

[1, 2, 3] * 2
# => [1, 2, 3, 1, 2, 3]

Accessing elements

You can access the elements of an array by their indices. Array index numbering starts at0.

%w(a b c)[0] # => 'a'
%w(a b c)[1] # => 'b'

You can crop an array using range

%w(a b c d)[1..2] # => ['b', 'c'] (indexes from 1 to 2, including the 2)
%w(a b c d)[1...2] # => ['b'] (indexes from 1 to 2, excluding the 2)

This returns a new array, but doesn't affect the original. Ruby also supports the use of negative indices.

%w(a b c)[-1] # => 'c'
%w(a b c)[-2] # => 'b'

Other useful methods

Usefirstto access the first element in an array:

[1, 2, 3, 4].first # => 1

Orfirst(n)to access the first n elements returned in an array:

[1, 2, 3, 4].first(2) # => [1, 2]

Similarly forlast and last(n):

[1, 2, 3, 4].last    # => 4
[1, 2, 3, 4].last(2) # => [3, 4]

Usesampleto access a random element in a array:

[1, 2, 3, 4].sample  # => 3
[1, 2, 3, 4].sample # => 1

Orsample(n):

[1, 2, 3, 4].sample(2) # => [2, 1]
[1, 2, 3, 4].sample(2) # => [3, 4]

Decomposition

Any array can be quickly decomposed by assigning its elements into multiple variables. A simple example:

arr = [1, 2, 3]
# ---
a = arr[0]
b = arr[1]
c = arr[2]
# --- or, the same
a, b, c = arr

Preceding a variable with the splat operator (*) puts into it an array of all the elements that haven't been captured by other variables. If none are left, empty array is assigned. Only one splat can be used in a single assignment:

a, *b = arr       # a = 1; b = [2, 3]
a, *b, c = arr # a = 1; b = [2]; c = 3
a, b, c, *d = arr # a = 1; b = 2; c = 3; d = []
a, *b, *c = arr # SyntaxError: unexpected *

Decomposition is safe and never raises errors.nilsare assigned where there's not enough elements, matching the behavior of[]operator when accessing an index out of bounds:

arr[9000] # => nil
a, b, c, d = arr # a = 1; b = 2; c = 3; d = nil

Decomposition tries to callto_aryimplicitly on the object being assigned. By implementing this method in your type you get the ability to decompose it:

class Foo
def to_ary
[1, 2]
end
end
a, b = Foo.new # a = 1; b = 2

If the object being decomposed doesn'trespond_to?to_ary, it's treated as a single-element array:

1.respond_to?(:to_ary) # => false
a, b = 1 # a = 1; b = nil

Decomposition can also be nested by using a()-delimited decomposition expression in place of what otherwise would be a single element:

arr = [1, [2, 3, 4], 5, 6]
a, (b, *c), *d = arr # a = 1; b = 2; c = [3, 4]; d = [5, 6]
# ^^^^^

This is effectively the opposite of splat.

Actually, any decomposition expression can be delimited by(). But for the first level decomposition is optional.

a, b = [1, 2]
(a, b) = [1, 2] # the same thing

Edge case: a single identifier cannot be used as a destructuring pattern, be it outer or a nested one:

(a) = [1] # SyntaxError
a, (b) = [1, [2]] # SyntaxError

When assigning an array literal to a destructuring expression, outer[]can be omitted:

a, b = [1, 2]
a, b = 1, 2 # exactly the same

This is known as parallel assignment, but it uses the same decomposition under the hood. This is particularly handy for exchanging variables' values without employing additional temporary variables:

t = a; a = b; b = t # an obvious way
a, b = b, a # an idiomatic way
(a, b) = [b, a] # ...and how it works

Values are captured when building the right-hand side of the assignment, so using the same variables as source and destination is relatively safe.

#map

#map, provided by Enumerable, creates an array by invoking a block on each element and collecting the results:

[1, 2, 3].map { |i| i * 3 }
# => [3, 6, 9]

['1', '2', '3', '4', '5'].map { |i| i.to_i }
# => [1, 2, 3, 4, 5]

The original array is not modified; a new array is returned containing the transformed values in the same order as the source values.map!can be used if you want to modify the original array.

Inmapmethod you can call method or use proc to all elements in array.

# call to_i method on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&:to_i)
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# using proc (lambda) on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&->(i){ i.to_i * 2})
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

mapis synonymous withcollect.

Arrays and the splat (*) operator

The*operator can be used to unpack variables and arrays so that they can be passed as individual arguments to a method.

This can be used to wrap a single object in an Array if it is not already:

def wrap_in_array(value)
[*value]
end

wrap_in_array(1)
#> [1]

wrap_in_array([1, 2, 3])
#> [1, 2, 3]

wrap_in_array(nil)
#> []

In the above example, thewrap_in_arraymethod accepts one argument,value.

Ifvalueis anArray, its elements are unpacked and a new array is created containing those element.

Ifvalueis a single object, a new array is created containing that single object.

Ifvalueisnil, an empty array is returned.

The splat operator is particularly handy when used as an argument in methods in some cases. For example, it allows nil, single values and arrays to be handled in a consistent manner:

def list(*values)
values.each do |value|
# do something with value
puts value
end
end

list(100)
#> 100

list([100, 200])
#> 100
#> 200

list(nil)
# nothing is outputted

Arrays union, intersection and difference

x = [5, 5, 1, 3]
y = [5, 2, 4, 3]

Union (|) contains elements from both arrays, with duplicates removed:

x | y
=> [5, 1, 3, 2, 4]

Intersection (&) contains elements which are present both in first and second array:

x & y
=> [5, 3]

Difference (-) contains elements which are present in first array and not present in second array:

x - y
=> [1]

Filtering arrays

Often we want to operate only on elements of an array that fulfill a specific condition:

Select

Will return elements that match a specific condition

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 } # => [4, 5, 6]

Reject

Will return elements that do not match a specific condition

array = [1, 2, 3, 4, 5, 6]
array.reject { |number| number > 3 } # => [1, 2, 3]

Both#selectand#rejectreturn an array, so they can be chained:

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 }.reject { |number| number < 5 }
# => [5, 6]

Get all combinations / permutations of an array

Thepermutationmethod, when called with a block yields a two dimensional array consisting of all ordered sequences of a collection of numbers.

If this method is called without a block, it will return anenumerator. To convert to an array, call theto_amethod.

Example Result
[1,2,3].permutation #<Enumerator: [1,2,3]:permutation
[1,2,3].permutation.to_a [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
[1,2,3].permutation(2).to_a [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]
[1,2,3].permutation(4).to_a [] -> No permutations of length 4

Thecombinationmethod on the other hand, when called with a block yields a two-dimensional array consisting of all sequences of a collection of numbers. Unlike permutation, order is disregarded in combinations. For example,[1,2,3]is the same as[3,2,1]

Example Result
[1,2,3].combination(1) #<Enumerator: [1,2,3]:combination
[1,2,3].combination(1).to_a [[1],[2],[3]]
[1,2,3].combination(3).to_a [[1,2,3]]
[1,2,3].combination(4).to_a [] -> No combinations of length 4

Calling the combination method by itself will result in an enumerator. To get an array, call theto_amethod.

Therepeated_combinationandrepeated_permutationmethods are similar, except the same element can be repeated multiple times.

For example the sequences[1,1],[1,3,3,1],[3,3,3]would not be valid in regular combinations and permutations.

Example # Combos
[1,2,3].combination(3).to_a.length 1
[1,2,3].repeated_combination(3).to_a.length 6
[1,2,3,4,5].combination(5).to_a.length 1
[1,2,3].repeated_combination(5).to_a.length 126

Get unique array elements

In case you need to read an array elementsavoiding repetitionsyou case use the#uniqmethod:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]

Instead, if you want to remove all duplicated elements from an array, you may use#uniq!method:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]

While the output is the same,#uniq!also stores the new array:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]
a
#=> [1, 1, 2, 3, 4, 4, 5]

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]
a
#=> [1, 2, 3, 4, 5]

Turn multi-dimensional array into a one-dimensional (flattened) array

[1, 2, [[3, 4], [5]], 6].flatten  # => [1, 2, 3, 4, 5, 6]

If you have a multi-dimensional array and you need to make it a simple (i.e. one-dimensional) array, you can use the #flatten method.

Two-dimensional array

Using theArray::new constructor, your can initialize an array with a given size and a new array in each of its slots. The inner arrays can also be given a size and and initial value.

For instance, to create a 3x4 array of zeros:

array = Array.new(3) { Array.new(4) { 0 } }

The array generated above looks like this when printed withp:

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

You can read or write to elements like this:

x = array[0][1]
array[2][3] = 2

Create an Array of consecutive numbers or letters

This can be easily accomplished by callingEnumerable#to_aon aRangeobject:

(1..10).to_a    #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(a..b)means that it will include all numbers between a and b. To exclude the last number, use a...b

a_range = 1...5
a_range.to_a #=> [1, 2, 3, 4]

or

('a'..'f').to_a    #=> ["a", "b", "c", "d", "e", "f"]
('a'...'f').to_a #=> ["a", "b", "c", "d", "e"]

A convenient shortcut for creating an array is[*a..b]

[*1..10]           #=> [1,2,3,4,5,6,7,8,9,10]
[*'a'..'f'] #=> ["a", "b", "c", "d", "e", "f"]

Create Array of numbers

The normal way to create an array of numbers:

numbers = [1, 2, 3, 4, 5]

Range objects can be used extensively to create an array of numbers:

numbers = Array(1..10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers = (1..10).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#stepand#mapmethods allow us to impose conditions on the range of numbers:

odd_numbers = (1..10).step(2).to_a # => [1, 3, 5, 7, 9]

even_numbers = 2.step(10, 2).to_a # => [2, 4, 6, 8, 10]

squared_numbers = (1..10).map { |number| number * number } # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

All the above methods load the numbers eagerly. If you have to load them lazily:

number_generator = (1..100).lazy # => #<Enumerator::Lazy: 1..100>

number_generator.first(10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]