Stdout-Pipe des untergeordneten Prozesses in Go umleiten

Ich schreibe ein Programm in Go, das ein serverähnliches Programm ausführt (auch Go). Jetzt möchte ich die Standardausgabe des untergeordneten Programms in meinem Terminalfenster haben, in dem ich das übergeordnete Programm gestartet habe. Eine Möglichkeit, dies zu tun, ist die cmd.Output()Funktion, die jedoch erst nach dem Beenden des Prozesses den Standard ausgibt. (Das ist ein Problem, da dieses serverähnliche Programm lange läuft und ich die Protokollausgabe lesen möchte.)

Die Variable outist von type io.ReadCloserund ich weiß nicht, was ich damit machen soll, um meine Aufgabe zu erfüllen, und ich kann im Web zu diesem Thema nichts Hilfreiches finden.

func main() {
    cmd := exec.Command("/path/to/my/child/program")
    out, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Println(err)
    }
    err = cmd.Start()
    if err != nil {
        fmt.Println(err)
    }
    //fmt.Println(out)
    cmd.Wait()
} 

Erklärung zum Code: Kommentieren Sie die PrintlnFunktion aus, um den Code zum Kompilieren zu bringen. Ich weiß, dass dies Println(out io.ReadCloser)keine sinnvolle Funktion ist.
(Es erzeugt die Ausgabe. &{3 |0 <nil> 0}) Diese beiden Zeilen sind nur erforderlich, damit der Code kompiliert werden kann.

Jetzt möchte ich die Standardausgabe des untergeordneten Programms in meinem Terminalfenster haben, in dem ich das übergeordnete Programm gestartet habe.

Sie müssen sich nicht mit Rohren oder Goroutinen herumschlagen, dies ist einfach.

func main() {
    // Replace `ls` (and its arguments) with something more interesting
    cmd := exec.Command("ls", "-l")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    cmd.Run()
}

Ich glaube , dass , wenn Sie importieren iound osund diese ersetzen:

//fmt.Println(out)

mit diesem:

go io.Copy(os.Stdout, out)

(siehe Dokumentation fürio.Copy und füros.Stdout ), es wird tun, was Sie wollen. (Haftungsausschluss: nicht getestet.)

Übrigens möchten Sie wahrscheinlich auch Standardfehler erfassen, indem Sie denselben Ansatz wie für die Standardausgabe verwenden, jedoch mit cmd.StderrPipeund os.Stderr.

Für diejenigen, die dies nicht in einer Schleife benötigen, aber möchten, dass die Befehlsausgabe in das Terminal zurückgesendet wird, ohne dass cmd.Wait()andere Anweisungen blockiert werden:

package main

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

func checkError(err error) {
    if err != nil {
        log.Fatalf("Error: %s", err)
    }
}

func main() {
    // Replace `ls` (and its arguments) with something more interesting
    cmd := exec.Command("ls", "-l")

    // Create stdout, stderr streams of type io.Reader
    stdout, err := cmd.StdoutPipe()
    checkError(err)
    stderr, err := cmd.StderrPipe()
    checkError(err)

    // Start command
    err = cmd.Start()
    checkError(err)

    // Don't let main() exit before our command has finished running
    defer cmd.Wait()  // Doesn't block

    // Non-blockingly echo command output to terminal
    go io.Copy(os.Stdout, stdout)
    go io.Copy(os.Stderr, stderr)

    // I love Go's trivial concurrency :-D
    fmt.Printf("Do other stuff here! No need to wait.\n\n")
}