Retour au cours

les ranges (intervalles)

Objectifs

  • Créer un Range (intervalle) pour représenter une séquence.
  • Distinguer l’intervalle inclusif (..) de l’intervalle exclusif (...).
  • Utiliser des ranges pour contrôler des boucles et des conditions case.
  • Extraire des portions de tableaux ou de chaînes de caractères.

Un Range est un objet qui représente une séquence, un intervalle entre une valeur de début et une valeur de fin. C’est une manière très efficace et lisible de travailler avec des suites d’éléments.

Syntaxe

Il existe deux types de ranges, qui se distinguent par le nombre de points.

1. Intervalle inclusif (..)

Le range a..b inclut la valeur de fin b.

range_inclusif = 1..5
# Représente les nombres 1, 2, 3, 4, 5

2. Intervalle exclusif (...)

Le range a...b exclut la valeur de fin b.

range_exclusif = 1...5
# Représente les nombres 1, 2, 3, 4

Les ranges ne se limitent pas aux nombres, ils fonctionnent aussi avec les lettres. 'a'..'d' # Représente ‘a’, ‘b’, ‘c’, ‘d’

Utilisation des Ranges

1. Itération

Les ranges incluent le module Enumerable, ce qui signifie qu’ils répondent à .each et à toutes les autres méthodes d’itération. C’est la manière la plus idiomatique de créer une boucle sur une séquence de nombres.

# Boucle de 1 à 5
(1..5).each do |i|
  puts "Tour de boucle numéro #{i}"
end

Ceci est beaucoup plus clair et plus “Ruby” qu’une boucle while avec un compteur.

2. Conditions case

Les ranges sont parfaits pour tester si une valeur se trouve dans un intervalle.

age = 25

description = case age
              when 0..17
                "Mineur"
              when 18..64
                "Adulte"
              else
                "Senior"
              end

puts description # => "Adulte"

3. Extraire des sous-ensembles (Slicing)

On peut utiliser un range pour “découper” un Array ou une String.

lettres = ['a', 'b', 'c', 'd', 'e']
chaine = "Bonjour le monde"

# Extraire des éléments d'un tableau
puts lettres[1..3].inspect  # => ["b", "c", "d"]

# Extraire une sous-chaîne
puts chaine[0..6]          # => "Bonjour"

4. Vérifier l’appartenance

La méthode .cover? ou .include? permet de savoir si une valeur fait partie du range.

(1..100).cover?(42)   # => true
('a'..'z').include?('M') # => false (sensible à la casse)

Bonnes pratiques

  • Utilisez (a..b).each pour toutes vos boucles sur des séquences numériques. C’est plus lisible et moins sujet aux erreurs qu’une boucle while manuelle.
  • La syntaxe case avec des ranges est extrêmement claire pour gérer des conditions basées on des intervalles.

Exercices

  1. Table de multiplication :

    • Utilisez un range et la méthode .each pour afficher la table de multiplication de 5 (de 1 à 10).
    • Sortie attendue : “5 x 1 = 5”, “5 x 2 = 10”, etc.

  2. Classement par note :

    • Écrivez une structure case qui prend une variable note (un nombre de 0 à 20).
    • Elle doit afficher “A” pour une note de 16 à 20, “B” pour 12 à 15, “C” pour 10 à 11, et “D” pour le reste.

  3. Découpage de mot :

    • Soit la chaîne mot = "programmation".
    • Utilisez un range pour extraire et afficher la sous-chaîne “gram”.

  4. Inclusif vs. Exclusif :

    • Dans irb, convertissez les deux ranges 1..5 et 1...5 en tableaux avec la méthode .to_a.
    • Observez et expliquez la différence de résultat.

Sujets abordés