web-dev-qa-db-fra.com

Comment obtenez-vous le résultat d'une commande système dans Go?

Disons que je veux exécuter 'ls' dans un programme go et stocker les résultats dans une chaîne. Il semble y avoir quelques commandes pour créer des processus dans les packages exec et os, mais elles nécessitent des arguments de fichier pour stdout, etc. Y a-t-il un moyen d'obtenir le résultat sous forme de chaîne?

go
37
marketer

Edit: Cette réponse est obsolète. S'il vous plaît voir réponse de Fatih Arslan ci-dessous.

Utilisez exec.Run en spécifiant Pipe en tant que sortie standard (et stderr si vous le souhaitez). Il retournera cmd, qui contient un os.Fichier dans les champs Stdout (et Stderr). Ensuite, vous pouvez le lire en utilisant par exemple ioutil.ReadAll .

Exemple:

package main

import (
    "exec";
    "io/ioutil";
)

func main() {
    if cmd, e := exec.Run("/bin/ls", nil, nil, exec.DevNull, exec.Pipe, exec.MergeWithStdout); e == nil {
        b, _ := ioutil.ReadAll(cmd.Stdout)
        println("output: " + string(b))
    }
}
0
Randy Sugianto 'Yuku'

Il y a un moyen plus facile maintenant:

package main

import (
    "fmt"
    "log"
    "os/exec"
)

func main() {
    out, err := exec.Command("date").Output()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("The date is %s\n", out)
}

Où out est la sortie standard. Il est au format []byte, mais vous pouvez le changer facilement en chaîne avec:

string(out)

Vous pouvez également utiliser CombinedOutput() au lieu de Output(), qui renvoie la sortie standard et l'erreur standard.

137
Fatih Arslan

Pour obtenir à la fois stdout et stderr dans des chaînes séparées, vous pouvez utiliser des buffers d'octets comme ceci:

cmd := exec.Command("date")
var outb, errb bytes.Buffer
cmd.Stdout = &outb
cmd.Stderr = &errb
err := cmd.Run()
if err != nil {
    log.Fatal(err)
}
fmt.Println("out:", outb.String(), "err:", errb.String())
13
Travis Reeder

Utilisez exec.Run , en passant Pipe pour stdout. Lire dans le tuyau qu'il retourne.

2
Andru Luvisi

Deux options, selon le paradigme que vous préférez:

  1. os.ForkExec ()
  2. exec.Run ()
1
esm

Je l'ai utilisé avec une version récente de GO (~ 1.11)

// CmdExec Execute a command
func CmdExec(args ...string) (string, error) {

    baseCmd := args[0]
    cmdArgs := args[1:]

    log.Debugf("Exec: %v", args)

    cmd := exec.Command(baseCmd, cmdArgs...)
    out, err := cmd.Output()
    if err != nil {
        return "", err
    }

    return string(out), nil
}

// Usage:
// out, err := CmdExec("ls", "/home")
0
lcapra