build-web-application-with-golang/pt-br/01.2.md

# 1.2 $GOPATH e Workspace

## $GOPATH

Os comandos em Go dependem de uma variável do sistema chama $GOPATH. Note que não é a variável $GOROOT, responsável pelo local aonde a linguagem está instalada.
Essa variável($GOPATH), marca a localização do ambiente de trabalho Go.

Em sistema UNIX-Linux, a variável do sistema deverá ser configurada da seguinte forma no arquivo `.bash_profile`

	export GOPATH=/home/apple/mygo

No Windows você precisa criar uma nova variável de ambiente chamada GOPATH, e configura-la para o diretório de trabalho, por exemplo: `c:\mygo`

É comum ter mais de um Workspace no seu $GOPATH, mas lembre-se de usar `:`(`;` no Windows) para delimitar os diretórios. Com o $GOPATH configurado você já poderá realizar o download de pacotes externos utilizando o `go get`.

Dentro do seu $GOPATH, deverá ter os seguintes diretórios:

- `src` Para arquivos de código fonte .go, .c, .g, .s.
- `pkg` Para bibliotecas compiladas .a.
- `bin` Para executáveis

Nesse livro, vamos utilizar a pasta: `mygo` como único ambiente no $GOPATH.

## Diretórios de pacotes

Crie um novo arquivo chamado sqrt.go dentro da pasta `$GOPATH/src/mymath/sqrt.go` (Note que também foi criado um diretório chamado 'mymath', o qual será o nome do nosso pacote)

Todas as vezes que um novo pacote for criado, você deverá criar uma pasta com seu nome dentro de `src`. O nome das pastas costumam ter o mesmo nome do pacote que será utilizado. Você pode ter quantas sub-pastas quiser, por exemplo: Se você criar uma pasta `$GOPATH/src/github.com/astaxie/beedb`, então seu pacote será `github.com/astaxie/beedb`. O nome do pacote sempre será o último, no caso do exemplo citado: `beedb`

Seguindo as instruções acima.
Execute os comandos abaixo:
	cd $GOPATH/src
	mkdir mymath

Crie um novo arquivo chamado `sqrt.go` e adicione o seguinte conteúdo:

	// Código fonte de $GOPATH/src/mymath/sqrt.go
	package mymath

	func Sqrt(x float64) float64 {
		z := 0.0
		for i := 0; i < 1000; i++ {
			z -= (z*z - x) / (2 * x)
		}
		return z
	}

Agora o diretório e código fonte do meu pacote foi criado. Conforme explicado, recomendo que utilize o nome do pacote correspondendo ao diretório.

## Compilando pacotes

Agora que nós criamos nosso pacote, como vamos utilizá-lo de modo prático? Existem duas maneiras de fazer isso.

1. Mude para o diretório do seu pacote e execute o comando `go install`.
2. Execute o comando acima, utilizando o nome do arquivo sem extensão, exemplo: `go install mymath`.

Após compilado, podemos ver o arquivo executável do pacote na seguinte pasta:

	cd $GOPATH/pkg/${GOOS}_${GOARCH}
	// O arquivo do pacote gerado com a extensão .a
	mymath.a

Nosso arquivo foi gerado com a extensão `.a` que é um arquivo binário, como vamos utilizá-lo?

Obviamente teremos que criar uma nova aplicação para utilizar.

Crie uma nova aplicação chamada `mathapp`

	cd $GOPATH/src
	mkdir mathapp
	cd mathapp
	vim main.go

Código fonte:

	//$GOPATH/src/mathapp/main.go código fonte.
	package main

	import (
		"mymath"
		"fmt"
	)

	func main() {
		fmt.Printf("Olá, mundo. Sqrt(2) = %v\n", mymath.Sqrt(2))
	}

Para compilar nossa aplicação, deveremos alterar o código fonte de diretório, nesse caso para `$GOPATH/src/mathapp` e executar o comando `go install`. Agora teremos um arquivo executável dentro da pasta `$GOPATH/bin/`. Para executarmos basta: `./mathapp` no terminal, e você deverá ver o seguinte retorno:

	Olá, mundo. Sqrt(2) = 1.414213562373095

## Instalando pacotes remotamente

Go possui uma ferramenta para utilizar pacotes remotos, chamada `go get`. Ela é suportada por grandes comunidades de código aberto, incluindo: GitHub, Google Code, Bitbucket e Launchpad.

	go get github.com/astaxie/beedb

Você pode utilizar o parâmetro `-u` para a atualizar os pacotes já existentes, por exemplo: `go get -u …`.

O `go get` utiliza as ferramentas de versionamento de código aberto mais utilizadas do mercado como `git` para o GitHub e o `hg` para o Google Code.
Antes de utilizar o `go get` certifique-se de ter instalado ao menos uma delas. (Nota do tradutor: Recomendo utilizar Git)

Após a execução do comando acima, você deverá ter a seguinte estrutura de diretórios:
	$GOPATH
		src
		 |-github.com
		 	 |-astaxie
		 	 	 |-beedb
		pkg
		 |--${GOOS}_${GOARCH}
		 	 |-github.com
		 	 	 |-astaxie
		 	 	 	 |-beedb.a

O comando `go get` clona o código fonte e dependencias para o seu $GOPATH/src e instala os pacote com `go install`

Você também pode utilizar pacotes de terceiros através de imports no código fonte da aplicação, utilizando a sintaxe abaixo:

	import "github.com/astaxie/beedb"

## Estrutura de diretórios completa

Se você seguiu todos os passos anteriores corretamente, sua estrurura de diretórios deverá ser algo semelhando a isso:

	bin/
		mathapp
	pkg/
		${GOOS}_${GOARCH}, A arquitetura do seu sistema: darwin_amd64, linux_amd64
      mymath.a
      github.com/
        astaxie/
          beedb.a
	src/
		mathapp
			main.go
		mymath/
			sqrt.go
		github.com/
			astaxie/
				beedb/
					beedb.go
					util.go

Agora você é capaz de ver claramente que a estrutura do diretório `bin` contém arquivos executáveis, `pkg` contém arquivos compilados e `src` contém arquivos de origem do pacote.
Agora que esclarecemos como Go gerencia dependencias e código fonte, vamos recaptular de forma rápida a estrutura; `bin` contém os executaveis, `pkg` bibliotecas ou pacotes compilados, `src` código fonte da sua aplicação e pacotes.

(O GOPATH no Windows é exibido como: `%GOPATH%`, como esse livro tem um foco maior em sistemas UNIX-Like, usuários Windows deverão realizar futuros ajustes para que tudo ocorra como esperado)

## Links

- [Sumário](preface.md)
- Seção anterior: [Instalação](01.1.md)
- Próxima seção: [Comandos em Go](01.3.md)