¿Cómo puedo poner en marcha un proceso que no es un archivo en Ir (por ejemplo, abrir una página web)

Question

Quiero abrir un navegador web:

c, err := exec.Command("http://localhost:4001").Output() 
if err != nil { 
    fmt.Printf("ERROR: %v, %v\n",err,c) 
} else { 
    fmt.Printf("OK:%v\n",c) 
} 

y me sale el error

ERROR: exec: "http://localhost:4001": file does not exist 

Editar: lo que quiero lograr es la misma que en Windows y C# cuando lo hace:

Process.Start("http://localhost:4001") 

con él se iniciará una nueva instancia de su navegador predeterminado mostrando la URL

Answer 1

"http://localhost:4001/" es una URL, no se puede ejecutar, pero puede ejecutar un navegador web (por ejemplo, firefox) y pasar la URL como primer argumento.

En Windows, OS X y Linux existen programas auxiliares que se pueden utilizar para iniciar el navegador web predeterminado. Supongo que hay algo similar para FreeBSD y Android, pero no estoy seguro de eso. El siguiente fragmento debería funcionar en Windows, OS X, y la mayoría de distribuciones de Linux:

var err error 
switch runtime.GOOS { 
case "linux": 
    err = exec.Command("xdg-open", "http://localhost:4001/").Start() 
case "windows", "darwin": 
    err = exec.Command("open", "http://localhost:4001/").Start() 
default: 
    err = fmt.Errorf("unsupported platform") 
} 

Answer 2

"http://localhost:4001" no es un proceso, ni ejecutable, ... es solo una URL.

Parece que está intentando recuperar una URL. Si es así, considere usar net/http.

Answer 3

Usando

exec.Command("open", "http://localhost:4001/").Start() 

en la respuesta de tux21b anterior no funcionó para mí en Windows. Sin embargo, esto hizo:

exec.Command(`C:\Windows\System32\rundll32.exe`, "url.dll,FileProtocolHandler", "http://localhost:4001/").Start() 

Answer 4

En Windows usando:

exec.Command("cmd", "/c", "start", "http://localhost:4001/").Start() 

Answer 5

https://github.com/golang/go/blob/33ed35647520f2162c2fed1b0e5f19cec2c65de3/src/cmd/internal/browser/browser.go

// Commands returns a list of possible commands to use to open a url. 
func Commands() [][]string { 
    var cmds [][]string 
    if exe := os.Getenv("BROWSER"); exe != "" { 
     cmds = append(cmds, []string{exe}) 
    } 
    switch runtime.GOOS { 
    case "darwin": 
     cmds = append(cmds, []string{"/usr/bin/open"}) 
    case "windows": 
     cmds = append(cmds, []string{"cmd", "/c", "start"}) 
    default: 
     cmds = append(cmds, []string{"xdg-open"}) 
    } 
    cmds = append(cmds, []string{"chrome"}, []string{"google-chrome"}, []string{"firefox"}) 
    return cmds 
} 

// Open tries to open url in a browser and reports whether it succeeded. 
func Open(url string) bool { 
    for _, args := range Commands() { 
     cmd := exec.Command(args[0], append(args[1:], url)...) 
     if cmd.Start() == nil { 
      return true 
     } 
    } 
    return false 
} 

Answer 6

Al principio, me gustó la respuesta proporcionada por @ tux21b. Pero hay un problema sutil con este código: la lógica condicional para seleccionar el código específico de la plataforma se integrará en el binario ejecutable del objetivo. Significa que, la lógica estará presente en "windows", "linux", "darwin" o cualquiera que sea la plataforma de destino. En este ejemplo particular, el código es solo una línea por plataforma. Pero imagínese, ¿qué sucede cuando el código sería más de 100 líneas por plataforma? El ejecutable objetivo crecerá dramáticamente. Entonces, en lugar de incluir código para cada plataforma posible, es mejor incluir solo el correcto en el momento de la compilación. En realidad, Go admite la función llamada etiquetas de compilación, que ofrece un control más preciso sobre el código específico de la plataforma.

Por ejemplo, si un archivo contiene este comentario (antes de la declaración del paquete):

// +build linux darwin

Va la estructura compilará sólo cuando se construye para Linux o Mac OS X. Esto significa que el ejecutable objetivo no contiene código para plataformas alienígenas.

open-golang paquete proporciona la funcionalidad cuestionada, pero con etiquetas de creación en mente!