Ruby Academy · Leçon

Écrire un each personnalisé

Implémentez l’itération

Écrire un each personnalisé est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Implémenter l'itération

L'itération de Ruby repose sur une seule méthode : each. En écrivant votre propre each, vous décidez comment parcourir une collection et débloquez tout l'écosystème de l'itération.

class Trio
  def each
    yield 1
    yield 2
    yield 3
  end
end
Trio.new.each { |n| puts n }

each transmet des valeurs

Dans each, appelez yield une fois par élément. Le bloc fourni par l'appelant reçoit chaque valeur à tour de rôle.

class Days
  NAMES = ["Mon", "Tue", "Wed"]
  def each
    NAMES.each { |d| yield d }
  end
end
Days.new.each { |day| puts day }

Stocker les données internes

En général, each parcourt les données conservées dans une variable d'instance.

class Stack
  def initialize
    @items = []
  end
  def push(x); @items << x; self; end
  def each
    @items.each { |i| yield i }
  end
end
s = Stack.new
s.push(10).push(20)
s.each { |x| puts x }

Ordre de parcours personnalisé

Votre each peut parcourir les éléments dans l'ordre de votre choix, par exemple dans l'ordre inverse.

class Reversed
  def initialize(arr); @arr = arr; end
  def each
    i = @arr.length - 1
    while i >= 0
      yield @arr[i]
      i -= 1
    end
  end
end
Reversed.new([1, 2, 3]).each { |x| puts x }

Transmettre plusieurs valeurs

yield peut transmettre plusieurs valeurs, que le bloc reçoit comme plusieurs paramètres, par exemple la clé et la valeur d'un hachage.

class Pairs
  def each
    yield :a, 1
    yield :b, 2
  end
end
Pairs.new.each { |key, value| puts "#{key}=#{value}" }

each renvoie la collection

Par convention, each renvoie la collection elle-même afin de permettre l'enchaînement des appels. Renvoyer self depuis each reproduit le comportement intégré au langage.

class Box
  def initialize(*x); @x = x; end
  def each
    @x.each { |i| yield i }
    self
  end
end
result = Box.new(1, 2).each { |i| }
puts result.class

Gérer l'absence de bloc

Prévoyez le cas où le bloc est absent afin qu'un appel isolé à each n'échoue pas, souvent en renvoyant un énumérateur, que nous étudierons plus tard.

class List
  def initialize(*x); @x = x; end
  def each
    return @x.to_enum unless block_given?
    @x.each { |i| yield i }
  end
end
puts List.new(5, 6).each.class

Faire fonctionner d'autres méthodes

Une fois que each existe, vous pouvez construire d'autres méthodes à partir de lui dans la même classe.

class Numbers
  def initialize(*n); @n = n; end
  def each; @n.each { |i| yield i }; end
  def total
    sum = 0
    each { |i| sum += i }
    sum
  end
end
puts Numbers.new(1, 2, 3, 4).total

Séquences calculées

each n'a pas besoin de stocker quoi que ce soit ; il peut générer les valeurs à la volée.

class Evens
  def initialize(limit); @limit = limit; end
  def each
    n = 0
    while n <= @limit
      yield n
      n += 2
    end
  end
end
Evens.new(8).each { |x| puts x }

La base du module itérable

Votre each est le seul élément de construction dont Enumerable a besoin. Dans la prochaine leçon, vous l'inclurez et obtiendrez gratuitement des dizaines de méthodes.

class Range3
  def each
    (1..3).each { |n| yield n }
  end
end
Range3.new.each { |n| print n }
puts

Tout mettre en place

Un each personnalisé vous donne un contrôle total sur l'itération :

yield une fois par élément.
Parcourez les éléments dans n'importe quel ordre, générez des valeurs ou transmettez des paires.
Renvoyez self par convention.

class Countdown
  def initialize(from); @from = from; end
  def each
    @from.downto(1) { |n| yield n }
  end
end
Countdown.new(3).each { |n| puts n }

Vérification rapide

Évaluez votre compréhension d'un each personnalisé.

Récapitulatif

Vous avez appris à écrire un each personnalisé :

yield transmet les éléments au bloc de l'appelant.
Vous contrôlez l'ordre du parcours et pouvez générer des valeurs.
Renvoyez self par convention.
each constitue la base du module Enumerable.

class Squares
  def initialize(n); @n = n; end
  def each
    (1..@n).each { |i| yield i * i }
  end
end
Squares.new(4).each { |sq| puts sq }

Questions Fréquemment Posées

La leçon « Écrire un each personnalisé » est-elle gratuite ?

Oui — le texte complet de « Écrire un each personnalisé » 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 « Écrire un each personnalisé » ?

Implémentez l’itération 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 1 sur 4.

Combien de temps prend la leçon « Écrire un each personnalisé » ?

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