Tu primer programa en Go (golang)

Bien, ya vimos como se vería un programa para la consola de terminal en go en sintaxis de go, ahora veremos como crear nuestro primero programa en go.

Primero tenemos que crear nuestra carpeta del programa en nuestra carpeta src.

en nuestra carpeta del programa deberemos de crear el archivo main.go este archivo este sera el archivo que correrá primero por defecto.

En nuestro caso haré una copia del código que hay en playground(https://go.dev/play/) quedando como sigue:

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

func main() {
	fmt.Println("Hello, 世界")
}

en este caso si corremos go build estando en la carpeta de nuestro primer programa:

go build

go: go.mod file not found in current directory or any parent directory; see 'go help modules'

esto se debe a que no posees el archivo go.mod.

El archivo go.mod

Este archivo contiene todos los path hacia los modulos, teniendo esta información sobre las dependencias de estos.

Si quieres ver go.mod de una manera más entendible si vienes de PHP, lo puedes ver como si cumpliera una funcion parecida a la que realiza composer cuando le decimos que modulos requiere en composer.json.

Este archivo a difrencia de composer lo tenemos que generear con go mod init.

Exelente esto quiere decir que una vez corra en carpeta puedo este comando puedo usar go build o go run no? en este caso de preguntas yo digo siempre «PROBEMOSLO».

go mod init

go: creating new go.mod: module primero
go: to add module requirements and sums:
        go mod tidy

Genial, ahora podremos correr go build,¿Pero qué es este mensaje que nos tira? Bueno, este mensaje nos indica que tendremos que usar el comando go mod tidy si agregamos algún módulo a nuestro código, esto actualizara el archivo go.mod .

¿Qué son los go mod?

En go podemos utilizar comandos en consola de los cuales podemos sacar el pequeño groupo de comandos go mod, estos comoandos son comando que podemos utilizar para trabajar con los modulos y a eso hace referencia la palabra mod.

Módulo principal

Antes de seguir con los diferentes comandos que tiene go mod es necesario que veamos cuál sería nuestro módulo principal o nuestro main module.

El módulo principal es el módulo que contiene el directorio donde se invoca el comando go. En nuestro caso solo tenemos un módulo así que ese será el principal. Si yo abro mi archivo go.mod :

module primero

go 1.16

Mi modulo principal es primero porque es el nombre que le di a mi carpeta donde cree el proyecto.

Diferentes comandos go mod que podemos usar

Por lo general en nuestros proyectos utilizaremos go mod init y go mod tidy, pero siempre es bueno tener una idea de los diferentes comandos para los módulos que tenemos a nuestra disposición.

go list -m

Si aunque no tenga la palabra mod me pareció conveniente habla de este comando, ya que te muestra todos los módulos siendo utilizados en una lista.

go list -m all

go mod download

Al parecer go mod download nos permite conseguir un módulo que necesitemos para nuestro proyecto. Un módulo es una colección de paquetes (packages) y, por tanto, no es lo mismo.

go mod edit

go mod edit provee una interfaz en la línea de comandos para editar y dar formato a los archivos go.mod. Este solo lee un archivo go.mod y no obtiene información de los otros módulos. Por defecto lee el módulo main. Pero puede leer otros módulos también.

go mod graph

The go mod graph command prints the module requirement graph

go mod init

con este comando generaremos el archivo go.mod

go mod tidy

En caso de que tengas que actualizar go.mod puedes utilizar este comando.

go mod vendor

go mod vendor crea un directorio(carpeta) llamada vendor en el módulo principal main carpeta raíz que contiene copias de paquetes necesarios para dar soporte a la builds y tests de paquetes en el módulo principal (main module).

Cuando vendor está habilitado, los comandos go cargaran paquetes de la carpeta vendor en vez de bajar(download) los módulos de sus respectivas fuentes(sources) en el caché de módulo y usar estos copias de paquetes bajados.

go mod verify

go mod verify chequea que las dependencias del modulo principal(main) almacenado en el cache de modulo no ha sido modificado desde que se bajo(downloaded).

Esta acción la realiza comparando los hashes del módulo bajado(downloaded), el cual es un archivo .zip y el directorio extraído.

Si los módulos no han sido modificados, go mod verify dará como resultado «all modules verified». En caso contrario, devolverá que módulos han sido modificados.

go mod why

Esta definición está un poco engorrosa para traducirla al español, así que decidí dejar la versión en inglés y hacerle una en español.

go mod why shows a shortest path in the import graph from the main module to each of the listed packages.

The output is a sequence of stanzas, one for each package or module named on the command line, separated by blank lines. Each stanza begins with a comment line starting with # giving the target package or module. Subsequent lines give a path through the import graph, one package per line. If the package or module is not referenced from the main module, the stanza will display a single parenthesized note indicating that fact.

ENG – https://go.dev/ref/mod

ES – go mod why muestra los caminos(paths) mas cortos desde el modulo principal hacia los paquetes listados «esto en el import graph»

Lo devuelto es una secuencia de e estrofas, una por cada paquete o modulo nombrado en la linea de comando separados por lineas en blanco – Esto se refiere a la sintaxis de go mod why veamos la sintaxis completa para entenderlo:

go mod why [-m] [-vendor] packages... 

Tal cual es la anterior la sintaxis que se nos da para go mod why en la pagina oficial aunque yo dira que es de esta manera

go mod why [-m] [-vendor] [package1 package2 ... packageN]

Ya que especificar los paquetes también sería opcional, si no especificamos un paquete funcionara con el módulo por defecto.

Cada estrofa empezará con # dando el paquete o módulo especificado. Las líneas que le siguen dan un camino a través del graph siendo estos los paquetes(1 por línea). Si el paquete no está referenciado en el módulo principal, la estrofa nos lo especificara.

Veamos un ejemplo sencillo y este es nuestro primer programa:

go mod why

# primero
primero

Ahora un paquete que no utilizamos:

go mod why https://cs.opensource.google/go/go/+/master:src/io/

# https:/cs.opensource.google/go/go/+/master:src/io
(main module does not need package https:/cs.opensource.google/go/go/+/master:src/io)

Referencias:

https://go.dev/ref/mod