Procs et Lambdas

Fait partie de la section Logique et Flux du Journey Ruby de Coddy — leçon 19 sur 56.

Un bloc n'est pas un objet, vous ne pouvez pas le stocker dans une variable. Lorsque vous voulez un morceau de code que vous pouvez transmettre, sauvegarder et appeler plus tard, vous l'enveloppez dans un Proc ou un lambda.

Un Proc est créé avec Proc.new ou le mot-clé proc. Appelez-le avec .call :

double = proc { |n| n * 2 }
puts double.call(5)   # 10
puts double.call(7)   # 14

Une lambda est similaire mais plus stricte, elle vérifie que vous passez le bon nombre d'arguments. La forme fléchée -> est l'écriture courante :

square = ->(n) { n * n }
puts square.call(4)   # 16
puts square.(4)       # 16  (raccourci pour .call)

Les deux peuvent être passés à une méthode qui attend un bloc en les préfixant par & :

[1, 2, 3].map(&double)   # [2, 4, 6]
[1, 2, 3].map(&square)   # [1, 4, 9]

Utilisez un lambda lorsque vous voulez une vérification des arguments plus stricte ; utilisez un Proc lorsque vous voulez un comportement plus léger et plus indulgent.

Défi

Facile

Créez un lambda nommé tripler qui prend un nombre et le retourne multiplié par 3.

Ensuite, lisez une liste d'entiers séparés par des virgules et affichez, sur des lignes distinctes :

Le résultat de l'appel tripler.call(10)
Les nombres d'entrée triplés (utilisez map(&tripler)) et joints avec ,

Pour l'entrée 1,2,3, la sortie est :

30
3, 6, 9

Aide-mémoire

Proc – bloc réutilisable stocké dans une variable :

double = proc { |n| n * 2 }
double.call(5)   # 10

Lambda – vérification plus stricte des arguments, syntaxe fléchée :

square = ->(n) { n * n }
square.call(4)   # 16
square.(4)       # 16 (raccourci)

Passer un Proc/lambda à une méthode attendant un bloc en utilisant & :

[1, 2, 3].map(&double)   # [2, 4, 6]

Essayez vous-même

# À FAIRE : définir `tripler` comme un lambda

numbers = gets.chomp.split(",").map(&:to_i)

# À FAIRE : ligne 1, afficher tripler.call(10)
# À FAIRE : ligne 2, mapper numbers avec &tripler, joindre avec ", "