#1.3 Comandos GO

## Comandos GO

A liguagem Go possui nativamente uma série de comandos operacionais. Você pode executar o comando `go` na sua linha de comando para ver a lista completa:

![](images/1.3.go.png?raw=true)

Figura 1.3 O comando Go mostra a informação detalhada das opções

Todos são bastante úteis para nós. Vamos ver como alguns deles funcionam.

## go build

Este é o comando para testes de compilação. Ele irá compilar as dependências, se for necessário.

- Se o pacote não for o pacote `main`, como o exemplo `mymath` na seção 1.2, nada será gerado após a execução do momando `go build`. Se você precisa do arquivo `.a` no diretório `$GOPATH/pkg`, o comando a ser utilizado é o `go install`.
- Se o pacote for o pacote `main`, como o exemplo `mathapp` na seção 1.2, então será gerado um arquivo executável na mesma pasta do arquivo `.go`. Se você precisa do arquivo executável no diretório `$GOPATH/bin` deverá utilizar o comando `go install` ou `go build -o {CAMINHO_DIRETORIO}/{FILE_NAME}.exe` (N. do T.: Pode também ser utilizado para direcionar o executável para outros diretórios e o final `.exe` não é obrigatório em sistemas UNIX-Linux).
- Se houverem muitos arquivos na mesma pasta e você quiser compilar apenas um deles, então você deve inserir o nome do arquivo no final do comando `go build`. Por exemplo, `go build a.go`. Usar apenas `go build` irá compilar todos os arquivos da pasta.
- Você também pode determinar o nome do arquivo que será gerado pelo comando `go build`. Por exemplo, no projeto `mathapp` (da seção 1.2), usando `go build -o astaxie.exe` irá gerar o arquivo `astaxie.exe` ao invés de `mathapp.exe`. O nome padrão é o nome da pasta, para pacotes que não sejam main, ou o nome do primeiro arquivo de código fonte, para o pacote main.

(De acordo com o ["The Go Programming Language Specification"](https://golang.org/ref/spec), o nome do pacote é definido pela palavra que aparece na frente da palavra chave `package` na primeira linha dos arquivos de código fonte. Essa palavra não precisa necessariamente ter o mesmo nome da pasta onde o arquivo está salvo, porém o arquivo executável terá o nome da pasta por padrão.)

- O comando `go build` ignora arquivos cujo os nomes comecem por `_` ou `.`.
- Se você desejar criar diferentes arquivos de código fonte para cada sistema operacional, você pode nomear os arquivos com o nome do sistema no final. Suponha que temos alguns códigos para carregamento de arrays, eles podem ser nomeados conforme segue abaixo:

	array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go

O comando `go build` irá escolher o arquivo respectivo ao seu sistema operacional. Por exemplo, ele irá compilar o array_linux.go em sistema Linux e ignorar os demais.

## go clean

Este comando serve para uma limpeza dos arquivos gerados pelos compiladores, incluindo os arquivos abaixo:

	_obj/            // antigo diretório de objetos, deixado pelos Makefiles
	_test/           // antigo diretório de testes, deixado pelos Makefiles
	_testmain.go     // antigo arquivo do gotest, deixado pelos Makefiles
	test.out         // antigo arquivo de teste, deixado pelos Makefiles
	build.out        // antigo arquivo de teste, deixado pelos Makefiles
	*.[568ao]        // arquivos de objetos, deixado pelos Makefiles

	DIR(.exe)        // gerado pelo go build
	DIR.test(.exe)   // gerado pelo go test -c
	MAINFILE(.exe)   // gerado pelo go build MAINFILE.go

Normalmente, usa-se esse comando para uma limpeza dos arquivos antes de fazer o upload do projeto para o repositório (GitHub,por exemplo). Eles são úteis para testes locais, mas inúteis para o versionamento.

## go fmt e gofmt

As pessoas acostumadas a trabalhar com C/C++ estão sempre discutindo sobre qual o melhor estilo de código: estilo-K&R ou estilo-ANSI?
Ao trabalhar com Go, só existe um estilo de código. Por exemplo, chaves esquerdas só devem ser inseridas no final da linha e não podem estar sozinhos em uma linha, caso contrário você receberá um erro de compilação! Felizmente, você não precisa se lembrar dessa regras. O comando `go fmt` faz esse trabalho pra você, basta executar o comando `go fmt <NomeDoArquivo.go>` no terminal. As IDEs modernas usualmente já realizam esse comando de modo automático, mas a escolha de IDE é o assunto da próxima seção.

`go fmt`  é apenas um apelido (alias) que irá de fato rodar o comando 'gofmt -l -w' nos pacotes nomeados pelos caminhos de importação.

Normalmente, usamos o comando `gofmt -w` ao invés de simplesmente `go fmt`. A diferença é que o último não irá reescrever os arquivos de código fonte formatando o código. `gofmt -w src` formata o projeto inteiro.

## go get

Esse comando serve para obtenção de pacotes remotamente. Até o momento, o comando suporta BitBucket, Github, Google Code e Launchpad. De fato, duas coisas ocorrem quando esse comando é executado. Primeiramente é feito o download do código fonte e então é executado o comando `go install`. Antes de utilizar esse comando, tenha certeza de possuir instalados as seguintes ferramentas.

	BitBucket (Mercurial Git)
	Github (git)
	Google Code (Git, Mercurial, Subversion)
	Launchpad (Bazaar)

Para o correto funcionamento, além de instalar as ferramentas acima, não se esqueça de configurar corretamente sua variável `$PATH`. A propósito, esse comando também suporta nomes de domínios customizados. Use `go help remote` para mais detalhes.

## go install

Esse comando compila todos os pacotes e gera os arquivos executáveis movendo-os para `$GOPATH/pkg` ou `$GOPATH/bin`.

## go test

Esse comando carrega todos os arquivos que tenham o nome seguindo o padrão `*_test.go` e gera os arquivos de testes, imprimindo informações conforme o exemplo abaixo.

	ok   archive/tar   0.011s
	FAIL archive/zip   0.022s
	ok   compress/gzip 0.033s
	...

Ele testa todos os arquivos por padrão. Use o comando `go help testflag` para mais detalhes e informações.

## godoc

Muitos afirmam não ser necessária a utilização de bibliotecas externas para documentação dos programas Go, uma vez que Go já possui uma poderosa ferramenta para documentação nativamente (de qualquer maneira, veja a biblioteca criada por mim, a [CHM](https://github.com/astaxie/godoc) (N. do T.: Link do autor original)).

Sendo assim, como devemos buscar essa documentação para cada um dos pacotes?
Se você quiser mais informações para um pacote nativo (builtin), você pode usar o comando `godoc builtin`. De forma semelhante, você pode usar `godoc net/http` para encontrar a documentação do pacote `http`, por exemplo. E ainda, se quiser mais detalhes de uma função específica, você pode usar `godoc fmt Printf` e `godoc -src fmt Printf` para ver o código fonte da função.

Finalmente, você pode ainda executar o comando `godoc -http=:8080` e, em seguida, abrir `127.0.0.1:8080` no seu navegador. Você terá uma cópia local de golang.org. Ele vai mostrar não só os pacotes padrões, mas também aqueles encontrados em `$GOPATH/pkg`. Esse recurso é ótimo para pessoas que sofrem de algum bloqueio como aquele do Great Firewall of China, por exemplo.

## Outros comandos

Go possui ainda muitos outros comandos além dos citados aqui. Seguem alguns exemplos.

	go fix // atualiza o código de uma versão antiga anterior a go1 para uma nova versão depois de go1
	go version // exibe informações sobre sua versão de Go
	go env //exibe as variáveis de ambiente relacionados a Go
	go list // lista todos os pacotes instalados
	go run // compila os arquivos temporários e executa a aplicação

Mesmo sobre os comandos explicados até aqui, existem vários outros detalhes que não foram discutidos. Você sempre pode usar `go help <command>` para detalhes e informações completas.

## Links

- [Sumário](preface.md)
- Seção anterior: [$GOPATH e Workspace](01.2.md)
- Próxima seção: [Ferramentas de desenvolvimento Go](01.4.md)