Go 语言多步操作中的错误处理：告别冗余，拥抱简洁

package main

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

func main() {
    cmd := exec.Command("cat", "-")

    stdin, err := cmd.StdinPipe()
    if err != nil {
        return // 错误处理
    }

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return // 错误处理
    }

    err = cmd.Start()
    if err != nil {
        return // 错误处理
    }

    _, err = io.WriteString(stdin, "Hello world!")
    if err != nil {
        return // 错误处理
    }

    err = stdin.Close()
    if err != nil {
        return // 错误处理
    }

    output, err := ioutil.ReadAll(stdout)
    if err != nil {
        return // 错误处理
    }

    fmt.Println(string(output))
}

package main

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

// piping 函数封装了执行 cat 管道操作的逻辑
// 接收一个输入字符串，返回 cat 命令的输出和可能发生的错误
func piping(input string) (string, error) {
    cmd := exec.Command("cat", "-")

    // 获取 stdin 管道
    stdin, err := cmd.StdinPipe()
    if err != nil {
        return "", fmt.Errorf("获取 stdin 管道失败: %w", err)
    }
    defer stdin.Close() // 确保 stdin 在函数返回前关闭

    // 获取 stdout 管道
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return "", fmt.Errorf("获取 stdout 管道失败: %w", err)
    }
    // 注意：stdout 通常由 ReadAll 关闭或在 cmd.Wait() 后自动关闭，
    // 但如果需要显式管理，可以考虑 defer stdout.Close()。
    // 对于 os/exec 场景，通常不需要单独关闭 stdout。

    // 启动命令
    err = cmd.Start()
    if err != nil {
        return "", fmt.Errorf("启动命令失败: %w", err)
    }

    // 将输入写入 stdin
    _, err = io.WriteString(stdin, input)
    if err != nil {
        return "", fmt.Errorf("写入 stdin 失败: %w", err)
    }
    // 写入完成后关闭 stdin，这会向 cat 进程发送 EOF
    // defer stdin.Close() 已经处理了，但如果需要立即关闭以触发 cat 读取，可以显式调用
    // err = stdin.Close() // 再次调用 Close 是安全的，但 defer 更优雅

    // 读取 stdout
    outputBytes, err := ioutil.ReadAll(stdout)
    if err != nil {
        // 注意：如果 ReadAll 失败，outputBytes 可能部分填充，
        // 但通常我们认为整个操作失败。
        return string(outputBytes), fmt.Errorf("读取 stdout 失败: %w", err)
    }

    // 等待命令完成，并检查退出状态
    err = cmd.Wait()
    if err != nil {
        return string(outputBytes), fmt.Errorf("命令执行失败: %w", err)
    }

    return string(outputBytes), nil
}

func main() {
    inputStr := "Hello world!"
    fmt.Println("输入:", inputStr)

    // 调用封装函数，一次性处理所有潜在错误
    outputStr, err := piping(inputStr)
    if err != nil {
        fmt.Fprintf(os.Stderr, "管道操作失败: %v\n", err)
        os.Exit(1) // 退出程序并返回错误码
    }

    fmt.Println("输出:", outputStr)
}