How do arrays and hashes work?

Question

Accepted Answer

**Arrays** are ordered collections; **hashes** are key-value collections (like dictionaries/maps). They're Ruby's two main data structures, both with rich, expressive methods (largely from the Enumerable module) that make data manipulation elegant.

## Arrays — ordered collections

```ruby
fruits = ["apple", "banana", "cherry"]
fruits[0]               # "apple" — index access
fruits[-1]              # "cherry" — negative indexes from the end
fruits << "date"        # append (or .push)
fruits.length           # size
fruits.include?("apple") # membership

# Ruby's elegant array methods (from Enumerable)
fruits.map { |f| f.upcase }          # transform each
fruits.select { |f| f.length > 5 }   # filter
fruits.each { |f| puts f }           # iterate
[3, 1, 2].sort                       # [1, 2, 3]
[1, 2, 3].sum                        # 6
```

Arrays are dynamic, ordered, indexed (with negative-index support), and have a rich set of methods (`map`, `select`, `reduce`, etc.) for elegant data processing.

## Hashes — key-value collections

```ruby
# symbol keys (the idiom) with modern syntax
user = { name: "Ann", age: 30, role: :admin }
user[:name]             # "Ann" — access by key
user[:email] = "a@x.com"  # add/set
user.key?(:name)         # check key existence
user.fetch(:name)        # access with an error if missing (or a default)

# iterate key-value pairs
user.each { |key, value| puts "#{key}: #{value}" }
user.keys; user.values
user.map { |k, v| "#{k}=#{v}" }
```

Hashes map keys to values. The idiomatic syntax uses **symbol keys** (`{ name: "Ann" }`), and hashes have rich methods for access, iteration, and transformation. `fetch` provides safe access (with a default or error for missing keys).

## Useful patterns

```ruby
# default values
counts = Hash.new(0)
counts[:x] += 1         # works even though :x wasn't set (default 0)

# nested structures (common for JSON-like data)
data = { users: [{ name: "Ann" }, { name: "Bob" }] }
data[:users].first[:name]    # "Ann"
```

## Why it matters

Arrays and hashes are Ruby's fundamental data structures — used constantly for storing and processing collections of data — so mastering them is essential everyday knowledge. **Arrays** (ordered, indexed collections with negative-index support) and **hashes** (key-value maps) cover the vast majority of data-handling needs (lists, records, configuration, JSON-like data).

What makes them particularly powerful in Ruby is their **rich, expressive method library** (largely from the Enumerable module) — `map`, `select`, `reduce`, `each`, and dozens more — which let you transform, filter, and process data elegantly with concise, readable code rather than verbose loops, embodying Ruby's expressive style.

Knowing the idiomatic conventions — especially **symbol keys for hashes** (`{ name: "Ann" }`) and useful patterns like `Hash.new(0)` for default values, `fetch` for safe access, and nested structures for complex data — is important for writing clean, idiomatic Ruby.

Since arrays and hashes appear in virtually every Ruby program, and since their rich methods are central to Ruby's elegant data-processing style (and to working with Rails, JSON, and APIs), fluency with them — creating, accessing, iterating, and transforming arrays and hashes with their expressive methods — is foundational, must-know knowledge that underpins effective, idiomatic Ruby development.