Golang · DacaCode

Constantes en Go y conceptos clave

Dacadev — Sun, 09 Jun 2024 00:00:00 -0500

Tabla de Contenido

Note

En el siguiente artículo aprenderás conceptos clave para entender el funcionamiento de las constantes en Go y algunos conceptos de su funcionamiento que te ayudarán a escribir mejor código.

Constantes en Go

una constante es un valor que no cambia en el tiempo y que puede ser referenciado para efectuar operaciones en un programa. Algo particular de Go es que las constantes solo existen en tiempo de compilación. Como sabrás, Go es un lenguaje de programación compilado, por lo que para obtener el código final del programa debemos construirlo. Es aquí donde las constantes son transformadas en valores literales dentro del programa.

Esto implica que durante la ejecución del código, las constantes no son alojadas en un espacio de memoria como ocurre con otros lenguajes como JavaScript, sino que son valores quemados en el binario final. Esto optimiza el rendimiento del programa y evita que se alojen valores en memoria que no son necesarios.

Declaración de constantes

En Go, la forma de declarar constantes es muy simple y similar a otros lenguajes de programación. Tenemos varias maneras de hacerlo. Veamos cada uno de los casos:

Note

Las constantes en Go solo pueden hacer referencia a tipos de dato built-in del lenguaje.

// single constant
const miConstante = 1

// multi-assignment in one line
const a, b, c = 1, 2, 3

// multi-assignment in block
const (
	anotherConstant = 1
	stringConstant = "Hello, World!"
	finalConstant = true
)

Conceptos clave de las Constantes

Kind vs Type

En Go, las constantes pueden ser de dos tipos, conocidos como kind y type. La principal diferencia es que en una constante de tipo kind no se necesita especificar el tipo de dato que se está utilizando, mientras que en una constante de tipo type sí es necesario especificarlo. Esto lo podemos observar en el siguiente ejemplo:

// kind
const name = "John"
const a = 10

// type
const c int64 = 10
const d float32 = 10

La principal ventaja del uso de kind vs type se ve en tiempo de compilación. Este comportamiento se definirá en base al tipo de constante usado:

kind: El compilador hará un análisis para determinar cuál es el tipo de dato más óptimo para efectuar la operación definida.
type: El compilador no hará ninguna inferencia o análisis sobre cuál debe ser la operación a realizar, sino que siempre usará el mismo tipo de valor (tipo) en la constante.

Esto es importante porque, recuerda, Go no convierte valores automáticamente. Si vas a usar la constante para operar con otros tipos de datos, deberás efectuar la transformación requerida explícitamente.

Veamos algunos ejemplos con constantes de tipo kind:

package main

import "fmt"

func main() {
	const age = 20
	var bigNumber int32 = 1000
	agePlusNumber := age + bigNumber

	fmt.Printf("El resultado es: %d\n", agePlusNumber)
	fmt.Println("El tipo de dato de cada variable es:")
	fmt.Printf("age: %T\n", age)
	fmt.Printf("bigNumber: %T\n", bigNumber)
	fmt.Printf("agePlusNumber: %T\n", agePlusNumber)
}

El resultado del anterior ejemplo es:

[Running] go run "/home/dacacode/dacadev/test/tempCodeRunnerFile.go"
El resultado es: 1020
El tipo de dato de cada variable es:
age: int
bigNumber: int32
agePlusNumber: int32

Como puedes observar, el tipo de age es int, mientras que el de bigNumber y agePlusNumber es int32, debido a que el compilador define cuál es el tipo más óptimo.

Ahora veamos el mismo caso usando constantes de tipo type:

package main

import "fmt"

func main() {
	const age int8 = 20
	var bigNumber int32 = 1000
	agePlusNumber := age + bigNumber

	fmt.Printf("El resultado es: %d\n", agePlusNumber)
	fmt.Println("El tipo de dato de cada variable es:")
	fmt.Printf("age: %T\n", age)
	fmt.Printf("bigNumber: %T\n", bigNumber)
	fmt.Printf("agePlusNumber: %T\n", agePlusNumber)
}

El código no se podrá compilar e incluso el IDE nos debería mostrar un error ya que Go nos dirá que la operación enter un tipo de dato y otro no esta permitido, el erro deberá lucir como el siguiente:

Pseudo-enumerados

Una funcionalidad que podemos aprovechar de las constantes y tipos definidos por el usuario es la creación de lo que podemos denominar pseudo-enumerados. En Go no disponemos de una estructura de datos de tipo Enum. sin embargo, podemos emularlas (ojo, no es que sean Enums en la práctica, pero pueden cumplir funciones similares).

La creación de estos enumerados es sencilla y consiste en definir un tipo de dato personalizado y posteriormente declarar las constantes con este tipo de dato. Para entenderlo mejor, veamos un ejemplo:

type UserPermissions int

const (
	Admin UserPermissions = 1
	Read UserPermissions = 2
	Write UserPermissions = 3
)

func validateUserPermissions(permissions UserPermissions) bool {
	// hacer algo con el código
}

En el ejemplo podemos ver que al crear el tipo UserPermissions y luego constantes de este mismo tipo, estamos usando una constante de tipo type. De esta manera podríamos controlar y exportar estas constantes del paquete. Sin embargo, no olvides que es una emulación de enumeración.

iota

Quiero hacer énfasis en la declaración de las constantes en el bloque del anterior ejemplo. En ellas podemos observar el uso de un valor numérico secuencial, es decir, que empieza desde 0, 1, 2, … Esto es importante porque Go nos ofrece una forma rápida y sencilla de realizar este mismo proceso de manera automática. Para ello tenemos el concepto de iota, que nos permite declarar la secuencia de constantes en bloque empezando desde cero.

Veamos algunos ejemplos:

const (
 A = iota // 0
 B // 1
 C // 2
)

func main() {
 fmt.Println(A, B, C) // 0 1 2
}

En el ejemplo anterior, podemos observar que estamos declarando las constantes A, B, y C y estas tendrán el valor de 0, 1 y 2 respectivamente. Lo que debemos destacar es el uso de la sintaxis iota. Si ejecutamos el código, veremos el siguiente resultado:

[Running] go run "/home/dacacode/dacadev/test/main.go"
0 1 2

De igual manera, podemos agregar operadores al valor de iota, siempre teniendo claro que el valor inicia en cero y es incremental de a 1 unidad. Veamos unos ejemplos:

const (
 KB = 1 << (10 * iota) // 1 << (10*0) = 1
 MB // 1 << (10*1) = 1024
 GB // 1 << (10*2) = 1048576
 TB // 1 << (10*3) = 1073741824
)

const (
 A = iota // 0
 B // 1
 C // 2
)

const (
 D = iota // 0
 E // 1
 F // 2
)

También podemos saltarnos los valores secuenciales de iota si estos no fueran necesarios empleando el caracter _ para ignorar el valor. Veamos un ejemplo:

const (
 _ = iota // Ignora el valor 0
 One // 1
 Two // 2
 Three // 3
 _ // Ignora el valor 4
 Five // 5
 Ten = iota * 2 // 6 * 2 = 12
 Eleven // 7 * 2 = 14
)

Con el concepto de iota ya claro, podemos facilitar la escritura de pseudo-enumeraciones de la siguiente manera:

type UserPermissions int

const (
	Admin UserPermissions = iota + 1 // 1
	Read UserPermissions // 2
	Write UserPermissions // 3
)

func validateUserPermissions(permissions UserPermissions) bool {
	// hacer algo con el código
}

Note

El término proviene de la letra griega ι (iota), que es la novena letra del alfabeto griego. Históricamente, la letra iota se usa en matemáticas y lógica para representar el elemento más pequeño en un conjunto o una secuencia, lo cual es apropiado dada su función en Go.

Aprovecha al Máximo go.work y go.mod en Golang

Dacadev — Fri, 24 May 2024 00:00:00 -0500

Tabla de Contenido

Note

En este artículo, aprenderás a usar los módulos de Golang, qué son y cómo usarlos. Además, complementaremos el uso de múltiples módulos en un proyecto con la ayuda de go.work.

¿Qué son los módulos de Golang?

Dentro del ecosistema de Golang para gestionar las dependencias de un proyecto, tenemos los módulos. Los módulos son una colección de paquetes de Golang que en conjunto forman una aplicación o librería. Entre los beneficios de los módulos de Golang se encuentran:

Especificar las dependencias y sus versiones.
Facilitar la descarga de las dependencias de un proyecto y compartirlas.
Gestionar las importaciones de paquetes que componen el módulo.
Actualizar y sincronizar las dependencias de un proyecto.

Los módulos en Golang se definen con el archivo go.mod en la raíz del proyecto y este archivo tiene la siguiente estructura:

module <nombre-del-modulo>

go <go-version>

require (
 <dependencia-1> <version>
 <dependencia-2> <version>
 ...
)

replace (
 <dependencia-1> => <ruta-local>
 <dependencia-2> => <nueva-dependencia> <version>
 ...
)

En la anterior estructura se identifican cuatro partes principales:

El nombre del módulo: Este puede tener cualquier nombre, sin embargo, es buena práctica definir un dominio en donde se alojará el módulo seguido de un path único.
Definir la versión de Go: Especifica la versión de Golang que se usará en el proyecto.
Las dependencias del proyecto: Se especifica el nombre de la dependencia y la versión que se usará. Esta sección no es obligatoria si el módulo no tiene dependencias.
Directiva replace: Permite reemplazar las dependencias del módulo por otras dependencias o rutas locales, lo cual veremos en profundidad más adelante.

Note

Podemos hacer la analogía del archivo go.mod con el archivo package.json de Node.js o el archivo requirements.txt de Python.

Junto con el archivo go.mod encontramos el archivo go.sum, el cual es un archivo autogenerado que no debes modificar manualmente. Este archivo contiene el listado de todos los paquetes de dependencias del módulo y sus respectivas versiones, sirviendo como referencia para verificar que las dependencias del módulo no hayan sido modificadas.

¿Cómo interactuar con los módulos de Golang?

Aunque podemos crear nuestros módulos manualmente creando el archivo go.mod y definiendo las dependencias, Golang nos provee de una serie de comandos para interactuar con los módulos. Los más importantes son:

go mod init <module-name> ➔ Inicializa un módulo de Golang en el directorio actual, recibe como parámetro el nombre del módulo y creará el archivo go.mod.
go mod get <package-name> ➔ Descarga un paquete de dependencia del módulo y lo registra dentro del archivo go.mod. Adicionalmente, puedes actualizar un paquete del módulo usando la bandera -u, con el comando go get -u <package-name>.
go mod tidy ➔ Sincroniza el estado actual del módulo en el archivo go.mod, eliminando las dependencias que no se estén usando y agregando las que faltan pero que sí se están usando.
go mod verify ➔ Verifica que las dependencias del módulo descargadas no hayan tenido modificaciones y estén sincronizadas con el archivo go.sum.

Note

Un comando que no forma parte de go mod pero que es muy útil es go list -m all, el cual lista todas las dependencias del módulo y sus respectivas versiones.

¿Qué es Go Workspace?

Hasta este punto, hemos visto qué son y cómo se usan los módulos, pero hay una característica adicional asociada al contexto de los módulos. Cuando trabajamos en un módulo dentro de nuestro editor de código, Go tiene como contexto el directorio del módulo. El problema surge cuando queremos trabajar con varios módulos al mismo tiempo, ya que Go no sabría identificar en qué módulo estamos trabajando.

Este era un problema común en el desarrollo, ya que muchas veces se tenían módulos que dependían de otros módulos también desarrollados por el mismo equipo. En estos casos, si necesitabas probar cambios de un módulo en otro, tenías que actualizar la dependencia en cuestión y posteriormente actualizarla en el módulo que la usará, haciendo tedioso el proceso de desarrollo.

Normalmente, para solucionar esto, el desarrollador tenía que configurar manualmente las dependencias que estaba probando para que estas apuntaran a otro módulo o una ruta dentro de su máquina local. Esto se hace con la directiva replace que mencionamos antes. Este proceso se hacía manualmente y debías estar pendiente de actualizar y revertir los cambios antes de actualizar el paquete en el repositorio.

Dado todos estos inconvenientes, se agregó go.work al ecosistema. La principal funcionalidad de los Go Workspaces es facilitar la gestión de los módulos en un mismo editor o contexto. Entre las ventajas de usar Go Work encontramos:

Permite trabajar con múltiples módulos en un mismo editor.
Puedes unificar el desarrollo de aplicaciones de Go que se componen de múltiples módulos en un mismo repositorio o ruta de trabajo.
Mejora el flujo de desarrollo.

Su uso es muy similar a lo que ya vimos para go.mod.

Note

go.work se agregó en la versión 1.18 de Go, por lo que si estás usando una versión anterior a esta, no podrás usar go.work.

¿Cómo usar go.work?

Lo primero que debemos hacer es crear el archivo go.work en la raíz del proyecto. Este archivo tiene la siguiente estructura:

go <go-version>

use (
 ./<module-path>
)

Dentro de la estructura encontramos dos partes principales:

La versión de Go: Especifica la versión de Golang que se usará en el proyecto.
Directiva use: Especifica la ruta del módulo que se usará en el proyecto.

Aunque podemos crear el archivo manualmente, lo recomendable es hacerlo a través de los comandos de Go que están definidos para los Workspaces. Al igual que los módulos de Go, Go Work tiene una serie de comandos que nos permiten interactuar con los Workspaces. Los más importantes son:

go work init ➔ Inicializa un Workspace de Golang en el directorio actual, creando el archivo go.work en la raíz del directorio.
go work use <module-path> ➔ Agrega un módulo al Workspace. Este módulo debe estar ya creado dentro del folder <module-path>, lo que significa que debe de tener definido el archivo go.mod.
go work sync ➔ Sincroniza los módulos del Workspace. Este comando descarga las dependencias de los módulos que están definidos dentro del Workspace.

Note

Si estás trabajando con un Workspace y un módulo que no está definido en el Workspace, Go no sabrá en qué módulo estás trabajando y te lanzará un error.

Con estos comandos, podrás interactuar con los módulos de Golang y el mismo Workspace será el encargado de resolver las dependencias sin necesidad de realizar configuraciones adicionales. Para explicar mejor qué significa esto, supongamos que tenemos el siguiente sistema de archivos:

proyecto/
├── go.work
├── modulo1/
└── modulo2/

Podríamos ejecutar comandos Go directamente dentro del módulo de la siguiente manera:

go test ./modulo1
go build ./modulo2

Todo desde la raíz del Workspace. Si no usáramos Workspace, tendríamos que abrir cada módulo en un nuevo editor o realizar las configuraciones pertinentes para que Go entienda qué módulo estamos trabajando.

Info

Este artículo se basa en mi experiencia como desarrollador y en la documentación que podemos encontrar en: