build-web-application-with-golang/es/01.2.md

# 1.2 $GOPATH y el ambiente de trabajo

## $GOPATH

Todos los comandos de Go dependen de una importante variable de entorno llamada $GOPATH. Favor notar que esta no es la variable $GOROOT que es la que muestra dónde Go está instalado. Esta variable apunta al ambiente de trabajo de Go en tu computadora (Yo uso esta ruta en mi computadora; si no tienes la misma estructura de directorios, por favor reemplaza por la que tengas).

En sistemas tipo Unix, la variable debe usar así:
```
	export GOPATH=/home/apple/mygo
```
En Windows, necesitas crear una nueva variable de entorno llamada GOPATH, luego estable su valor a `c:\mygo` (Este valor depende dónde tu ambiente de trabajo esté ubicado)

Está bien tener más de una ruta de ambiente de trabajo en $GOPATH, pero recuerda que debes usar `:`(`;` en Windows) para separarlos. En este punto, `go get` guardará el contenido de tu primera ruta en $GOPATH.

En $GOPATH, debes tener los siguientes tres directorios:

- `src` para archivos fuentes cuyo sufijo es .go, .c, .g, .s.
- `pkg` para archivos compilados cuyo sufijo es .a.
- `bin` para archivos ejecutables

En este libro, utilizo `mygo` cómo mi única ruta en $GOPATH.

## Directorio de paquetes

Crea archivos de código fuente de paquetes de la siguiente forma `$GOPATH/src/mymath/sqrt.go` (`mymath` es el nombre del paquete) ( **El autor utiliza `mymath` cómo su nombre de paquete, el mismo nombre para el directorio que contiene los archivos de código fuente del paquete**)

Cada vez que creas un paquete, deberías crear un nuevo folder en el directorio `src`. Los nombres de los directorios usualmente son los mismos que el paquete que vas a utilizar. Puedes tener directorios de múltiples niveles si lo deseas. Por ejemplo, si creas el directorio `$GOPATH/src/github.com/astaxie/beedb`, entonces la ruta del paquete sería `github.com/astaxie/beedb`. El nombre del paquete será el último directorio en tu ruta, que es `beedb` en este caso.

Ejecuta los siguientes comandos. (Ahora el autor mostrará unos ejemplos)
```
	cd $GOPATH/src
	mkdir mymath
```
Crea un nuevo archivo llamado `sqrt.go`, escribe el siguiente contenido en el archivo.
```
	// Código fuente 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
	}
```
Ahora el directorio de mi paquete ha sido creado y su código ha sido escrito. Recomiendo que uses el mismo nombre para tus paquetes y sus directorios correspondientes y que los directorios contenga todo el código fuente del paquete.

## Compilar paquetes

Ya hemos creado nuestra paquete, pero cómo lo compilamos para propósitos prácticos? hay dos formas de hacer esto.

1. Cambia tu ruta de trabajo al directorio de tu paquete, luego ejecuta el comando `go install`.
2. Ejecuta el comando de arriba, con la diferencia de que suministras el nombre del archivo como parámetro `go install mymath`.

Después de compilar podemos abrir el siguiente directorio.
```
	cd $GOPATH/pkg/${GOOS}_${GOARCH}
	// puedes ver que el archivo fue generado
	mymath.a
```
Este archivo cuyo sufijo es `.a`, es el archivo binario de nuestro paquete. Cómo lo usamos?

Obviamente, necesitamos crear una nueva aplicación para utilizarlo.

Crea una nueva aplicación llamada `mathapp`.
```
	cd $GOPATH/src
	mkdir mathapp
	cd mathapp
	vim main.go
```
código
```
	//$GOPATH/src/mathapp/main.go código fuente
	package main

	import (
		"mymath"
		"fmt"
	)

	func main() {
		fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
	}
```
Para compilar esta aplicación necesitas cambiar al directorio de la aplicación que en este caso es `$GOPATH/src/mathapp`, luego ejecuta el comando `go install`. Ahora deberías ver un archivo ejecutable llamado `mathapp` que se ha generado en el directorio `$GOPATH/bin/`. Para correr este programa usa el comando `./mathapp`. Deberías de ver el siguiente contenido en tu terminal:
```
	Hello world. Sqrt(2) = 1.414213562373095
```
## Instala paquete remotos

Go tiene una herramienta para instalar paquetes remotos, es el comando llamado `go get`. Soporta la mayoría de comunidades de código libre, incluyendo GitHub, Google Code, BitBucket y Launchpad.
```
	go get github.com/astaxie/beedb
```
Puedes usar `go get -u …` para actualizar tus paquetes remotos e incluso instalará todas sus dependencias.

Esta herramienta usará diferente herramientas de control de versiones para las diferentes plataformas de código libre. Por ejemplo, `git` para GitHub y `hg` para Google Code. Debido a esto, debes instalar estas herramientas de control de versiones antes de usar `go get`.

Después de ejecutar los comandos anteriormente descritos, la estructura de directorios debería verse de la siguiente forma:
```
	$GOPATH
		src
		 |-github.com
		 	 |-astaxie
		 	 	 |-beedb
		pkg
		 |--${GOOS}_${GOARCH}
		 	 |-github.com
		 	 	 |-astaxie
		 	 	 	 |-beedb.a
```
Actualmente, `go get` clona el código fuente a la ruta $GOPATH/src, luego ejecuta `go install`.

Puedes usar paquetes remotos de la misma forma que usas paquetes locales.

	import "github.com/astaxie/beedb"

## Estructura completa del directorio

Si has seguido todos los pasos anteriores, la estructura de tu directorio se debería ver de la siguiente forma.
```
	bin/
		mathapp
	pkg/
		${GOOS}_${GOARCH}, como 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
```
Ahora puedes ver la estructura de directorios claramente; `bin` contiene los archivos ejecutables, `pkg` contiene los archivos compliados y `src` los archivos de código fuente del paquete.

(El formato de las variables de entorno en Windows es `%GOPATH%`, sin embargo este libro sigue principalmente el estilo Unix, así que si eres un usuario Windows debes reemplazarlo apropiadamente)

## Links

- [Índice](preface.md)
- Sección anterior: [Instalación](01.1.md)
- Sección siguiente: [Comandos Go](01.3.md)