Comment fonctionnent les tableaux et les hachés ?

Question

Accepted Answer

**Les tableaux** sont des collections ordonnées ; **les hachés** sont des collections clé-valeur (comme des dictionnaires/maps). Ce sont les deux principales structures de données de Ruby, toutes deux dotées de méthodes riches et expressives (largement issues du module Enumerable) qui rendent la manipulation de données élégante.

## Tableaux — collections ordonnées

```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
```

Les tableaux sont dynamiques, ordonnés, indexés (avec support des index négatifs), et disposent d'un ensemble riche de méthodes (`map`, `select`, `reduce`, etc.) pour un traitement de données élégant.

## Hachés — collections clé-valeur

```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}" }
```

Les hachés mappent les clés aux valeurs. La syntaxe idiomatique utilise des **clés symboles** (`{ name: "Ann" }`), et les hachés ont des méthodes riches pour l'accès, l'itération et la transformation. `fetch` offre un accès sûr (avec une valeur par défaut ou une erreur pour les clés manquantes).

## Motifs utiles

```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"
```

## Pourquoi c'est important

Les tableaux et les hachés sont les structures de données fondamentales de Ruby — utilisés constamment pour stocker et traiter des collections de données — donc les maîtriser est une connaissance essentielle du quotidien. **Les tableaux** (collections ordonnées indexées avec support des index négatifs) et **les hachés** (maps clé-valeur) couvrent la vast majorité des besoins en matière de traitement de données (listes, enregistrements, configuration, données de type JSON).

Ce qui les rend particulièrement puissants dans Ruby, c'est leur **bibliothèque de méthodes riche et expressive** (largement issue du module Enumerable) — `map`, `select`, `reduce`, `each` et des dizaines d'autres — qui vous permettent de transformer, filtrer et traiter les données de façon élégante avec du code concis et lisible plutôt que des boucles verboselles, incarnant le style expressif de Ruby.

Connaître les conventions idiomatiques — en particulier les **clés symboles pour les hachés** (`{ name: "Ann" }`) et les motifs utiles comme `Hash.new(0)` pour les valeurs par défaut, `fetch` pour un accès sûr, et les structures imbriquées pour les données complexes — est important pour écrire du Ruby propre et idiomatique.

Puisque les tableaux et les hachés apparaissent dans pratiquement chaque programme Ruby, et puisque leurs méthodes riches sont centrales au style de traitement de données élégant de Ruby (et au travail avec Rails, JSON et les APIs), la maîtrise — créer, accéder, itérer et transformer les tableaux et les hachés avec leurs méthodes expressives — est une connaissance fondamentale et incontournable qui sous-tend un développement Ruby efficace et idiomatique.