Skip to content

Latest commit

 

History

History
151 lines (121 loc) · 5.94 KB

01.2.md

File metadata and controls

151 lines (121 loc) · 5.94 KB
Raw

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