Golang exec

Le package EXEC est défini sous le package OS. C'est simplement un sous-package qui vous permet d'exécuter des commandes externes en utilisant Go.

Dans ce guide, nous explorerons comment nous pouvons utiliser le package Exec pour exécuter des commandes externes.

Importation du package Exec

Pour utiliser le package Exec, nous devons l'importer. Nous pouvons le faire en utilisant une commande d'importation simple comme:

Importer "OS / EXEC"

Une fois importé, vous pouvez exécuter des commandes, comme nous le verrons dans cet article.

Golang exécuter les commandes

Commençons par un appel de commande de base pour illustrer comment utiliser le package Exec. Un exemple de code est comme indiqué ci-dessous:

package principal
importer (
"FMT"
"enregistrer"
"OS / EXEC"
)
funcmain ()
cmd: = exec.Commande ("dir")
sortie, err: = cmd.CombinedOutput ()
Si err != nil
enregistrer.Fatal (euh)

fmt.Printf ("output: \ n% s \ n", string (sortie))

Dans l'exemple ci-dessus, nous utilisons la commande exec pour obtenir la liste des fichiers et répertoires à l'aide de la commande dir.

Nous commençons par définir la commande pour exécuter en utilisant la méthode de commande. La syntaxe est comme indiqué:

Commande func (nom de nom, arg… chaîne) * cmd

La fonction prend les commandes pour s'exécuter comme un argument de chaîne. Il renvoie ensuite une structure de commande pour exécuter la commande avec les arguments fournis.

L'étape suivante consiste à exécuter la commande à l'aide de la méthode combinée. La syntaxe de la méthode est comme indiqué:

func (c * cmd) combinée

La méthode exécute la commande et renvoie le stdout combiné et le stderr. Cela renvoie une tranche d'octets, que nous convertissons en une chaîne en utilisant la méthode de chaîne.

Une fois que vous avez exécuté le code ci-dessus, il doit renvoyer les fichiers et répertoires dans le répertoire de travail actuel.

Définir le répertoire de travail actuel

Nous pouvons définir le répertoire de travail actuel sur lequel exécuter la commande à l'aide du CMD.Variable DIR. Un exemple est comme indiqué:

package principal
importer (
"FMT"
"enregistrer"
"OS / EXEC"
)
funcmain ()
cmd: = exec.Commande ("dir")
CMD.Dir = "…"
sortie, err: = cmd.CombinedOutput ()
Si err != nil
enregistrer.Fatal (euh)

fmt.Printf ("output: \ n% s \ n", string (sortie))

Capture Stdout & Stderr séparément.

Au lieu de combiner STDOUT et STDERR, vous pouvez les capturer séparément comme indiqué dans le code ci-dessous:

cmd: = exec.Commande ("dir")
CMD.Dir = "…"
var stdout, stderr octets.Amortir
CMD.Stderr = & stderr
CMD.Stdout = & stdout
err: = cmd.Courir()
Si err != nil
enregistrer.Fatal (euh)

sortie, err: = string (stdout.Bytes ()), chaîne (stderr.Octets ())

Spécifier le système d'exploitation

Vous pouvez également définir des commandes personnalisées pour un système d'exploitation différent en utilisant l'exécution.Méthode de Goos. Par exemple:

ifruntime.Goos == "Windows"
cmd = exec.Commande ("dir")

Commandes de tuyaux

Vous pouvez également tuer la sortie d'une commande précédente comme indiqué dans l'exemple ci-dessus:

package principal
importer (
"FMT"
"enregistrer"
"OS / EXEC"
)
funcmain ()
first_cmd: = 'echo "Hello World" | wc -c '
cmd: = exec.Commande ("bash", "-c", first_cmd)
sortie, err: = cmd.CombinedOutput ()
Si err != nil
enregistrer.Fatal (euh)

fmt.Printf ("output \ n% s \ n", string (sortie))

La commande ci-dessus doit renvoyer le nombre de caractères de la commande echo.

Fermeture

Ce court guide illustre comment démarrer avec le package Exec à Golang.