Ruby et ses blocs

Sunny Ripert 10 ans que je fais du Ruby appris des choses sur les blocs l’année dernière pratique du bloc depuis l’année dernière

Premier groupe de financement participatif européen à permettre à la foule de se faire financer par la foule peu importe le projet KissKissBankBank don contre don ou de la prévente lancement de projets, projets associatifs LENDOPOLIS prêts rémunérés de particuliers à entrepreneurs financement rapide d’entreprises en phase de développement prêteurs sont des particuliers qui investissent dans des PME du quotidien et de soutenir l’économie locale hellomerci via des prêts entre particulier à taux 0 financer son permis, son mariage, sa caution d’appartement collecter une somme auprès de son entourage et de leur rembourser selon ses possibilités de façon automatisée

Les Blocs

Boucler Filtrer et Transformer Nettoyer DSLs Exemples 3.times { puts “Penny” } (2..99).select|num| { num.even? }.map |num| { -num } File.open( “data.csv” ,”w”) do |file| file.puts “A,B,C” file.puts “1,2,3” end get”/hi”do “Hello World!” end

“Closures” Du code + un environnement de variables “Fermetures Lexicales”

Vous vous servez de blocs J’aimerais que vous sachiez construire avec des blocs Faites votre propre times, select , map , open, ou votre propre DSL 2. Premiers pas

Acceptez des blocs avec yield deftwice yield”first” yield”last” end twice {|item|puts”Hey #{item}!” } # => Hey first! # Hey last!

ça transforme notre code en un objet le passer à d’autres méthodes Acceptez des blocs avec & deftwice(&action) action.call( “first” ) action.call( “last” ) end twice {|item|puts”Hey #{item}!” } # => Hey first! # Hey last!

appeler des méthodes dessus introspection Acceptez des blocs avec & deftwice(&action) action.call(action. class ) action.call(action. class ) end twice {|item|puts”Hey #{item}!” } # => Hey Proc! # => Hey Proc!

Procs

Proc.new greeter = Proc.new do |item| puts “Hey #{item}!” end greeter.call( “first” ) greeter.call( “last” ) # => Hey first! # Hey last!

Ruby Style Guide Proc.new { … } proc { … }

Permettent d’accepter plusieurs blocs Exemple defsave(error: ,success: ) iftrue success.call else error.call end end saveerror:proc { puts “:(“}, success:proc { puts “:)”} # => :)

& transforme un proc en bloc increment = proc|n| { n +1 } double = proc |n| { n *2 } [1,2,3].map(&increment) # => [2, 3, 4] .map(&double) # => [4, 6, 8] .map(&increment) # => [5, 7, 9]

& appelle to_proc %w(fou barre spamme) .map {|word|word.length #} => [3, 5, 6] %w(fou barre spamme) .map(&:length ) # => [3, 5, 6]

Apparu dans Rails 1.1.1 Puis intégré dans Ruby 1.9 et 1.8.7 Vous pouvez ajouter to_proc dans vos propres méthodes & appelle to_proc %w(fou barre spamme) .map {|word|word.length #} => [3, 5, 6] %w(fou barre spamme) .map(&:length ) # => [3, 5, 6] classSymbol defto_proc Proc.new|obj| { obj.send( self ) } end end

Lambdas

Comme les procs proc { … } lambda { … }

Comme les procs proc { … }. class# => Proc lambda { … }. class# => Proc

Comme les procs proc { … }# => #Proc:0x007f8ab31ba1f8@(irb):1 lambda { … }# => #<Proc:0x007f8ab3813590@(irb):2 (lambda)>

Comme une méthode DiGérence #1 Les lambdas vériJent le nombre d’arguments passés. test_proc = proc |a, b| {[a, b] } test_lambda = lambda|a, { b| [a, b] } test_proc.call( 42) # => [42, nil] test_lambda.call( 42) # ArgumentError: wrong number of arguments (1 for 2)

Proc plus proche d’une syntaxe de bloc normale comme une boucle each Lambda plus proche d’une méthode aussi DiGérence #2 Dans un proc, returnarrête le code autour de son bloc. deftest_proc a = procreturn”You { shall not pass!” } result = a.call “Result: #{result} ” # Code jamais atteint end test_proc # => “You shall not pass!” Dans un lambda, returnn’arrête que son propre bloc. deftest_lambda a = lambdareturn”You { shall pass!” } result = a.call “Result: #{result} ” end test_lambda# => “Result: You shall pass!”

moins de surprise avec le lambda DiGérence #3 Si on lui passe un array, le proc le transforme en arguments. test_proc = proc |a, b{ nil = | [a, b] } test_lambda = lambda|a, { b nil = | [a, b] } test_proc.call([ 1,2,3])# => [1, 2] test_lambda.call([ 1,2,3])# => [[1, 2, 3], nil]

Ruby 2 Flèche =~ lambda Yukihiro Matsumoto 5 chars de moins Quelqu’un de lambda lambda {|foo, bar| … } -> foo, bar { … }

Dans la première ligne vous serez obligé de redémarrer votre serveur Web pour que Time.now change Depuis Rails 4, vous serez obligé d’utiliser la deuxième syntaxe avec un objet apellable Exemple classArticle< ActiveRecord::Base scope:published , where( ‘published_at ,< Time.now) ?’ scope:published , -> { where( ‘published_at ,< Time.now) ?’ } end

Arguments

Arguments par défaut proc {|foo, bar=”Meh”| … } -> foo, bar= “Meh” { … } Comme une méthode.

Arguments nommés proc {|city: “Paris”, …age:| } -> city:”Paris” ,age: { … } Comme une méthode.

Arguments ignorés proc {|_foo, _foo| “…” } -> _foo, _foo”…” { } Comme une méthode.

Méthodes pour les appeler

Comme une méthode .() increment = -> num { num1 +} increment.call( 41) # => 42 increment.( 41) # => 42

Peut être substitué à un hash ou un array [] increment = -> num { num1 +} increment[ 41] # => 42

=== number = 41.9 case number when 42 “Exactly 42!” when -> n { n41.5 > && n < 43.5 } “Close enough” end # => “Close enough”

les méthodes peuvent être stockées dans des variables aussi plus proches d’un lambda que d’un proc Un objet à partir d’une méthode defincrement(number) number +1 end inc = method( :increment ) inc.call( 5) # => 6 inc. class# => Method

on appelle to_procsur l’objet méthode De la méthode jusqu’au bloc en passant par le proc [1,2].each |number| { puts number } [1,2].each(&method( :puts )) # 1 # 2

Bravo Faites des blocs, procs, lambdas, des API Ruby propres et des DSLs simples

Merci