Question

我想从另一个go程序中执行另一个go程序并给它args，类似这样：

package main
func main() {
  //here I want to call a specific go file, e.g. test.go with args
}

test.go

package main
func 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”：如果你没有源码，而你只有二进制，或者您可以通过文件或文本args传递args：

你可以通过这样的args：

package main

import (
    "fmt"
    "os"
)

func main() {

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

或使用“flag”std lib：

// 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-另一种方法是使用stdin / stdout调用外部程序通过这种方式，您可以通过stdin / out发送二进制数据：
这里文件“a”调用二进制文件“b”并通过stdin / stdout发送和接收：
这是我的转换：
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)
    }
}

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

3 个答案: