0Pricing
Ruby Academy · Leçon

Fermetures et portée

Capturez des variables

Fermetures et portée est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Capturer des variables

Une fermeture est une fonction qui mémorise les variables de l’endroit où elle a été définie, même après la fin de l’exécution à cet endroit. Les Proc et les lambdas sont des fermetures.

name = "Ada"
greeter = -> { puts "Hello, #{name}" }
greeter.call

La variable reste liée

La fermeture ne copie pas la valeur ; elle conserve une référence active vers la variable. Si vous modifiez la variable ultérieurement, la fermeture voit la nouvelle valeur.

count = 0
reader = -> { count }
count = 5
puts reader.call

Les fermetures peuvent modifier leur état

Comme la référence reste active, une fermeture peut également modifier la variable capturée.

total = 0
adder = ->(n) { total += n }
adder.call(3)
adder.call(7)
puts total

Survivre à la méthode englobante

La variable capturée continue d’exister aussi longtemps que la fermeture, même après le retour de la méthode qui l’a créée.

def counter
  n = 0
  -> { n += 1 }
end
c = counter
puts c.call
puts c.call
puts c.call

États indépendants

Chaque appel à la méthode fabrique crée une nouvelle variable ; des fermetures distinctes conservent donc des états distincts.

def counter
  n = 0
  -> { n += 1 }
end
a = counter
b = counter
puts a.call
puts a.call
puts b.call

Les paramètres de bloc sont locaux

Les paramètres déclarés entre les barres verticales sont locaux au bloc et ne débordent jamais à l’extérieur, même si une variable portant le même nom existe.

x = 100
[1, 2, 3].each { |x| }
puts x  # still 100

Variables locales au bloc

Ajoutez des noms supplémentaires après un point-virgule entre les barres verticales pour les rendre locaux au bloc et protéger les variables extérieures contre toute modification accidentelle.

y = "outer"
[1].each { |i; y| y = "inner" }
puts y  # unchanged

Créer des fonctions configurables

Les fermetures vous permettent d’intégrer une configuration dans une fonction une seule fois, puis de la réutiliser de nombreuses fois.

def power_of(exp)
  ->(base) { base ** exp }
end
square = power_of(2)
cube = power_of(3)
puts square.call(5)
puts cube.call(2)

Les fermetures dans les itérations

Un piège courant : une fermeture créée dans une boucle capture la variable, et non un instantané de sa valeur. Créer une fermeture à chaque itération permet de capturer chaque valeur séparément.

funcs = [1, 2, 3].map { |i| -> { i } }
puts funcs.map(&:call).inspect

Encapsuler un état privé

Les fermetures peuvent dissimuler un état derrière des fonctions, ce qui constitue une forme primitive d’objet. Ici, le solde est inaccessible autrement que par les lambdas renvoyées.

def make_account(start)
  balance = start
  deposit = ->(n) { balance += n }
  show = -> { balance }
  [deposit, show]
end
dep, show = make_account(100)
dep.call(50)
puts show.call

Mise en pratique

Les fermetures associent le code à l’endroit où il a été créé :

  • Elles capturent des références actives vers les variables environnantes.
  • L’état persiste après le retour de la méthode englobante.
  • Chaque fermeture conserve ses propres variables indépendantes.
def tagger(prefix)
  ->(text) { "[#{prefix}] #{text}" }
end
warn = tagger("WARN")
puts warn.call("low disk space")

Vérification rapide

Vérifiez votre compréhension des fermetures.

Récapitulatif

Vous avez appris les fermetures et la portée :

  • Les Proc et les lambdas capturent les variables environnantes par référence.
  • L’état capturé persiste au-delà de la méthode englobante.
  • Chaque fermeture conserve un état indépendant.
  • Les paramètres de bloc restent locaux ; utilisez ; pour les variables locales au bloc.
def stepper(by)
  pos = 0
  -> { pos += by }
end
s = stepper(5)
puts s.call
puts s.call

Questions Fréquemment Posées

La leçon « Fermetures et portée » est-elle gratuite ?

Oui — le texte complet de « Fermetures et portée » 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 « Fermetures et portée » ?

Capturez des variables 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 4 sur 4.

Combien de temps prend la leçon « Fermetures et portée » ?

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

  1. Récapitulatif des blocs
  2. Procs
  3. Lambdas
  4. Fermetures et portée
← Retour à Ruby Academy