Go os/exec：深度解析与处理子进程环境变更

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    // 设置子进程的初始环境
    cmd := exec.Command("bash", "-c", "echo Initial value: $MY_CUSTOM_VAR; export MY_CUSTOM_VAR=modified_by_child; echo Modified by child: $MY_CUSTOM_VAR")
    cmd.Env = []string{"MY_CUSTOM_VAR=initial_value"} // 为子进程设置初始环境变量

    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("命令执行失败: %v\n", err)
        return
    }
    fmt.Printf("子进程输出:\n%s\n", string(output))

    // 尝试在父进程中访问 MY_CUSTOM_VAR
    // 注意：这里访问的是父进程的环境，而不是子进程修改后的环境
    fmt.Printf("父进程中的 MY_CUSTOM_VAR: %s\n", os.Getenv("MY_CUSTOM_VAR")) // 假设父进程没有设置此变量
}

package main

import (
    "bytes"
    "fmt"
    "os"
    "os/exec"
    "strings"
)

func main() {
    // 模拟一个会修改环境并输出特定格式的子进程脚本
    // 注意：在实际应用中，你需要确保外部命令以可解析的格式输出环境信息
    script := `
    export MY_CUSTOM_VAR="hello_from_child";
    export ANOTHER_VAR="value_changed";
    echo "---ENVIRONMENT_START---";
    # 仅输出我们关心的变量，或全部输出然后过滤
    env | grep MY_CUSTOM_VAR;
    env | grep ANOTHER_VAR;
    echo "---ENVIRONMENT_END---";
    # 子进程的其他操作...
    echo "Child process finished its main task."
    `

    cmd := exec.Command("bash", "-c", script)

    // 为子进程设置初始环境（如果需要）
    // cmd.Env = append(os.Environ(), "INITIAL_VAR=initial_value_for_child")

    var stdoutBuf bytes.Buffer
    var stderrBuf bytes.Buffer
    cmd.Stdout = &stdoutBuf
    cmd.Stderr = &stderrBuf

    fmt.Println("正在执行子进程...")
    err := cmd.Run()
    if err != nil {
        fmt.Printf("命令执行失败: %v\n", err)
        fmt.Printf("标准输出: %s\n", stdoutBuf.String())
        fmt.Printf("标准错误: %s\n", stderrBuf.String())
        return
    }

    output := stdoutBuf.String()
    errorOutput := stderrBuf.String()
    fmt.Println("\n--- 子进程原始标准输出 ---")
    fmt.Print(output)
    if errorOutput != "" {
        fmt.Println("\n--- 子进程原始标准错误 ---")
        fmt.Print(errorOutput)
    }

    // 解析输出，提取环境变更
    modifiedEnv := make(map[string]string)
    inEnvSection := false
    for _, line := range strings.Split(output, "\n") {
        trimmedLine := strings.TrimSpace(line)
        if trimmedLine == "---ENVIRONMENT_START---" {
            inEnvSection = true
            continue
        }
        if trimmedLine == "---ENVIRONMENT_END---" {
            inEnvSection = false
            break // 找到结束标记后停止解析环境部分
        }
        if inEnvSection && trimmedLine != "" {
            parts := strings.SplitN(trimmedLine, "=", 2)
            if len(parts) == 2 {
                modifiedEnv[parts[0]] = parts[1]
            }
        }
    }

    fmt.Println("\n--- 捕获到的子进程环境变更 ---")
    if len(modifiedEnv) == 0 {
        fmt.Println("未捕获到环境变更或格式不匹配。")
    } else {
        for k, v := range modifiedEnv {
            fmt.Printf("%s=%s\n", k, v)
        }
    }

    // 后续操作：将捕获到的环境用于新的命令
    if val, ok := modifiedEnv["MY_CUSTOM_VAR"]; ok {
        fmt.Printf("\n--- 尝试用捕获到的变量执行新命令 --- (echo $MY_CUSTOM_VAR)\n")
        newCmd := exec.Command("bash", "-c", "echo $MY_CUSTOM_VAR")

        // 方式一：仅添加或覆盖特定变量
        // newCmd.Env = append(os.Environ(), fmt.Sprintf("MY_CUSTOM_VAR=%s", val))
        // 方式二：构建一个全新的环境切片，包含父进程原有环境和子进程修改后的环境
        currentEnv := os.Environ()
        var newEnv []string
        for _, envVar := range currentEnv {
            if !strings.HasPrefix(envVar, "MY_CUSTOM_VAR=") { // 避免重复添加或覆盖
                newEnv = append(newEnv, envVar)
            }
        }
        newEnv = append(newEnv, fmt.Sprintf("MY_CUSTOM_VAR=%s", val))
        newCmd.Env = newEnv

        var newStdout bytes.Buffer
        newCmd.Stdout = &newStdout
        newErr := newCmd.Run()
        if newErr != nil {
            fmt.Printf("新命令执行失败: %v\n", newErr)
            return
        }
        fmt.Printf("新命令输出: %s", newStdout.String())
    }
}