For example, let’s say we had a category model and a transaction model defined like so:

class Category < ApplicationRecord
  has_many :transactions, dependent: :nullify
end

class Transaction < ApplicationRecord
  belongs_to :category
end

With this setup, if a category is deleted, and it has transactions associated, the category_id field on each transaction is set to null. The category is deleted but the transactions remain. A new category can then be set for each transaction, or the association can be left as null.

References

• https://guides.rubyonrails.org/association_basics.html

I also made a Python Lists Cheatsheet you can check out.

All examples were run using the Ruby v3.2.3 REPL.

Initializing an Array

Empty Array

arr = Array.new
# => []

Alternative way:

arr = []
# => []

Array with Values

Initializing an array of integers:

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

Initializing an array of strings:

arr = ["A", "B", "C"]
# => ["A", "B", "C"]

You can do the above with any type.

Initializing an array of symbols:

arr = [:A, :B, :C]
# => [:A, :B, :C]

Shorthand Notations

With shorthand notations there is no need to add quotes for strings or colons for symbols. There’s also no need to add commas after each element. Just separate each element with a space.

Initializing an array of strings using %w:

arr = %w[A B C D E]
# => ["A", "B", "C", "D", "E"]

Initializing an array of symbols using %i:

arr = %i[A B C D E]
# => [:A, :B, :C, :D, :E]

Adding Elements

At the Beginning of the Array

Add elements to the beginning of the array with unshift() or prepend(), which is an alias for unshift().

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

arr
# => [0, 1, 2, 3]

arr = [1, 2, 3]
arr.prepend(0)
# => [0, 1, 2, 3]

arr
# => [0, 1, 2, 3]

At the End of the Array

Add elements to the end of the array with push() or append(), which is an alias for push():

arr = [1, 2, 3]
arr.append(4)

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

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

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

You can use << as a shortcut to add elements to the end of an array:

arr = []

arr << 1 # [1]
arr << 2 # [1, 2]
arr << 3 # [1, 2, 3]

arr
# => [1, 2, 3]

If you add arrays, the arrays added to the first one will be appended in the order in which they are added:

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

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

You can add arrays containing multiple elements and they will be appended:

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

At a Specific Index

Use insert() to add an element at a specific index of an array. The insert() method accepts multiple parameters but the first one must be an index. This method modifies the array in-place.

In this example, "A" is being added at index 2:

arr = ["A", "B", "C"]
arr.insert(2, "A")
# => ["A", "B", "A", "C"]

arr
# => ["A", "B", "A", "C"]

Multiple elements can be added at once:

arr = ["A", "B", "C"]
arr.insert(2, "Z", "Z", "Z")
# => ["A", "B", "Z", "Z", "Z", "C"]

arr
# => ["A", "B", "Z", "Z", "Z", "C"]

Removing Elements

At the Beginning of the Array

Remove an element from the beginning of an array with shift(). This method returns the removed element and modifies the array in-place:

arr = [1, 2, 3]
arr.shift
# => 1

arr
# => [2, 3]

At the End of the Array

Remove an element from the end of the array with pop(). This method returns the removed element and modifies the array in-place:

arr = [1, 2, 3]
arr.pop
# => 3

arr
# => [1, 2]

Delete all instances of an element by passing in that element to delete(). This method returns the removed element and modifies the array in-place:

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

arr
# => [1, 2]

Attempting to delete an element that isn’t present returns nil:

arr = [1, 2, 3, 3, 3]
arr.delete(5)
# => nil

Note that you cannot delete multiple values in one call of delete(). But it is possible to do it by subtracting arrays. Keep reading after this example to see how:

arr = [1, 2, 3, 3, 3]
arr.delete(1,2,3)
# (irb):83:in `delete': wrong number of arguments (given 3, expected 1) (ArgumentError)

You can subtract an array to remove all occurrences of an element and get the resulting array as a return value, but it does not modify the array in-place:

arr = [1, 2, 3, 3, 3]
arr - [3]
# => [1, 2]

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

Subtracted arrays can have multiple elements:

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

Subtracting arrays with elements that aren’t present in the first array does nothing:

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

At a Specific Index

We can delete an element at a specific index using delete_at(index). The delete_at() method returns the element that is removed. Passing in an index that is out of bounds returns nil:

arr = ["A", "B", "C"]
arr.delete_at(1)
# => "B"

arr
# => ["A", "C"]

arr.delete_at(100)
# => nil

Retrieving Elements

Element at a Specific Index

Like in most programming languages, an element can be retrieved using my_array[index] where index is an integer.

arr = ["A", "B", "C"]
arr[1]
# => "B"

We can also use at() to get the element at a certain index. It works the same way as the previous example:

arr = ["A", "B", "C"]
arr.at(1)
# => "B"

Negative indexes start at the end of the array.

arr = ["A", "B", "C"]
arr[-1]
# => "C"
arr[-2]
# => "B"
arr[-3]
# => "A"

Out of bounds indexes return nil:

arr = ["A", "B", "C"]
arr[5]
# => nil
arr[-4]
# => nil

The First Element

There is a handy first() method to retrieve the first element of an array:

arr = ["A", "B", "C"]
arr.first # equivalent to arr[0]
# => "A"

The Last Element

There’s also a last() method to retrieve the last element of an array:

arr = ["A", "B", "C"]
arr.last
# => "C"

Range of Elements

We can use a .. or ... to specify a range of indices within an array. These are useful for sliding window problems:

Using .. results in an inclusive range:

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

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

Using ... results in an exclusive range:

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

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

Maximum Element

We can use max() to retrieve the biggest number in an array:

arr = [1, 5, 8, 2, 0, 4]

arr.max
# => 8

If max() is used on an array of strings it returns the last string after sorting alphabetically:

arr = ["B", "D", "A", "C"]

arr.max
# => "D"

It works the same way for an array of Symbols:

arr = [:A, :C, :D, :B]

arr.max
# => :D

max() will not work on an array containing elements of different types:

arr = [1, "B", 4, "C", 2, "A"]

arr.max
# => (irb):14:in `max': comparison of Integer with String failed (ArgumentError)

Minimum Element

Works the same way as max() but with the smallest value instead.

Retrieving the smallest number in an array:

arr = [9, 2, 5, 1, 8]

arr.min
# => 1

If min() is used on an array of strings it returns the first string after sorting alphabetically:

arr = ["B", "D", "A", "C"]

arr.min
# => "A"

It works the same way for an array of Symbols:

arr = [:A, :C, :D, :B]

arr.min
# => :A

And once again, min() will not work on an array containing elements of different types:

arr = [1, "B", 4, "C", 2, "A"]

arr.min
# => (irb):27:in `min': comparison of Integer with String failed (ArgumentError)

Sorting Arrays

The sort() method returns a sorted version of the array it is used on. This does not modify the original array:

arr = ["E", "D", "A", "C", "B"]
arr.sort
# => ["A", "B", "C", "D", "E"]

arr
# => ["E", "D", "A", "C", "B"]

Use sort!() to modify the array in-place:

arr = ["E", "D", "A", "C", "B"]
arr.sort!
# => ["A", "B", "C", "D", "E"]

arr
# => ["A", "B", "C", "D", "E"]

Sorting works with other types of elements as well.

Sorting integers:

arr = [5, 9, 0, 3, 4]
# => [5, 9, 0, 3, 4]
arr.sort
# => [0, 3, 4, 5, 9]

Sorting symbols:

arr = [:red, :blue, :green, :cyan]
# => [:red, :blue, :green, :cyan]
arr.sort
# => [:blue, :cyan, :green, :red]

Sorting multi-character strings:

arr = ["someone", "hire", "me", "please"]
# => ["someone", "hire", "me", "please"]
arr.sort
# => ["hire", "me", "please", "someone"]

arr = ["aaaa", "aa", "aaa", "a"]
# => ["aaaa", "aa", "aaa", "a"]
arr.sort
# => ["a", "aa", "aaa", "aaaa"]

Note:

There’s also a sort_by() method but I am too dumb to come up with good examples. You should read about it in this article instead: How to Sort Arrays & Hashes in Ruby.

Looping Through Arrays

Each Element

Use each() to iterate through each element in an array:

arr = ["A", "B", "C", "D", "E"]

arr.each do |i|
  puts i
end

# output:
# A
# B
# C
# D
# E

Each Index

Use each_index() to iterate through each index in an array beginning at 0:

arr = ["A", "B", "C", "D", "E"]

arr.each_index do |i|
  puts i
end

# output:
# 0
# 1
# 2
# 3
# 4

Element and Index

Use each_with_index() to iterate through both elements and indexes at the same time. The first variable in the | | is the element, the second one is the index.

arr = ["A", "B", "C", "D", "E"]

arr.each_with_index do |element, index|
  puts "#{index}: #{element}"
end

# output:
# 0: A
# 1: B
# 2: C
# 3: D
# 4: E

Modifying All Elements in an Array

We can use map() to modify all elements in an array.

For example, to increment all integers in an array we can do the following:

arr = [1, 2, 3, 4, 5]
arr.map { |i| i += 1 }
#  => [2, 3, 4, 5, 6]

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

To modify the elements/array in-place, add an exclamation point:

arr = [1, 2, 3, 4, 5]
arr.map! { |i| i += 1 }
#  => [2, 3, 4, 5, 6]

arr
# => [2, 3, 4, 5, 6]

Here’s another example where string names in an array are capitalized appropriately:

names = ["nelson", "cindy", "john", "sophia"]
names.map! { |name| name.capitalize }
# => ["Nelson", "Cindy", "John", "Sophia"]

There is a shorthand notation when you want to run a method against all elements in an array. We can use &:method_name. The following example achieves the exact same thing as the previous example:

names = ["nelson", "cindy", "john", "sophia"]
names.map!(&:capitalize)
# => ["Nelson", "Cindy", "John", "Sophia"]

Here’s another example using shorthand notation to convert all strings to symbols:

arr = ["A", "B", "C", "D", "E"]
arr.map!(&:to_sym)
# => [:A, :B, :C, :D, :E]

If you want to do more advanced things, like modify elements conditionally, you will need to stick to the long format. This example replaces all nil elements with 0 but leaves other elements unchanged:

data = [100, 200, nil, 400, 500, nil]
data.map! { |i| i.nil? ? i = 0 : i = i }
# => [100, 200, 0, 400, 500, 0]

Other Things to Know

Arrays Can Contain Multiple Types

For example:

arr = []

arr << 1
arr << "a"
arr << :my_symbol
arr << [1,2]
arr << {hash_key: "hash_value"}

arr
# => [1, "a", :my_symbol, [1, 2], {:hash_key=>"hash_value"}]

Getting the Index of an Element

Use index() and pass in the element you are looking for to retrieve its index.

arr = ["A", "B", "C"]
arr.index("B")
# => 1

If there are multiple occurrences of an element, index() will return the index of the first occurrence of the element:

arr = ["A", "B", "B", "B", "C"]
arr.index("B")
# => 1

If an element isn’t present in the array, index() returns nil:

arr = ["A", "B", "C"]
arr.index("Z")
# => nil

Reversing Elements in an Array

Elements in an array can be reversed with reverse(). This method returns a new array with the elements in reverse order and does not modify the original array:

arr = ["A", "B", "C"]
arr.reverse
# => ["C", "B", "A"]

arr
# => ["A", "B", "C"]

The reverse!() method does the same thing but it modifies the array in-place:

arr = ["A", "B", "C"]
arr.reverse!
# => ["C", "B", "A"]

arr
# => ["C", "B", "A"]

Converting Multi-dimensional Array into 1-dimensional Array

We can use flatten() to recursively extract elements from all arrays within an array and return an array with only elements. The original array remains unchanged.

arr = ["A", ["B", "C"], ["D", ["E", ["F"]]]]
arr.flatten
# => ["A", "B", "C", "D", "E", "F"]

arr
# => ["A", ["B", "C"], ["D", ["E", ["F"]]]]

We can use flatten!() to modify the array in-place:

arr = ["A", ["B", "C"], ["D", ["E", ["F"]]]]
arr.flatten!
# => ["A", "B", "C", "D", "E", "F"]

arr
# => ["A", "B", "C", "D", "E", "F"]

Removing All Elements from Array

We can use clear() to remove all elements from an array in-place.

arr = ["A", "B", "C"]
arr.clear
# => []

arr
# => []

Note:

Using arr.clear is not the same as setting arr to an empty array.

arr.clear modifies the array in-place. All references to arr will be an empty array [].

arr = [] creates a new empty array and assigns it to the arr variable. Other references to the original array are left intact.

Removing nil Elements from Array

We can use compact() to remove all nil elements in an array. This method returns a new array.

arr = [1, nil, 2, nil, 3]
arr.compact
# => [1, 2, 3]

arr
# => [1, nil, 2, nil, 3]

We can use compact!() to do the same operation to the array in-place:

arr = [1, nil, 2, nil, 3]
arr.compact!
# => [1, 2, 3]

arr
#  => [1, 2, 3]

References

• https://gist.github.com/mkdika/d1a9c72b6d2b86547f2269e82c235e83
• https://www.rubyguides.com/2017/07/ruby-sort/
• https://apidock.com/ruby/v2_5_5/Enumerable/sort_by
• https://www.shortcutfoo.com/app/dojos/ruby-arrays/cheatsheet
• https://apidock.com/ruby/Array
• https://ruby-doc.org/core-3.1.0/Array.html
• https://www.rubyguides.com/2018/10/ruby-map-method/
• https://womanonrails.com/one-line-map-ruby

If a hash is created using “hash rocket” (=>) notation then the keys will retain their type. If the hash is written in JSON-style syntax, all keys become symbols.

In both scenarios, values will retain their type.

If a key is added to the hash after the hash has been created, that key will retain its type. This can lead to situations where a hash has keys that are of multiple data types.

Hashes With Hash Rocket Syntax

In the example below, a hash is created using hash rocket notation:

items = {
  'A' => 1,
  'B' => 2,
  'C' => 3
}

puts items['A']
puts items.keys.first.class

The output is:

$ ruby script.rb

1
String

We can see that with hash rocket syntax the A key retained its string type and can be written as a string in items['A'].

Hashes with JSON Syntax

Let’s see what happens if we take the previous example but change the hash syntax to use JSON-style colons:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

puts items['A']
puts items.keys.first.class

The output is as follows:

$ ruby script.rb

Symbol

The empty line above Symbol is not a typo. In this case, items['A'] doesn’t exist because 'A' is a symbol and should be written as :A. As a result, Ruby prints an empty value.

To get the expected value, we need to write A as a symbol inside puts items[]:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

# writing A as a symbol
puts items[:A]

Now we get the expected output:

$ ruby script.rb

1

We can see that JSON syntax turns all keys in the hash into symbols.

Mixing Hash Key Data Types

It’s possible to mix certain hash key data types (integers, strings, symbols) when using hash rocket syntax:

items = {
  1 => 1,
  'B' => 2,
  :C => 3
}

items.each do |key, value|
  puts "#{key}, #{key.class}"
end

The output from the code above is:

$ ruby script.rb

1, Integer
B, String
C, Symbol

However, if we change the hash rockets to colons, the code does not work:

items = {
  1: 1,
  'B': 2,
  :C: 3
}

items.each do |key, value|
  puts "#{key}, #{key.class}"
end

The code above throws the error:

$ ruby script.rb

syntax error, unexpected ':', expecting =>

This is because when using JSON syntax the keys must be written as strings (which are then converted to symbols).

Key Types When They Are Appended to Hashes

Creating a hash with JSON-style syntax results in all keys being converted to the symbol data type. However, if keys are added to the hash after creation, we can have keys of different data types.

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items[4] = 4
items['5'] = 5

items.each do |key, value|
  puts "#{key}, #{key.class}"
end

The output is:

$ ruby script.rb

A, Symbol
B, Symbol
C, Symbol
4, Integer
5, String

We can see that the original 3 keys in the items hash were converted to symbols, while the new appended keys retained their data types.

This also works with rocket syntax hashes since they are more flexible about key data types:

items = {
  'A' => 1,
  'B' => 2,
  'C' => 3
}

items[4] = 4
items['5'] = 5

items.each do |key, value|
  puts "#{key}, #{key.class}"
end

The output is:

$ ruby script.rb

A, String
B, String
C, String
4, Integer
5, String

The difference between the JSON-style hash and the rocket notation hash is that the original 3 keys in the items hash retained their type.

More information in the Ruby docs:

• https://ruby-doc.org/3.1.2/Hash.html

Ascending Order

Let’s say we had the following hash:

items = {
  "b": 2,
  "a": 3,
  "c": 1
}

If we wanted to sort it by keys, we can use the .sort method to sort in ascending order:

items = {
  "b": 2,
  "a": 3,
  "c": 1
}

# sorting the hash by keys. `items` is now an array
items = items.sort

The code above will result in items being an array of arrays (sorted alphabetically by keys) that looks like this:

[[:a, 3], [:b, 2], [:c, 1]]

Descending Order

To sort a hash by key in descending order, we can chain the .reverse method to the previous code:

items = {
  "b": 2,
  "a": 3,
  "c": 1
}

items = items.sort.reverse

The code above turns items into the following:

[[:c, 1], [:b, 2], [:a, 3]]

Sorting Hashes by Value

Ascending Order

To sort a hash by value, we need to use .sort_by like so:

items = {
  "b": 2,
  "a": 3,
  "c": 1
}

# sorting by values
items = items.sort_by { |k, v| v }

The code above will result in items being an array once again, but this time sorted by values in ascending order:

[[:c, 1], [:b, 2], [:a, 3]]

Descending Order

We can also use .sort_by to sort values in descending order by using -v:

items = {
  "b": 2,
  "a": 3,
  "c": 1
}

# sorting by values in descending order, note the `-v`
items = items.sort_by { |k, v| -v }

The code above transforms items into the following:

[[:a, 3], [:b, 2], [:c, 1]]

Side Note: Converting Resulting Arrays to Hashes

As a side note: if you still need the result in a hash format, you can convert the resulting array into a hash with .to_h:

items = {
  "b": 2,
  "a": 3,
  "c": 1
}

# sorting and converting the result to a hash
items = items.sort.to_h

The code above will result in items being a hash again:

{:a=>3, :b=>2, :c=>1}

Note that at the time of this writing I’m running Ruby 3.1.2.

Iterating With Key and Value

The most common way I’ve seen hash iterations is by declaring both the key and value variables in the loop. The result is as expected:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.each do |key, value|
  puts "key: #{key}, value: #{value}"
end

The code above has the following output:

key: A, value: 1
key: B, value: 2
key: C, value: 3

Iterating With a Single Variable

When iterating through a hash and declaring only a single variable, the variable is an array containing the key and value of the hash as elements.

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.each do |item|
  puts "#{item}"
end

The code above has the following output:

[:A, 1]
[:B, 2]
[:C, 3]

In this case, the item variable is an array of 2 elements. The keys are Symbols while the values retain their original type.

There is also the .each_pair method, which works exactly the same way:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.each_pair do |pair|
  puts "#{pair}"
end

The output is exactly the same as before:

[:A, 1]
[:B, 2]
[:C, 3]

Iterating Through Keys

The keys of a Ruby hash can be retrieved with .keys:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

puts items.keys

The code above prints out the following:

A
B
C

If we want to iterate over each key, we can use .keys in a loop:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.keys.each do |key|
  puts key
end

And the output is exactly the same:

A
B
C

Finally, there is also the .each_key method that works the same way and is recommended by Rubocop:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.each_key do |key|
  puts key
end

Once again, the output is the same:

A
B
C

Iterating Through Values

Like with keys, the values of a hash can be retrieved with .values:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

puts items.values

The code above outputs the following:

1
2
3

We can use .values to iterate through the values of a hash:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.values.each do |value|
  puts value
end

The output is the same:

1
2
3

There is also the .each_value method that achieves the same result and is also recommended by Rubocop:

items = {
  'A': 1,
  'B': 2,
  'C': 3
}

items.each_value do |value|
  puts value
end

Once again, the output is exactly the same as before:

1
2
3

rvm --default use <version number>

For example, to use 3.1.2 as the default version system-wide, run:

rvm --default use 3.1.2

Now this version will be used even when a new terminal tab or window is opened.

References:

• https://rvm.io/rubies/default

In the documentation, I discovered that Ruby’s Date class comes with two array constants that can help in this situation. Those constants are MONTHNAMES and ABBR_MONTHNAMES.

MONTHNAMES is an array of the full names of all the months.

# irb

> require 'date'

=> true

> Date::MONTHNAMES

=> [nil, "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]

ABBR_MONTHNAMES is an array of abbreviated month names.

# irb

> require 'date'

=> true

> Date::ABBR_MONTHNAMES

=> [nil, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]

In my situation, ABBR_MONTHNAMES will solve my problem since the data I’m parsing contains abbreviated month names. Now, when parsing Aug 20, 2020, I can run the following to get a numerical value for Aug:

# irb

> require 'date'

=> true

> Date::ABBR_MONTHNAMES.index('Aug')

=> 8

No need to create a hash or array myself, this constant gets the job done.

I noticed both arrays have nil as their first value. At first I asked “why?”, but it quickly became clear that the nil values are simply filler to take up index 0 since there is no month with this numerical value.

This was a nice discovery. Ruby continues to make writing code a pleasant experience.