Use Output() to execute simple commands and obtain stdout output, suitable for scenarios without interaction; 2. Use CombinedOutput() to capture stdout and stderr at the same time, suitable for debugging or error troubleshooting; 3. Customize working directories and environment variables by setting Dir and Env fields to achieve a more flexible execution environment; 4. Use StdinPipe and stdout to read to implement interactive input and output with commands, suitable for scenarios where data needs to be input dynamically; 5. Use CommandContext to combine context.WithTimeout to implement timeout control to prevent unlimited command blocking; in summary, the os/exec package provides a complete external command execution solution from simple execution to complex interaction, and you can choose the appropriate method according to your needs.

In Go language, "command execution" usually refers to executing external commands (such as shell commands, system tools, etc.) through a program. Go's os/exec package provides a powerful interface to achieve this. The following are several common examples to illustrate how to execute external commands in Go.

1. Execute simple commands and get output

Use exec.Command to create a command and use Output() method to get the standard output.

 package main

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

func main() {
    cmd := exec.Command("ls", "-l") // on Linux/macOS // cmd := exec.Command("dir") // on Windows output, err := cmd.Output()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Output:\n%s", output)
}

? For: You want to run a command quickly and get its output without interaction.

2. Execute commands and handle errors (including stderr)

Output() returns only stdout, and if the command errors (non-zero exit code), it returns an error. But the stderr content will not be included in the error unless you capture it explicitly.

A more flexible way is to use CombinedOutput() :

 package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("go", "run", "noneexistent.go")
    output, err := cmd.CombinedOutput()

    if err != nil {
        fmt.Printf("Command execution failed: %v\n", err)
    }

    fmt.Printf("Output (including stderr):\n%s", output)
}

? Suitable for: debugging or requiring both stdout and stderr to be captured.

3. Command execution with environment variables and working directory

You can customize the environment variables and run directories of the command.

 package main

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

func main() {
    cmd := exec.Command("pwd")

    // Set the working directory cmd.Dir = "/tmp"

    // Optional: Set environment variables (complete replacement)
    // cmd.Env = []string{"PATH=/usr/bin"}

    // Inherit the current environment and add the custom variable cmd.Env = append(os.Environ(), "MY_VAR=hello")

    output, err := cmd.Output()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Execute pwd: %s under /tmp", output)
}

4. Interactively execute commands (input/output stream)

When you need to enter data into a command (such as stdin ), you can use a pipeline.

 package main

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

func main() {
    cmd := exec.Command("grep", "hello")

    // Get stdin pipeline stdin, err := cmd.StdinPipe()
    if err != nil {
        log.Fatal(err)
    }

    // Start command if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }

    // Write input io.WriteString(stdin, "hello world\n")
    io.WriteString(stdin, "goodbye world\n")
    stdin.Close()

    // Get the output output, _ := io.ReadAll(cmd.Stdout)
    cmd.Wait() // Wait for completion fmt.Printf("Match result:\n%s", output)
}

? Suitable for: scenarios that need to interact with commands, such as grep , bc , custom CLI tools, etc.

5. Timeout control (avoid command stuck)

Use context to control execution time to prevent unlimited waiting of commands.

 package main

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

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    cmd := exec.CommandContext(ctx, "sleep", "5") // Timeout will be interrupted err := cmd.Run()
    if err != nil {
        if ctx.Err() == context.DeadlineExceeded {
            fmt.Println("Command Timeout")
        } else {
            log.Printf("Command Error: %v", err)
        }
    } else {
        fmt.Println("Command completed successfully")
    }
}

? Suitable for: Execute commands that are untrusted or may run for a long time.

Summary: Comparison of common methods

Basically these common uses. Go's os/exec design is simple but complete, and is suitable for most automated scripts, CLI tools or system integration scenarios. The key is to choose the appropriate method based on whether you need input, timeout, environmental control, etc.

The above is the detailed content of go by example command execution. For more information, please follow other related articles on the PHP Chinese website!