Como compilar o programa Go que consiste em vários arquivos?

Eu tenho um pequeno programa que consiste em três arquivos, todos pertencentes ao mesmo pacote (principal), mas quando faço "ir construir main.go", a compilação não é bem-sucedida. Quando era apenas um arquivo (main.go), tudo funcionava bem. Agora que fiz algum esforço para separar o código, parece que o compilador não consegue encontrar o que foi retirado de main.go e colocado nesses dois outros arquivos (que residem no mesmo diretório do main.go) . O que resulta em erros de "tipo 'indefinido".

Como compilar este programa que consiste em vários arquivos?

Novo método ( recomendado ):

Por favor, dê uma olhada nesta resposta .

À moda antiga:

Suponha que você esteja escrevendo um programa chamado myprog:

Coloque todos os seus arquivos em um diretório como este

myproject/go/src/myprog/xxx.go

Em seguida, adicione myproject/goao GOPATH

E corra

go install myprog

Desta forma, você poderá adicionar outros pacotes e programas em myproject / go / src se desejar.

Referência: http://golang.org/doc/code.html

(este documento sempre faz falta para os novatos e muitas vezes é mal compreendido no início. Ele deve receber a maior atenção da equipe Go IMO)

Quando você separa o código do main.goem, por exemplo more.go, simplesmente passa esse arquivo para go build/ go run/ go installtambém.

Então, se você já executou

go build main.go

você agora simplesmente

go build main.go more.go

Como mais informações:

go build --help

afirma:

Se os argumentos forem uma lista de arquivos .go, build os tratará como uma lista de arquivos de origem especificando um único pacote.

Observe que go builde go installdiferem de go runque os dois primeiros estados esperam nomes de pacotes como argumentos, enquanto o último espera arquivos go . No entanto, os dois primeiros também aceitam arquivos go como go install.

Se você está se perguntando: build irá apenas buildos pacotes / arquivos, installirá produzir objetos e arquivos binários em seu GOPATH, e runirá compilar e executar seu programa.

Você também pode simplesmente correr

go build

na pasta do seu projeto myproject / go / src / myprog

Então você pode simplesmente digitar

./myprog

para executar seu aplicativo

Desde o Go 1.11+, GOPATH não é mais recomendado, a nova forma é usar os módulos Go.

Digamos que você esteja escrevendo um programa chamado simple:

1. Crie um diretório:

   mkdir simple
   cd simple

2. Crie um novo 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. Coloque todos os seus arquivos nesse diretório.

4. Finalmente, execute:

   go run .

5. Como alternativa, você pode criar um programa executável construindo-o:

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

Para obter mais informações, você pode ler isto .

Go incluiu suporte para módulos versionados conforme proposto aqui desde 1.11. O protótipo inicial do vgo foi anunciado em fevereiro de 2018. Em julho de 2018, os módulos versionados chegaram ao repositório Go principal. No Go 1.14, o suporte do módulo é considerado pronto para uso em produção e todos os usuários são incentivados a migrar para módulos de outros sistemas de gerenciamento de dependências.

Você pode usar

go build *.go 
go run *.go

ambos funcionarão também você pode usar

go build .
go run .

Depende da estrutura do seu projeto. Mas o mais simples é:

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

então corra ./myproject.

Suponha que a estrutura do seu projeto se pareça com este

- hello
|- main.go

então você simplesmente vai para o diretório do projeto e executa

go build -o ./myproject

em seguida, execute ./myprojectno shell.

ou

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

suponha que seu arquivo principal esteja aninhado em um subdiretório como um cmd

- hello
|- cmd
 |- main.go

então você vai correr

go run cmd/main.go

Sim! Isso é muito simples e é aí que a estratégia do pacote entra em jogo. existem três maneiras de meu conhecimento. estrutura da pasta:

Aviso de GOPATH / src / github.com/ abc / myproject / adapter / main.go pkg1 pkg2: o adaptador pode conter apenas os diretórios principal e sun do pacote

1. navegue até a pasta "adaptador". Corre:

    go build main.go

2. navegue até a pasta "adaptador". Corre:

    go build main.go

3. navegue até GOPATH / src e reconheça o caminho relativo ao pacote principal, aqui "myproject / adapter". Corre:

    go build myproject/adapter

O arquivo exe será criado no diretório em que você está atualmente.