从 golang 程序中执行另一个 go 程序

Question

我想从另一个 go 程序中执行另一个 go 程序并给它 args，如下所示：package mainfunc main() {  //here I want to call a specific go file, e.g. test.go with args}测试.gopackage mainfunc main(x int) {  //do stuff with x}我不想发送一个int作为arg，而是像http.ResponseWriter这样的东西我想到了一个解决方案，但它并不是很好：使用 gob 将 http.ResponseWriter 转换为字符串从 test.go 读入一行将字符串发送到 test.go感谢您的任何答案：D

Answer 1

有很多方法可以实现互操作性：

1- 如果您有双方的源文件，我建议使用标准的 golang 包 (Lib) 调用，而不是互操作性。

2-使用“os/exec”：如果您没有源代码，并且只有二进制文件，或者您可以通过文件或文本参数传递参数：

你可以像这样传递参数：

package main

import (

    "fmt"

    "os"

)

func main() {

    fmt.Println(os.Args[0]) // fileNameAndPath

}

或使用“标志”标准库：

// flags.exe -h

package main

import (

    "flag"

    "fmt"

)

func main() {

    namePtr := flag.String("name", "AR", "name")

    agePtr := flag.Int("age", 3700, "age")

    flag.Parse()

    fmt.Println(*namePtr, *agePtr) //AR 3700

}

/*

Usage of flags.exe:

  -age int

        age (default 3700)

  -name string

        name (default "AR")

*/

这将提供 -h 的帮助。

您可以像这样调用另一个二进制程序或 golang 编译器本身：

package main

import (

    "log"

    "os/exec"

)

func main() {

    cmnd := exec.Command("main.exe", "arg")

    //cmnd.Run() // and wait

    cmnd.Start()

    log.Println("log")

}

3-另一种方法是使用标准输入/标准输出调用外部程序。

这样，您可以通过标准输入/输出发送二进制数据：

这里文件“a”调用二进制文件“b”并通过标准输入/标准输出发送和接收：

这是我的转换：

http : //erlang.org/doc/tutorial /c_port.html

（您可以使用 os 命名管道）

文件 a：

// a

package main

import (

    "fmt"

    "log"

    "os/exec"

    "runtime"

    "time"

)

var cout chan []byte = make(chan []byte)

var cin chan []byte = make(chan []byte)

var exit chan bool = make(chan bool)

func Foo(x byte) byte { return call_port([]byte{1, x}) }

func Bar(y byte) byte { return call_port([]byte{2, y}) }

func Exit() byte      { return call_port([]byte{0, 0}) }

func call_port(s []byte) byte {

    cout <- s

    s = <-cin

    return s[1]

}

func start() {

    fmt.Println("start")

    cmd := exec.Command("../b/b")

    stdin, err := cmd.StdinPipe()

    if err != nil {

        log.Fatal(err)

    }

    stdout, err2 := cmd.StdoutPipe()

    if err2 != nil {

        log.Fatal(err2)

    }

    if err := cmd.Start(); err != nil {

        log.Fatal(err)

    }

    defer stdin.Close()

    defer stdout.Close()

    for {

        select {

        case s := <-cout:

            stdin.Write(s)

            buf := make([]byte, 2)

            runtime.Gosched()

            time.Sleep(100 * time.Millisecond)

            stdout.Read(buf)

            cin <- buf

        case b := <-exit:

            if b {

                fmt.Printf("Exit")

                return //os.Exit(0)

            }

        }

    }

}

func main() {

    go start()

    runtime.Gosched()

    fmt.Println("30+1=", Foo(30)) //30+1= 31

    fmt.Println("2*40=", Bar(40)) //2*40= 80

    Exit()

    exit <- true

}

文件 b：

// b

package main

import (

    "log"

    "os"

)

func foo(x byte) byte { return x + 1 }

func bar(y byte) byte { return y * 2 }

func ReadByte() byte {

    b1 := make([]byte, 1)

    for {

        n, _ := os.Stdin.Read(b1)

        if n == 1 {

            return b1[0]

        }

    }

}

func WriteByte(b byte) {

    b1 := []byte{b}

    for {

        n, _ := os.Stdout.Write(b1)

        if n == 1 {

            return

        }

    }

}

func main() {

    var res byte

    for {

        fn := ReadByte()

        log.Println("fn=", fn)

        arg := ReadByte()

        log.Println("arg=", arg)

        if fn == 1 {

            res = foo(arg)

        } else if fn == 2 {

            res = bar(arg)

        } else if fn == 0 {

            return //exit

        } else {

            res = fn //echo

        }

        WriteByte(1)

        WriteByte(res)

    }

}

4 - 另一种方式是使用“net/rpc”，这是从另一个程序调用另一个函数的最佳方式。

样本：

// rpc

package main

import (

    "fmt"

    "net"

    "net/rpc"

    "runtime"

    "sync"

)

var wg sync.WaitGroup

type Server struct{}

func (this *Server) Add(u [2]int64, reply *int64) error {

    *reply = u[0] + u[1]

    return nil

}

func server() {

    fmt.Println("server: Hi")

    rpc.Register(new(Server))

    ln, err := net.Listen("tcp", "127.0.0.1:12345")

    if err != nil {

        fmt.Println(err)

        return

    }

    for {

        c, err := ln.Accept()

        if err != nil {

            continue

        }

        go rpc.ServeConn(c)

    }

}

func client() {

    wg.Add(1)

    c, err := rpc.Dial("tcp", "127.0.0.1:12345")

    if err != nil {

        fmt.Println(err)

        return

    }

    fmt.Println("Connected...")

    var result int64

    err = c.Call("Server.Add", [2]int64{10, 20}, &result)

    if err != nil {

        fmt.Println(err)

    } else {

        fmt.Println("Server.Add(10,20) =", result)

    }

    wg.Done()

}

func main() {

    go server()

    runtime.Gosched()

    go client()

    runtime.Gosched()

    wg.Wait()

    fmt.Println("Bye")

}

/*output:

server: Hi

Connected...

Server.Add(10,20) = 30

Bye

*/

Answer 2

使用os/exec，您可以像这样调用 go 编译器：

output, err := exec.Command("go", "run", "/file/path/to/open").Output() 

if err == nil {

    w.Write(output) // write the output with ResponseWriter

}

Go 不会将参数传递给程序main，例如func main(x int). 在 Go 中执行此操作的方法是使用os.Args.

在我看来，您正在尝试在 Go 中使用 PHP 概念，结果不会很好。相反，您应该使用模板和静态文件来实现动态网站。检查包裹text/template。

Answer 3

为要从另一个文件运行的包创建一个可执行文件。提供要在其中运行的文件的相对路径exec.Command。例如：

文件 A

package a

import "fmt"

func main(){

    for i:=0;i<10;i++{

         fmt.Println(fmt.Sprintf("Process: %d", i))

    }

}

为上述文件创建一个二进制/可执行文件。该文件将位于包内，因此请前往包并运行可执行文件。

go build github.com/user/a/a.go // or whatever be your GOPATH for executables to create a binary file

下面是linux系统中二进制文件的情况。

文件 B

package b

import (

    "fmt"

    "os/exec"

)    

func main(){

    // come out of package b and then go inside package a to run the executable file as

    cmd := exec.Command("../a/a.go")

    if err := cmd.Run(); err != nil{

       fmt.Println(err)

    }

}