Rubis - Blocs

Vous avez vu comment Ruby définit des méthodes dans lesquelles vous pouvez mettre un certain nombre d'instructions, puis appeler cette méthode. De même, Ruby a un concept de Block.

• Un bloc se compose de morceaux de code.

• Vous attribuez un nom à un bloc.

• Le code du bloc est toujours entre accolades ({}).

• Un bloc est toujours appelé à partir d'une fonction portant le même nom que celui du bloc. Cela signifie que si vous avez un bloc avec le nom test , vous utilisez le test de fonction pour appeler ce bloc.

• Vous appelez un bloc à l'aide de l' instruction yield .

Syntaxe

block_name {
   statement1
   statement2
   ..........
}

Ici, vous apprendrez à appeler un bloc en utilisant une simple instruction yield . Vous apprendrez également à utiliser une instruction yield avec des paramètres pour appeler un bloc. Vous vérifierez l'exemple de code avec les deux types d' instructions de rendement .

La déclaration de rendement

Regardons un exemple de l'instruction yield -

#!/usr/bin/ruby

def test
   puts "You are in the method"
   yield
   puts "You are again back to the method"
   yield
end
test {puts "You are in the block"}

Cela produira le résultat suivant -

You are in the method
You are in the block
You are again back to the method
You are in the block

Vous pouvez également transmettre des paramètres avec l'instruction yield. Voici un exemple -

#!/usr/bin/ruby

def test
   yield 5
   puts "You are in the method test"
   yield 100
end
test {|i| puts "You are in the block #{i}"}

Cela produira le résultat suivant -

You are in the block 5
You are in the method test
You are in the block 100

Ici, l' instruction yield est écrite suivie de paramètres. Vous pouvez même passer plus d'un paramètre. Dans le bloc, vous placez une variable entre deux lignes verticales (||) pour accepter les paramètres. Par conséquent, dans le code précédent, l'instruction yield 5 transmet la valeur 5 en tant que paramètre au bloc de test.

Maintenant, regardez la déclaration suivante -

test {|i| puts "You are in the block #{i}"}

Ici, la valeur 5 est reçue dans la variable i . Maintenant, observez l' instruction put suivante -

puts "You are in the block #{i}"

La sortie de cette instruction put est -

You are in the block 5

Si vous souhaitez transmettre plusieurs paramètres, l' instruction yield devient -

yield a, b

et le bloc est -

test {|a, b| statement}

Les paramètres seront séparés par des virgules.

Blocs et méthodes

Vous avez vu comment un bloc et une méthode peuvent être associés l'un à l'autre. Vous appelez normalement un bloc à l'aide de l'instruction yield d'une méthode qui porte le même nom que celui du bloc. Par conséquent, vous écrivez -

#!/usr/bin/ruby

def test
   yield
end
test{ puts "Hello world"}

Cet exemple est le moyen le plus simple d'implémenter un bloc. Vous appelez le bloc de test à l'aide de l' instruction yield .

Mais si le dernier argument d'une méthode est précédé de &, alors vous pouvez passer un bloc à cette méthode et ce bloc sera affecté au dernier paramètre. Dans le cas où * et & sont présents dans la liste d'arguments, & devrait venir plus tard.

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

Cela produira le résultat suivant -

Hello World!

Blocs BEGIN et END

Chaque fichier source Ruby peut déclarer des blocs de code à exécuter pendant le chargement du fichier (les blocs BEGIN) et après la fin de l'exécution du programme (les blocs END).

#!/usr/bin/ruby

BEGIN { 
   # BEGIN block code 
   puts "BEGIN code block"
} 

END { 
   # END block code 
   puts "END code block"
}
   # MAIN block code 
puts "MAIN code block"

Un programme peut inclure plusieurs blocs BEGIN et END. Les blocs BEGIN sont exécutés dans l'ordre dans lequel ils sont rencontrés. Les blocs END sont exécutés dans l'ordre inverse. Lorsqu'il est exécuté, le programme ci-dessus produit le résultat suivant -

BEGIN code block
MAIN code block
END code block