passer par l'exemple exécutant un sous-processus

Exécutez le processus enfant à l'aide du package OS / EXEC, créez la commande via exec.command mais ne s'exécutez pas immédiatement; 2. Exécutez la commande avec .output () et attrapez stdout. Si le code de sortie est non nul, return exec.exiterror; 3. Utilisez .Start () pour démarrer le processus sans blocage, et combinez avec .stdoutPipe () pour diffuser la sortie en temps réel; 4. Entrez les données dans le processus via .stDinpipe (), et après avoir écrit, vous devez fermer le pipeline et appeler .wait () pour attendre la fin; 5. exec.exiterror doit être traité pour obtenir le code de sortie et le stderr de la commande raté pour éviter les processus zombies.

L'exécution d'un sous-processus dans GO est simple à l'aide du package os/exec . Voici un exemple pratique montrant comment exécuter une commande externe, capturer sa sortie et gérer les erreurs.

Exemple de base: exécutez ls (ou dir sur Windows)

 package principal

importer (
    "FMT"
    "Io"
    "enregistrer"
    "OS"
    "OS / EXEC"
)

func main () {
    var cmd * exec.cmd

    // Choisissez la commande basée sur le système d'exploitation
    Si os.pathseparator == '\\' {
        // Windows
        cmd = exec.command ("cmd", "/ c", "dir")
    } autre {
        // Unix-like: Linux, macOS
        cmd = exec.command ("ls", "-l")
    }

    // capture la sortie
    sortie, err: = cmd.output ()
    Si err! = Nil {
        Si exiterror, ok: = err. (* exec.exiterror); d'accord {
            // Commande a été exécutée mais est sortie avec un statut non nul
            fmt.fprintf (os.stderr, "La commande a échoué avec le code de sortie:% d \ n", exiterror.exitcode ())
            fmt.fprintf (os.stderr, "stderr:% s \ n", exiterror.stderr)
        } autre {
            // autre erreur (par exemple, commande non trouvée)
            log.fatalf ("Échec de l'exécution de la commande:% v", err)
        }
        Retour
    }

    // imprime la sortie
    fmt.printf ("sortie de commande: \ n% s \ n", sortie)
}

Exécutez une commande de commande et de flux en temps réel

Parfois, vous ne voulez pas attendre que la commande se termine - diffusez simplement STDOUT / STDERR au fur et à mesure.

 func runwithStreamingOutput () {
    cmd: = exec.command ("ping", "-c", "5", "google.com")

    // Obtenez un tuyau stdout
    stdout, err: = cmd.stdoutpipe ()
    Si err! = Nil {
        Log.fatalf ("Erreur d'obtention du tuyau stdout:% V", ERR)
    }

    // Démarrez la commande
    Si err: = cmd.start (); err! = Nil {
        log.fatalf ("Commande de démarrage d'erreur:% v", err)
    }

    // Stream de sortie ligne par ligne
    lecteur: = io.teeReader (stdout, os.stdout)
    _, _ = io.readall (lecteur)

    // attendez que la commande termine
    Si err: = cmd.wait (); err! = Nil {
        Log.printf ("Commande terminée avec l'erreur:% V", ERR)
    }
}

Passer l'entrée à un sous-processus

Si vous devez envoyer une entrée (par exemple, à un script ou à un outil interactif):

 func runwithinput () {
    cmd: = exec.command ("grep", "bonjour")
    stdin, err: = cmd.stdinpipe ()
    Si err! = Nil {
        Log.fatalf ("Erreur d'obtention du tuyau stdin:% V", ERR)
    }

    // N'oubliez pas de démarrer la commande * après * Configuration des tuyaux
    Si err: = cmd.start (); err! = Nil {
        log.fatalf ("Commande de démarrage d'erreur:% v", err)
    }

    // Écrivez l'entrée
    fmt.fprintln (Stdin, "Hello World")
    fmt.fprintln (Stdin, "Goodbye World")
    stdin.close ()

    // capture et imprimez les lignes de correspondance
    sortie, _: = io.readall (cmd.stdout)
    fmt.printf ("correspondant:% s", sortie)

    // attendez l'achèvement
    cmd.wait ()
}

Points clés pour se souvenir

• Utilisez exec.Command() pour configurer la commande, mais il ne l'exécute pas immédiatement.
• .Output() Exécute la commande et renvoie Stdout (échoue si le code de sortie ≠ 0).
• .Start() démarre le processus (non bloquant), .Run() démarre et attend.
• Appelez toujours .Wait() si vous utilisez .Start() , pour éviter les processus zombies.
• Gire *exec.ExitError pour obtenir des codes de sortie et stderr à partir des commandes échouées.

Fondamentalement, os/exec vous donne un contrôle total, que vous souhaitiez capturer la sortie, le diffuser ou l'entrée de nourriture. Soyez juste prudent avec les chemins, les arguments et les types d'erreur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!