Ruby Academy · Leçon

Énumérateurs paresseux

Évaluation paresseuse

Énumérateurs paresseux est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Évaluation différée

Normalement, les méthodes Enumerable traitent la collection entière en une seule fois. Un énumérateur différé traite les éléments un par un, uniquement lorsque cela est nécessaire. Vous pouvez ainsi travailler avec des séquences très volumineuses, voire infinies.

result = (1..Float::INFINITY).lazy.map { |n| n * 2 }.first(5)
p result

Le problème des méthodes immédiates

Appeler map sur une plage infinie sans lazy ne se terminerait jamais, car Ruby essaierait d'abord de construire un tableau de résultats complet.

# Eager version would hang. Lazy completes instantly:
first_three = (1..Float::INFINITY).lazy.select(&:even?).first(3)
p first_three

Créer un énumérateur différé

Appelez .lazy sur n'importe quel objet itérable pour obtenir une version différée. Les méthodes enchaînées deviennent alors différées elles aussi.

lazy = (1..10).lazy
puts lazy.class

Rien ne s'exécute avant le déclenchement

Les enchaînements différés construisent une recette, mais ne l'exécutent pas. Une méthode terminale comme first, to_a ou force déclenche le traitement.

chain = (1..Float::INFINITY).lazy.map { |n| n * n }
puts "Nothing computed yet"
p chain.first(4)

Déclencher les résultats

force (alias de to_a) matérialise un enchaînement différé limité sous la forme d'un tableau.

result = (1..20).lazy.select(&:odd?).first(5)
p result
all = (1..6).lazy.map { |n| n * 10 }.force
p all

Enchaîner les opérations en différé

Plusieurs opérations différées sont entrelacées élément par élément au lieu d'être exécutées comme plusieurs parcours complets distincts. Chaque valeur traverse tout l'enchaînement avant que la suivante ne commence.

result = (1..Float::INFINITY)
  .lazy
  .map { |n| n * n }
  .select { |n| n.even? }
  .first(4)
p result

take et prise conditionnelle

take et take_while en mode différé cessent de demander des valeurs dès que leur condition est satisfaite.

result = (1..Float::INFINITY).lazy.take_while { |n| n < 6 }.to_a
p result

Séquences infinies

Les énumérateurs différés sont particulièrement utiles avec les générateurs. Associez-les à Enumerator pour modéliser des flux sans fin.

naturals = Enumerator.new do |y|
  n = 1
  loop { y << n; n += 1 }
end
p naturals.lazy.map { |x| x * 3 }.first(5)

Efficacité mémoire

Comme les enchaînements différés ne matérialisent jamais toute la collection intermédiaire, ils économisent de la mémoire lorsque vous réduisez un grand volume de données à quelques résultats.

big = (1..1_000_000).lazy
first_match = big.select { |n| n % 7 == 0 && n % 11 == 0 }.first
puts first_match

Quand utiliser l'évaluation différée

Utilisez l'évaluation différée lorsque :

La source est infinie ou très volumineuse.
Vous n'avez besoin que de quelques résultats.
Vous voulez éviter de grands tableaux intermédiaires.

Pour les petites collections, les méthodes immédiates sont plus simples et suffisamment rapides.

fizz = (1..Float::INFINITY).lazy.select { |n| n % 3 == 0 }.first(5)
p fizz

Tout mettre en place

Les énumérateurs différés reportent le traitement :

.lazy rend un enchaînement différé.
Le traitement ne s'exécute que lorsqu'une méthode terminale demande des valeurs.
Cette approche convient parfaitement aux séquences infinies ou très volumineuses.

squares = (1..Float::INFINITY).lazy.map { |n| n * n }
p squares.select(&:odd?).first(4)

Vérification rapide

Évaluez votre compréhension des énumérateurs différés.

Récapitulatif

Vous avez découvert les énumérateurs différés :

.lazy reporte le calcul.
Les méthodes terminales (first, to_a, force) déclenchent le traitement.
Chaque valeur traverse tout l'enchaînement à la demande.
Cette approche est idéale pour les séquences infinies ou volumineuses.

p (1..Float::INFINITY).lazy.select(&:even?).map { |n| n + 1 }.first(3)

Questions Fréquemment Posées

La leçon « Énumérateurs paresseux » est-elle gratuite ?

Oui — le texte complet de « Énumérateurs paresseux » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Énumérateurs paresseux » ?

Évaluation paresseuse Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Énumérateurs paresseux » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy