与外部控制台应用进行交互式通信的Go语言教程

package main

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

func main() {
    cmd := exec.Command("stockfish")
    stdin, _ := cmd.StdinPipe() // 获取标准输入管道
    // 将 "isready\n" 写入 stdin。注意 io.Copy 完成后会关闭 stdin。
    io.Copy(stdin, bytes.NewBufferString("isready\n"))
    var out bytes.Buffer
    cmd.Stdout = &out // 设置标准输出捕获到 bytes.Buffer
    cmd.Run()         // 运行命令并等待其结束
    fmt.Printf(out.String())
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "os/exec"
    "time" // 引入 time 包
)

func main() {
    cmd := exec.Command("stockfish")
    stdin, _ := cmd.StdinPipe()
    io.Copy(stdin, bytes.NewBufferString("isready\n"))
    var out bytes.Buffer
    cmd.Stdout = &out
    cmd.Start() // 启动命令，不阻塞
    time.Sleep(1000 * time.Millisecond) // 等待1秒，希望有输出
    fmt.Printf(out.String())
}

package main

import (
    "bufio"
    "fmt"
    "io"
    "log"
    "os/exec"
    "strings"
    "sync"
    "time"
)

// Engine 结构体封装了与外部控制台应用交互所需的所有资源
type Engine struct {
    cmd     *exec.Cmd
    stdin   io.WriteCloser
    stdout  io.ReadCloser
    scanner *bufio.Scanner // 用于按行读取输出
    mu      sync.Mutex     // 保护对 stdin/stdout 的并发访问
}

// NewEngine 启动外部命令并返回一个 Engine 实例
func NewEngine(path string, args ...string) (*Engine, error) {
    cmd := exec.Command(path, args...)

    stdin, err := cmd.StdinPipe()
    if err != nil {
        return nil, fmt.Errorf("无法获取 stdin 管道: %w", err)
    }

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        stdin.Close() // 出现错误时清理
        return nil, fmt.Errorf("无法获取 stdout 管道: %w", err)
    }

    err = cmd.Start() // 启动命令，不阻塞
    if err != nil {
        stdin.Close()
        stdout.Close()
        return nil, fmt.Errorf("无法启动命令: %w", err)
    }

    engine := &Engine{
        cmd:     cmd,
        stdin:   stdin,
        stdout:  stdout,
        scanner: bufio.NewScanner(stdout), // 使用 bufio.Scanner 逐行读取
    }
    return engine, nil
}

// Put 向引擎的标准输入发送命令
func (e *Engine) Put(command string) error {
    e.mu.Lock()
    defer e.mu.Unlock()
    fmt.Printf("\n你:\n\t%s\n", command) // 打印发送的命令，用于演示
    _, err := fmt.Fprintf(e.stdin, "%s\n", command)
    if err != nil {
        return fmt.Errorf("写入 stdin 失败: %w", err)
    }
    return nil
}

// Get 从引擎的标准输出读取数据，直到遇到指定的停止条件
func (e *Engine) Get(stopCondition string) ([]string, error) {
    e.mu.Lock()
    defer e.mu.Unlock()

    var output []string
    fmt.Println("\n引擎:") // 打印接收到的输出，用于演示

    if stopCondition == "" {
        return nil, fmt.Errorf("停止条件不能为空")
    }

    // 对于国际象棋引擎，'isready' 命令通常用于触发 'readyok' 响应
    // 这里的逻辑模仿了 Python 示例，在 Get 方法内部发送 'isready'
    if stopCondition == "readyok" {
        if err := e.Put("isready"); err != nil {
            return nil, fmt.Errorf("发送 'isready' 失败: %w", err)
        }
    }

    // 逐行读取输出，直到遇到停止条件
    for e.scanner.Scan() {
        line := strings.TrimSpace(e.scanner.Text())
        if line == stopCondition {
            break
        }
        if line != "" {
            fmt.Printf("\t%s\n", line) // 打印引擎输出
            output = append(output, line)
        }
    }
    if err := e.scanner.Err(); err != nil {
        return nil, fmt.Errorf("从 stdout 读取错误: %w", err)
    }
    return output, nil
}

// Close 清理资源，关闭管道并等待进程退出
func (e *Engine) Close() error {
    // 尝试发送 'quit' 命令，通知引擎退出
    _ = e.Put("quit") // 尽力而为，不处理错误

    // 给予引擎一些时间处理 'quit' 命令
    time.Sleep(100 * time.Millisecond)

    // 关闭管道
    e.stdin.Close()
    e.stdout.Close()

    // 等待命令进程退出
    err := e.cmd.Wait()
    if err != nil {
        // 记录错误，但即使进程非正常退出，也认为 Close 操作完成
        log.Printf("引擎命令退出时出现错误: %v", err)
    }
    return nil
}

func main() {
    // 请将 "stockfish" 替换为您的 stockfish 可执行文件的实际路径
    // 例如：在 Windows 上可能是 "./stockfish-x64.exe"，如果已添加到 PATH 则直接 "stockfish"
    engine, err := NewEngine("stockfish") // 假设 stockfish 在 PATH 中或当前目录
    if err != nil {
        log.Fatalf("初始化引擎失败: %v", err)
    }
    defer engine.Close() // 确保在 main 函数结束时关闭引擎

    // 初始检查，类似于 Python 示例中的第一个 get()
    _, err = engine.Get("readyok")
    if err != nil {
        log.Fatalf("初始 ready 检查失败: %v", err)
    }

    // 发送 UCI 协议命令并等待响应
    engine.Put("uci")
    _, err = engine.Get("readyok")
    if err != nil {
        log.Fatalf("UCI 命令失败: %v", err)
    }

    // 设置选项
    engine.Put("setoption name Hash value 128")
    _, err = engine.Get("readyok")
    if err != nil {
        log.Fatalf("setoption 命令失败: %v", err)
    }

    // 开始新游戏
    engine.Put("ucinewgame")
    _, err = engine.Get("readyok")
    if err != nil {
        log.Fatalf("ucinewgame 命令失败: %v", err)
    }

    // 设置棋盘位置
    engine.Put("position startpos moves e2e4 e7e5 f2f4")
    _, err = engine.Get("readyok")
    if err != nil {
        log.Fatalf("position 命令失败: %v", err)
    }

    // 开始思考（go infinite 是一个特殊情况，需要手动停止）
    engine.Put("go infinite")
    // 对于 "go infinite" 这样的命令，引擎会持续输出，直到收到 "stop"。
    // 这里模拟 Python 示例，等待一段时间后发送 "stop"。
    time.Sleep(3 * time.Second)
    engine.Put("stop")
    _, err = engine.Get("readyok") // 停止后，引擎应该再次变为 readyok 状态
    if err != nil {
        log.Fatalf("go infinite/stop 失败: %v", err)
    }

    // defer engine.Close() 会在 main 函数退出时自动发送 "quit" 并清理资源。
}