Go 围棋中的持久程序

我正在努力学习围棋，我想我应该从一个我想做了一段时间的项目开始（但这个项目似乎太“烦琐”了）。基本的想法是，我有一个在stdin/stdout上与用户交互的程序，我想写一个新的程序，以同样的方式与程序交互（就像它是一个运行程序的人）

这里的程序很简单，因为它是同步的：你输入一个命令，得到一些输出，然后它坐在那里等待下一批输入。这似乎并不难，但我很难让这个I/O框架正常工作

package main

import (
    "os/exec"
    "time"
    "bufio"
    "math/rand"
    "fmt"
    "strings"
)

func main() {
    cmd := exec.Command("e")    // A simple program that echos input until it becomes "exit"

    progin, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Println("Trouble with e's stdout")
        panic(err)
    }

    err = cmd.Start()
    if err != nil {
        fmt.Println("Trouble starting e")
        panic(err)
    }

    r := rand.New(rand.NewSource(99))

    buf := bufio.NewReader(progin)
    for {
        // Write stuff
        var toProg string
        if (r.Float64() < .1) {
            toProg = "exit"
        } else {
            toProg = fmt.Sprintf("%d", r.Int)
        }
        fmt.Println("Printing: ", toProg)
        cmd.Stdin = strings.NewReader(toProg + "\n")

        // Read stuff
        time.Sleep(500 * time.Millisecond) // give the program time to generate output

        input, err := buf.ReadString('\n')
        if err != nil {
            fmt.Println("I did *not* like that: ", input)
            panic(err)
        }
        fmt.Println("Received: ", input)

    }
}

主程序包
进口(
“os/exec”
“时间”
“布菲奥”
“数学/兰德”
“fmt”
“字符串”
)
func main（）{
cmd:=exec.Command（“e”）//一个简单的程序，在输入变为“exit”之前进行回送
progin，err:=cmd.StdoutPipe（）
如果错误！=零{
fmt.Println（“e的标准装置故障”）
恐慌（错误）
}
err=cmd.Start（）
如果错误！=零{
fmt.Println（“启动e故障”）
恐慌（错误）
}
r:=rand.New（rand.NewSource（99））
buf:=bufio.NewReader（progin）
为了{
//写东西
var-toProg字符串
如果（r.Float64（）<.1）{
toProg=“退出”
}否则{
toProg=fmt.Sprintf（“%d”，r.Int）
}
fmt.Println（“打印：”，toProg）
cmd.Stdin=strings.NewReader（toProg+“\n”）
//阅读材料
time.Sleep（500*time.毫秒）//给程序生成输出的时间
输入，错误：=buf.ReadString（'\n'）
如果错误！=零{
Println（“我不喜欢：”，输入）
恐慌（错误）
}
fmt.Println（“接收：”，输入）
}
}

---

有人吗？

你在重新发明轮子，你想做的一切都可以通过

fmt

包来处理，所以只要使用它，并在需要的地方添加额外的东西，比如随机数检查器

以下是如何轻松实现这一目标的示例：

为了快速查看，此策略的主要功能包括：

var s string
_, err := fmt.Scanf("%s", &s)
if err != nil {
    log.Fatal(err)
}
fmt.Println(s)

---

请注意，由于权限问题，它不会在操场上运行，但是如果您在本地运行它，它应该可以正常工作。

您正在重新设计轮子，您想做的一切都可以通过

fmt

包来处理，所以只需使用它，并在需要的地方添加额外的东西，如随机数检查器

以下是如何轻松实现这一目标的示例：

为了快速查看，此策略的主要功能包括：

var s string
_, err := fmt.Scanf("%s", &s)
if err != nil {
    log.Fatal(err)
}
fmt.Println(s)

---

请注意，由于权限问题，它不会在操场上运行，但如果在本地运行它，它应该可以正常工作。

您最大的问题是重新分配命令的Stdin，而不是管道到它

以下是一个工作版本：

package main

import (
    "bufio"
    "fmt"
    "math/rand"
    "os/exec"
    "time"
)

func main() {
    cmd := exec.Command("./e") // A simple program that echos input until it becomes "exit"

    progin, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Println("Trouble with e's stdout")
        panic(err)
    }

    progout, err := cmd.StdinPipe()
    if err != nil {
        fmt.Println("Trouble with e's stdin")
        panic(err)
    }

    err = cmd.Start()
    if err != nil {
        fmt.Println("Trouble starting e")
        panic(err)
    }

    r := rand.New(rand.NewSource(99))

    buf := bufio.NewReader(progin)
    for {
        // Write stuff
        var toProg string
        if r.Float64() < .1 {
            toProg = "exit"
        } else {
            toProg = fmt.Sprintf("%d", r.Int())
        }
        fmt.Println("Printing: ", toProg)
        progout.Write([]byte(toProg + "\n"))

        // Read stuff
        time.Sleep(500 * time.Millisecond) // give the program time to generate output

        input, err := buf.ReadString('\n')
        if err != nil {
            fmt.Println("I did *not* like that: ", input)
            panic(err)
        }
        fmt.Println("Received: ", input)

    }
}

---

您最大的问题是重新分配命令的Stdin，而不是管道

以下是一个工作版本：

package main

import (
    "bufio"
    "fmt"
    "math/rand"
    "os/exec"
    "time"
)

func main() {
    cmd := exec.Command("./e") // A simple program that echos input until it becomes "exit"

    progin, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Println("Trouble with e's stdout")
        panic(err)
    }

    progout, err := cmd.StdinPipe()
    if err != nil {
        fmt.Println("Trouble with e's stdin")
        panic(err)
    }

    err = cmd.Start()
    if err != nil {
        fmt.Println("Trouble starting e")
        panic(err)
    }

    r := rand.New(rand.NewSource(99))

    buf := bufio.NewReader(progin)
    for {
        // Write stuff
        var toProg string
        if r.Float64() < .1 {
            toProg = "exit"
        } else {
            toProg = fmt.Sprintf("%d", r.Int())
        }
        fmt.Println("Printing: ", toProg)
        progout.Write([]byte(toProg + "\n"))

        // Read stuff
        time.Sleep(500 * time.Millisecond) // give the program time to generate output

        input, err := buf.ReadString('\n')
        if err != nil {
            fmt.Println("I did *not* like that: ", input)
            panic(err)
        }
        fmt.Println("Received: ", input)

    }
}

---

对于测试，这里是

e

的源代码：对于测试，这里是

e

的源代码：请在回答中也包括代码的本质。这根本不会产生外部过程，我不确定它是如何连接到我的问题的。请在回答中也包括你的代码的本质。这根本不会产生一个外部过程，我不确定它是如何连接到我的问题的。