Ruby — Hash, méthodes et blocs

Section 13.1.4 : Ruby — Hash, méthodes et blocs

🎯 Objectif pédagogique

Maîtriser les Hash (dictionnaires), écrire des méthodes Ruby propres et comprendre les blocs — le mécanisme le plus élégant et distinctif du langage Ruby.

Hash : les dictionnaires Ruby

Un Hash est une collection de paires clé-valeur. Contrairement à un Array indexé par position, un Hash permet d'accéder aux valeurs par une clé nommée.

# Syntaxe moderne (clés symboles - PRÉFÉRÉ)
personne = { nom: 'Alice', age: 28, ville: 'Paris' }
personne[:nom]    # 'Alice'
personne[:age]    # 28

# Ajouter / Modifier
personne[:email] = 'alice@example.com'
personne[:age] = 29

# Supprimer
personne.delete(:ville)

# Vérifications
personne.key?(:nom)      # true
personne.empty?           # false
personne.length           # 3

Itération sur les Hash

personne = { nom: 'Alice', age: 28, email: 'alice@example.com' }

personne.each do |cle, valeur|
  puts "#{cle}: #{valeur}"
end

personne.keys     # [:nom, :age, :email]
personne.values   # ['Alice', 28, 'alice@example.com']

personne.map { |k, v| "#{k}=#{v}" }
personne.select { |k, v| v.is_a?(String) }

Hash imbriqués

utilisateurs = {
  alice: {
    nom: 'Alice Martin',
    age: 28,
    competences: ['Ruby', 'JavaScript', 'SQL'],
    adresse: { ville: 'Paris', cp: '75001' }
  },
  bob: {
    nom: 'Bob Dupont',
    age: 32,
    competences: ['Python', 'Docker', 'AWS'],
    adresse: { ville: 'Lyon', cp: '69001' }
  }
}

utilisateurs[:alice][:nom]                  # 'Alice Martin'
utilisateurs[:alice][:adresse][:ville]      # 'Paris'
utilisateurs.dig(:alice, :adresse, :ville)  # 'Paris' (accès sécurisé)
utilisateurs.dig(:charlie, :nom)            # nil (pas d erreur)

Les méthodes

En Ruby, les méthodes retournent implicitement la dernière expression évaluée — pas besoin de return.

def saluer(prenom, langue = 'fr')
  case langue
  when 'fr' then "Bonjour, #{prenom} !"
  when 'en' then "Hello, #{prenom}!"
  when 'es' then "Hola, #{prenom}!"
  else "Hi, #{prenom}!"
  end
end

saluer('Alice')       # Bonjour, Alice !
saluer('Bob', 'en')   # Hello, Bob!

# Keyword arguments
def creer_utilisateur(nom:, email:, role: :viewer)
  { nom: nom, email: email, role: role }
end

creer_utilisateur(nom: 'Alice', email: 'alice@test.com')

# Méthodes prédicats (?), destructives (!)
def majeur?(age)
  age >= 18
end

Les blocs : la signature de Ruby

Les blocs sont des morceaux de code anonymes passés à une méthode. Deux syntaxes :

# do...end (multi-ligne)
[1, 2, 3].each do |nombre|
  puts nombre * 2
end

# { } (une ligne)
[1, 2, 3].each { |nombre| puts nombre * 2 }

Créer ses propres méthodes avec yield

def avec_timing
  debut = Time.now
  yield
  duree = Time.now - debut
  puts "Exécuté en #{duree.round(3)} secondes"
end

avec_timing do
  sleep(1)
  puts 'Travail en cours...'
end

Procs et Lambdas

carre = Proc.new { |n| n ** 2 }
carre.call(5)           # 25
[1, 2, 3].map(&carre)   # [1, 4, 9]

double = ->(n) { n * 2 }
double.call(5)           # 10
[1, 2, 3].map(&double)   # [2, 4, 6]