5 Façons d'exécuter des commandes système en Ruby

Ruby est un langage de programmation puissant et polyvalent, souvent utilisé pour le développement web, l'automatisation et bien plus encore. L'une des fonctionnalités intéressantes de Ruby est sa capacité à interagir avec le système d'exploitation sous-jacent, ce qui permet d'exécuter des commandes système directement depuis votre code. Dans cet article, nous allons explorer cinq méthodes différentes pour exécuter des commandes système en Ruby, accompagnées d'exemples de code pour vous aider à comprendre comment les utiliser.

1. Utiliser la méthode `system`

La méthode `system` est l'une des façons les plus simples d'exécuter une commande système en Ruby. Elle exécute la commande spécifiée dans un sous-processus et renvoie `true` si la commande a réussi, ou `false` en cas d'échec.

Exemple d'utilisation de `system`

command = "ls -l"
if system(command)
  puts "Commande exécutée avec succès."
else
  puts "Échec de l'exécution de la commande."
end

Dans cet exemple, nous exécutons la commande `ls -l`, qui liste les fichiers dans le répertoire courant avec des détails. Si la commande réussit, un message de succès est affiché.

2. Utiliser la méthode ``backticks``

Les backticks (`` ` ``) sont une autre façon d'exécuter des commandes système en Ruby. Cette méthode exécute la commande et renvoie la sortie standard sous forme de chaîne de caractères. C'est utile lorsque vous souhaitez capturer la sortie d'une commande pour l'utiliser dans votre programme.

Exemple d'utilisation des backticks

output = `ls -l`
puts "La sortie de la commande est :"
puts output

Dans cet exemple, nous exécutons la même commande `ls -l`, mais cette fois, nous capturons la sortie et l'affichons. Cela vous permet de manipuler la sortie comme vous le souhaitez.

3. Utiliser la méthode `exec`

La méthode `exec` remplace le processus Ruby en cours par le programme spécifié. Cela signifie que le code Ruby suivant l'appel à `exec` ne sera pas exécuté. Cette méthode est utile lorsque vous souhaitez exécuter un programme et ne pas revenir à Ruby.

Exemple d'utilisation de `exec`

puts "Exécution de la commande..."
exec("ls -l")
puts "Cette ligne ne sera pas exécutée."

Dans cet exemple, la commande `ls -l` est exécutée, mais le message "Cette ligne ne sera pas exécutée." ne sera jamais affiché, car le processus Ruby a été remplacé par la commande exécutée.

4. Utiliser la classe `Open3`

La bibliothèque `Open3` fournit une interface pour exécuter des commandes système tout en capturant la sortie standard, la sortie d'erreur et le code de retour. Cela vous donne un contrôle plus granulaire sur l'exécution des commandes.

Exemple d'utilisation de `Open3`

require 'open3'

command = "ls -l"
stdout, stderr, status = Open3.capture3(command)

puts "Sortie standard :"
puts stdout
puts "Sortie d'erreur :"
puts stderr
puts "Code de retour : #{status.exitstatus}"

Dans cet exemple, nous utilisons `Open3.capture3` pour exécuter la commande `ls -l`. Nous capturons la sortie standard, la sortie d'erreur et le code de retour, ce qui nous permet de gérer les erreurs de manière plus efficace.

5. Utiliser la méthode `spawn`

La méthode `spawn` permet de lancer une commande dans un processus séparé et de continuer l'exécution du code Ruby. Cela peut être utile si vous souhaitez exécuter plusieurs commandes simultanément ou si vous ne voulez pas bloquer l'exécution de votre programme.

Exemple d'utilisation de `spawn`

pid = spawn("sleep 5")
puts "La commande est en cours d'exécution en arrière-plan avec le PID #{pid}."
Process.wait(pid)
puts "La commande est terminée."

Dans cet exemple, nous exécutons la commande `sleep 5` en arrière-plan. Le programme continue à s'exécuter pendant que la commande est en cours, et nous attendons ensuite que le processus se termine avant d'afficher le message final.

Conclusion

Ruby offre plusieurs façons d'exécuter des commandes système, chacune ayant ses propres avantages et inconvénients. Que vous souhaitiez exécuter une commande simple, capturer sa sortie ou gérer des processus en arrière-plan, Ruby a les outils nécessaires pour le faire. En utilisant les méthodes `system`, backticks, `exec`, `Open3` et `spawn`, vous pouvez facilement intégrer des commandes système dans vos applications Ruby.

Nous espérons que cet article vous a été utile et vous a donné une meilleure compréhension de la façon d'exécuter des commandes système en Ruby. N'hésitez pas à expérimenter ces méthodes dans vos propres projets et à explorer davantage les capacités de Ruby !