¿Cómo compilar el programa Go que consta de varios archivos?

Tengo un pequeño programa que consta de tres archivos, todos pertenecientes al mismo paquete (principal), pero cuando hago "go build main.go", la compilación no se realiza correctamente. Cuando era solo un archivo (main.go) todo funcionaba bien. Ahora que hice un esfuerzo para separar el código, parece que el compilador no puede encontrar las cosas que se sacaron de main.go y se colocaron en estos otros dos archivos (que residen en el mismo directorio que main.go) . Lo que da como resultado errores de "tipo" indefinido ".

¿Cómo compilar este programa que consta de varios archivos?

Nueva forma ( recomendado ):

Por favor, eche un vistazo a esta respuesta .

Vieja forma:

Supongamos que está escribiendo un programa llamado myprog:

Pon todos tus archivos en un directorio como este

myproject/go/src/myprog/xxx.go

Luego agregue myproject/goa GOPATH

Y correr

go install myprog

De esta manera, podrá agregar otros paquetes y programas en myproject / go / src si lo desea.

Referencia: http://golang.org/doc/code.html

(Los recién llegados siempre pasan por alto este documento y, a menudo, no lo entienden bien al principio. Debería recibir la mayor atención del equipo de Go, en mi opinión)

Cuando separa el código de main.goen, por ejemplo more.go, simplemente pasa ese archivo a go build/ go run/ go installtambién.

Entonces, si previamente corriste

go build main.go

tu ahora simplemente

go build main.go more.go

Como más información:

go build --help

estados:

Si los argumentos son una lista de archivos .go, build los trata como una lista de archivos fuente que especifica un solo paquete.

Tenga en cuenta que go buildy se go installdiferencian de go runque los dos primeros estados esperan nombres de paquetes como argumentos, mientras que el último espera archivos go . Sin embargo, los dos primeros también aceptarán archivos go como lo hace la instalación de go.

Si se está preguntando: compilará solo buildlos paquetes / archivos, installproducirá objetos y archivos binarios en su GOPATH, y runcompilará y ejecutará su programa.

También podrías simplemente correr

go build

en la carpeta de su proyecto myproject / go / src / myprog

Entonces puedes escribir

./myprog

para ejecutar tu aplicación

Desde Go 1.11+, ya no se recomienda GOPATH, la nueva forma es usar los módulos Go.

Digamos que está escribiendo un programa llamado simple:

1. Crea un directorio:

   mkdir simple
   cd simple
   

2. Crea un nuevo módulo:

   go mod init github.com/username/simple
   # Here, the module name is: github.com/username/simple.
   # You're free to choose any module name.
   # It doesn't matter as long as it's unique.
   # It's better to be a URL: so it can be go-gettable.
   

3. Pon todos tus archivos en ese directorio.

4. Finalmente, ejecuta:

   go run .
   

5. Alternativamente, puede crear un programa ejecutable compilándolo:

   go build .
   
   # then:
   ./simple     # if you're on xnix
   
   # or, just:
   simple       # if you're on Windows
   

Para obtener más información, puede leer esto .

Go ha incluido soporte para módulos versionados como se propone aquí desde 1.11. El prototipo inicial de vgo se anunció en febrero de 2018. En julio de 2018, los módulos versionados aterrizaron en el repositorio principal de Go. En Go 1.14, la compatibilidad con módulos se considera lista para su uso en producción y se anima a todos los usuarios a migrar a módulos desde otros sistemas de gestión de dependencias.

Puedes usar

go build *.go 
go run *.go

ambos funcionarán también puedes usar

go build .
go run .

Depende de la estructura de su proyecto. Pero lo más sencillo es:

go build ./... -o ./myproject

luego corre ./myproject.

Suponga que la estructura de su proyecto se ve así

- hello
|- main.go

luego simplemente ve al directorio del proyecto y ejecuta

go build -o ./myproject

luego ejecutar ./myprojecten shell.

o

# most easiest; builds and run simultaneously
go run main.go

suponga que su archivo principal está anidado en un subdirectorio como un cmd

- hello
|- cmd
 |- main.go

entonces correrás

go run cmd/main.go

¡Sip! Eso es muy sencillo y ahí es donde entra en juego la estrategia del paquete. hay tres formas de mi conocimiento. estructura de carpetas:

GOPATH / src / github.com/ abc / myproject / adaptor / main.go pkg1 pkg2 advertencia: el adaptador puede contener solo los directorios principal y sun del paquete

1. navegue hasta la carpeta "adaptador". Correr:

    go build main.go

2. navegue hasta la carpeta "adaptador". Correr:

    go build main.go

3. navegue a GOPATH / src reconozca la ruta relativa al paquete principal, aquí "myproject / adapter". Correr:

    go build myproject/adapter

El archivo .exe se creará en el directorio en el que se encuentra actualmente.