GOPATH y Módulos

Introducción

En esta práctica de laboratorio, exploraremos las dos formas principales de gestionar dependencias en Go: GOPATH y Go Modules. Estos conceptos son fundamentales para organizar y administrar proyectos de Go de manera profesional y eficiente.

Puntos de conocimiento:

GOPATH
GOROOT
Go Modules (Módulos de Go)

Preparación

En este paso, prepararemos el entorno de trabajo descomprimiendo un archivo comprimido proporcionado para la práctica.

Primero, abre la terminal y dirígete al directorio del proyecto escribiendo lo siguiente:
```
cd ~/project
```
Descomprime el archivo helloWorld.tar.gz en el directorio actual:
```
tar -xzf helloWorld.tar.gz
```
Una vez extraído el archivo, verifica si se ha creado la carpeta helloWorld:
```
ls helloWorld
```

Esto mostrará el contenido del directorio helloWorld si la descompresión se realizó correctamente.

Conceptos básicos de GOPATH

Antes de la versión 1.11 de Go, el lenguaje utilizaba un espacio de trabajo específico llamado GOPATH para almacenar todo el código. En este paso, entenderemos cómo funciona esta estructura tradicional.

GOROOT es el directorio donde está instalado Go, incluyendo sus herramientas y los paquetes de la biblioteca estándar.
GOPATH es el lugar donde reside tu código personal de Go y contiene tres directorios principales:
- src: Almacena el código fuente de tus proyectos.
- bin: Almacena los archivos ejecutables compilados.
- pkg: Almacena paquetes compilados que no son ejecutables.

Para verificar los valores actuales de GOPATH y GOROOT, ejecuta los siguientes comandos:

## Verificar el directorio GOPATH
go env | grep GOPATH

## Verificar el directorio GOROOT
go env | grep GOROOT

Estos comandos mostrarán las rutas configuradas para GOPATH y GOROOT en tu entorno actual.

Inicialización de módulos

Los Go Modules, introducidos en Go 1.11 y habilitados por defecto desde la versión 1.13, surgieron para resolver dos problemas principales:

Dependencia excesiva de GOPATH: Antes de los módulos, el código debía guardarse obligatoriamente dentro de GOPATH/src. Con Go Modules, puedes organizar tu código en cualquier carpeta de tu sistema.
Gestión de versiones: Los módulos permiten que los proyectos controlen y rastreen dependencias con versiones específicas, facilitando el trabajo con diferentes versiones de un mismo paquete.

En este paso, inicializaremos un módulo de Go para un nuevo proyecto.

Crea un nuevo directorio para el proyecto llamado testHello:
```
cd ~/project
mkdir testHello
```
Entra en el directorio testHello:
```
cd testHello
```
Inicializa el módulo de Go para este proyecto:
```
go mod init testHello
```
La salida debería ser:
```
go: creating new go.mod: module testHello
```
Crea un nuevo archivo de Go llamado testHello.go dentro de la carpeta testHello con el siguiente contenido:
```
touch testHello.go
```
```
package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}
```

Ahora hemos inicializado el proyecto testHello utilizando Go Modules y le hemos añadido un programa sencillo.

Importación de paquetes locales con módulos

En este paso, demostraremos cómo importar y utilizar otros módulos locales dentro de tu proyecto de Go.

El paquete helloWorld en la carpeta homónima ya ha sido inicializado con Go Modules. Del mismo modo, el paquete test, que también usa módulos, importa la función Say del paquete helloWorld.

Para explorar esto, sigue estos pasos:

Primero, observa la estructura de los directorios helloWorld y test:

helloWorld
├── go.mod
└── helloWorld.go
test
├── go.mod
└── test.go

A continuación, abre el archivo test/go.mod. Deberías ver lo siguiente:

module test

go 1.15

require "helloWorld" v0.0.1
replace "helloWorld" => "../helloWorld"

La directiva replace le indica a Go que utilice la ruta local ../helloWorld en lugar de intentar buscar el paquete en un repositorio externo. La directiva require especifica que el paquete test depende de la versión v0.0.1 del paquete helloWorld.

Parámetro	Descripción
module	Especifica el nombre del paquete actual
require	Especifica las dependencias necesarias
replace	Reemplaza una dependencia por otra (útil para desarrollo local)
exclude	Excluye dependencias específicas

Para ejecutar el archivo test.go en el paquete test:

cd ~/project/test
go run test.go

El resultado debería ser:

hello, world

Importación de paquetes remotos

En Go, puedes importar paquetes remotos de forma sencilla. Vamos a demostrarlo utilizando un paquete alojado en GitHub.

Crea un directorio llamado remoteModule:

cd ~/project
mkdir remoteModule
cd remoteModule

Inicializa el módulo de Go:
```
go mod init remoteModule
```
Crea un archivo remote.go dentro de la carpeta remoteModule con el siguiente contenido:
```
touch remote.go
```
```
package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.StringTobase64("miiy")
}
```
Este programa importa el paquete chap02module desde GitHub y utiliza su función StringTobase64.
Ejecuta el archivo remote.go usando los siguientes comandos:
```
go get github.com/labex-labs/golang-dev-code/chap02module
go run -v remote.go
```
Nota: Los usuarios de la versión gratuita no tienen acceso a internet, por lo que no podrán ejecutar este comando. Actualiza al plan Pro para obtener acceso completo a la red.

El comando go get descargará el paquete chap02module de GitHub y lo guardará en la caché de módulos de tu sistema. Una vez hecho esto, el comando go run ejecutará tu programa.

Mini Desafío

En este paso, pondremos a prueba tus conocimientos creando un nuevo archivo que utilice la función Hello del módulo remoto.

Crea una carpeta llamada remoteModule2:

cd ~/project
mkdir remoteModule2
cd remoteModule2

Inicializa el módulo de Go:
```
go mod init remoteModule2
```

Crea un archivo remote2.go con el siguiente contenido:

touch remote2.go

package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.Hello()
}

Ejecuta el programa:

go get github.com/labex-labs/golang-dev-code/chap02module
go run remote2.go

La salida debería ser:

hello

Resumen

En esta práctica de laboratorio, hemos aprendido lo siguiente:

El significado y propósito de los directorios GOPATH y GOROOT.
Los conceptos básicos de Go Modules para la gestión de dependencias.
Cómo inicializar y utilizar Go Modules en un proyecto real.
Cómo importar y utilizar paquetes de Go tanto locales como remotos.

Al finalizar esta sesión, deberías sentirte cómodo utilizando Go Modules para organizar y gestionar las dependencias en tus propios proyectos de Go.