Go语言与子进程交互：实现标准输入输出的实时通信

import sys

# 确保输出不被缓冲，实时刷新
sys.stdout.reconfigure(line_buffering=True) 

while True:
    try:
        # 从标准输入读取一行
        line = sys.stdin.readline()
        if not line: # 如果读取到EOF，则退出循环
            break
        # 求值并写入标准输出
        sys.stdout.write('%s\n' % eval(line))
    except Exception as e:
        sys.stderr.write(f"Error: {e}\n")
        break # 遇到错误也退出

package main

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

func main() {
    // 1. 定义子进程命令
    // "-u" 参数确保Python的输出是无缓冲的，这对于实时交互至关重要。
    cmd := exec.Command("python", "-u", "add.py")

    // 2. 获取子进程的标准输入管道
    // StdinPipe返回一个io.WriteCloser，Go程序可以向其写入数据，这些数据将作为子进程的标准输入。
    stdinPipe, err := cmd.StdinPipe()
    if err != nil {
        log.Fatalf("无法获取StdinPipe: %v", err)
    }

    // 3. 获取子进程的标准输出管道
    // StdoutPipe返回一个io.ReadCloser，Go程序可以从其读取数据，这些数据是子进程的标准输出。
    stdoutPipe, err := cmd.StdoutPipe()
    if err != nil {
        log.Fatalf("无法获取StdoutPipe: %v", err)
    }

    // 4. 使用bufio.NewReader封装stdoutPipe，以便按行读取
    // 对于交互式程序，通常需要按行读取输出，bufio.Reader提供了方便的ReadString('\n')方法。
    reader := bufio.NewReader(stdoutPipe)

    // 5. 启动子进程
    // Start方法启动命令但不等待其完成。这允许Go程序在子进程运行时与其进行交互。
    err = cmd.Start()
    if err != nil {
        log.Fatalf("无法启动子进程: %v", err)
    }

    // 6. 进行循环通信：向子进程发送输入并读取输出
    for i := 0; i < 10; i++ {
        // 构造要发送的数学表达式
        input := fmt.Sprintf("2+%d\n", i)

        // 向子进程的stdin写入数据。注意需要写入字节切片，并且要包含换行符'\n'，
        // 因为Python脚本是按行读取的。
        _, err = stdinPipe.Write([]byte(input))
        if err != nil {
            log.Fatalf("写入stdin失败: %v", err)
        }

        // 从子进程的stdout读取一行数据。ReadString会阻塞直到读取到指定分隔符（这里是换行符）或EOF。
        answer, err := reader.ReadString('\n')
        if err != nil {
            log.Fatalf("读取stdout失败: %v", err)
        }

        // 打印Go程序接收到的结果
        fmt.Printf("对表达式 %q 的答案是: %q\n", input, answer)
    }

    // 7. 关闭输入管道，向子进程发送EOF信号
    // 当Go程序不再需要向子进程发送数据时，应关闭stdinPipe。
    // 这会向子进程的标准输入发送EOF（文件结束）信号，Python脚本中的readline()会返回空字符串，从而优雅地退出循环。
    err = stdinPipe.Close()
    if err != nil {
        log.Printf("关闭stdinPipe失败: %v", err)
    }

    // 8. 关闭输出管道，释放资源
    // 虽然通常在进程退出后会自动关闭，但显式关闭是一个好习惯。
    err = stdoutPipe.Close()
    if err != nil {
        log.Printf("关闭stdoutPipe失败: %v", err)
    }

    // 9. 等待子进程完成
    // Wait方法会阻塞直到子进程退出，并返回其退出状态。
    // 这是确保所有资源被清理和获取子进程最终状态的关键步骤。
    err = cmd.Wait()
    if err != nil {
        log.Fatalf("子进程执行失败: %v", err)
    }

    fmt.Println("子进程通信完成。")
}

对表达式 "2+0\n" 的答案是: "2\n"
对表达式 "2+1\n" 的答案是: "3\n"
对表达式 "2+2\n" 的答案是: "4\n"
对表达式 "2+3\n" 的答案是: "5\n"
对表达式 "2+4\n" 的答案是: "6\n"
对表达式 "2+5\n" 的答案是: "7\n"
对表达式 "2+6\n" 的答案是: "8\n"
对表达式 "2+7\n" 的答案是: "9\n"
对表达式 "2+8\n" 的答案是: "10\n"
对表达式 "2+9\n" 的答案是: "11\n"
子进程通信完成。