En las lecciones anteriores trabajamos con valores únicos. Pero, ¿qué pasa cuando necesitamos guardar una lista de usuarios, un inventario de productos o un diccionario de traducciones? Para eso usamos las colecciones de datos.

1. Arrays: Listas de tamaño fijo

Un Array en Go es una secuencia numerada de elementos con un tamaño específico que no puede cambiar.

• Se define indicando el tamaño entre corchetes [ ] seguido del tipo de dato.
• Por defecto, se inicializan con «ceros» (0 para números, «» para strings).

Ejemplo de Array:

var a [5]int
fmt.Println("emp:", a) // Salida: [0 0 0 0 0]

a[4] = 100
fmt.Println("set:", a)
fmt.Println("get:", a[4])
fmt.Println("len:", len(a)) // Tamaño del array

2. Slices: Las listas dinámicas (El estándar en Go)

• Usamos la función make para crearlos.
• Usamos append para añadir elementos (esto devuelve un nuevo slice).

Ejemplo de Slice:

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"

// Añadir elementos
s = append(s, "d")
s = append(s, "e", "f")

fmt.Println("slice:", s)
fmt.Println("largo:", len(s))

El operador de «Slicing»:

Puedes obtener una parte de un slice usando la sintaxis [bajo:alto]

l := s[2:5] // Elementos desde el índice 2 hasta el 4
fmt.Println("sl1:", l)

3. Maps: Diccionarios Clave-Valor

Un Map es una estructura de datos asociativa (conocida en otros lenguajes como Hash, Diccionario o Objeto). Relaciona una clave con un valor.

• Se crean con make(map[tipo_clave]tipo_valor).
• Son extremadamente rápidos para buscar información.

Ejemplo de Map:

m := make(map[string]int)

m["manzana"] = 5
m["banana"] = 10

fmt.Println("map:", m)

// Eliminar un elemento
delete(m, "manzana")

// Verificar si una clave existe
valor, existe := m["pera"]
fmt.Println("¿Existe pera?:", existe)

Resumen de diferencias:

Array   Fijo        Casi nunca (solo para tamaños conocidos y constantes).
Slice   Dinámico    El 90% de las veces para listas de datos.
Map     Dinámico    Para búsquedas rápidas mediante una clave o ID.

Reto de la Lección:

Crea un programa que tenga un Map de países y sus capitales. Luego, añade un nuevo país, elimina uno existente y finalmente imprime el mapa completo usando un ciclo for (Pista: investiga cómo usar for range en Maps).

En la lección anterior aprendimos a declarar variables y constantes. Ahora vamos a darle «inteligencia» a nuestro código. El control de flujo nos permite decidir qué partes del programa se ejecutan y cuántas veces deben repetirse.

En Go, el control de flujo es minimalista y muy potente.

1) El Ciclo for:

En Go, solo existe un comando para hacer ciclos: for. No existe while ni do-while, porque for puede hacerlo todo.

Ejemplo A: Estilo «While» (Solo condición)

Se usa cuando quieres que algo se repita hasta que una condición deje de cumplirse.

i := 1
for i <= 3 {
    fmt.Println(i)
    i = i + 1
}

Ejemplo B: Estilo Clásico

El formato estándar de tres partes: inicialización, condición y post-iteración.

for j := 7; j <= 9; j++ {
    fmt.Println(j)
}

Ejemplo C: Ciclo Infinito y break

Si no pones ninguna condición, el ciclo se ejecutará para siempre a menos que uses un break

for {
    fmt.Println("Esto se repite una vez y sale")
    break
}

2) Condicionales if / else

Las condicionales en Go son muy limpias. Una regla de oro: no se usan paréntesis () para la condición, pero las llaves {} son siempre obligatorias.

Ejemplo Básico:

if 7%2 == 0 {
    fmt.Println("7 es par")
} else {
    fmt.Println("7 es impar")
}

Ejemplo con declaración corta:

Go permite declarar una variable que solo vivirá dentro del bloque del if. Esto es excelente para mantener el código limpio.

if num := 9; num < 0 {
    fmt.Println(num, "es negativo")
} else if num < 10 {
    fmt.Println(num, "tiene un solo dígito")
} else {
    fmt.Println(num, "es un número grande")
}

3) La Estructura switch

El switch es la mejor forma de evitar muchos if anidados cuando tienes varias opciones para una misma variable.

Ejemplo de Switch con valores:

i := 2
fmt.Print("Escribe ", i, " como ")
switch i {
case 1:
    fmt.Println("uno")
case 2:
    fmt.Println("dos")
case 3:
    fmt.Println("tres")
}

Ejemplo de Switch múltiple y por defecto:

Puedes evaluar varias opciones en un solo case y usar default para cuando ninguna coincida.

import "time"

switch time.Now().Weekday() {
case time.Saturday, time.Sunday:
    fmt.Println("Es fin de semana 🥳")
default:
    fmt.Println("Es día de semana 💼")
}

Ejemplo de Switch sin expresión (como If/Else):

Si no le pasas una variable al switch, funciona como una cadena de condiciones lógicas muy elegante.

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("Es antes del mediodía")
default:
    fmt.Println("Es después del mediodía")
}

For: Único bucle disponible. Úsalo para todo tipo de repeticiones.

If/Else: No lleva paréntesis. Permite declarar variables temporales.

Switch: No necesita la palabra break al final de cada caso; Go lo hace por ti automáticamente.

Crea un programa que recorra los números del 1 al 20 usando un ciclo for. Si el número es divisible entre 3, imprime «Fizz», si es divisible entre 5 imprime «Buzz», y si es divisible entre ambos imprime «FizzBuzz». ¡Es el famoso reto FizzBuzz!

¡Bienvenidos a la primera entrega de nuestro estudio de Golang desde Cero! Hoy aprenderemos cómo Go maneja la información básica. Entender estos tres conceptos es vital porque Go es un lenguaje de tipado estático, lo que significa que es muy preciso con el tipo de datos que usamos.

1) Valores y Tipos de Datos Básicos

Go tiene varios tipos de valores fundamentales. Antes de guardarlos en variables, debemos entender qué son:

Strings (Cadenas): Se escriben entre comillas dobles "Hola". Puedes unirlas (concatenar) usando el símbolo +.

Integers (Enteros): Números sin decimales, como 1 o 100.

Floats (Flotantes): Números con decimales, como 3.14.

Booleans (Booleanos): Valores lógicos que solo pueden ser true (verdadero) o false (falso).

fmt.Println("go" + "lang") // Salida: golang
fmt.Println("1+1 =", 1+1) // Salida: 2
fmt.Println(7.0/3.0) // Salida: 2.3333333333333335
fmt.Println(true && false) // Salida: false

2) Variables: Almacenando Información

En Go, existen varias formas de declarar variables. Una variable es simplemente un nombre que le damos a un espacio en la memoria para guardar un valor.

La palabra clave var

Es la forma explícita. Puedes declarar una o varias variables a la vez.

var a = "inicial"
var b, c int = 1, 2
var d = true

El operador corto :=

Esta es la forma más común de declarar y asignar una variable dentro de funciones. Go deduce automáticamente el tipo de dato.

f := "manzana" // Go sabe que es un string

Para números es 0.

Para booleanos es false.

Para strings es "" (vacío).

3) Constantes: Valores que no cambian

Las constantes son valores que se definen al inicio y no pueden ser modificados durante la ejecución del programa. Se declaran con la palabra clave const.

Pueden ser caracteres, strings, booleanos o valores numéricos.

No puedes usar el operador corto := para declarar constantes.

const s string = "constante"
const n = 500000000

Las constantes en Go son muy potentes porque pueden realizar cálculos de alta precisión antes de ser asignadas a un tipo específico.

Resumen para tu práctica:

Valores: Son los datos crudos (texto, números).

Variables (var / :=): Son contenedores que pueden cambiar su contenido.

Constantes (const): Son reglas fijas; una vez que las defines, nadie puede cambiarlas.

Para empezar nuestra serie de aprendizaje, lo primero es dejar tu «laboratorio» listo. En este post configuraremos todo lo necesario para que tu única preocupación sea escribir código.

1) Descarga e Instalación de Go

El primer paso es obtener el instalador oficial. Go es multiplataforma, por lo que funciona igual de bien en Windows, macOS y Linux.

• Paso A: Ve al sitio oficial golang.org/dl.

• Paso B: Descarga el instalador correspondiente a tu sistema operativo.

• Paso C: Sigue el asistente de instalación (en Windows es el clásico «Next, Next, Finish»).

2) Verificando la Instalación

Una vez instalado, debemos comprobar que nuestra computadora reconoce el comando go. Abre una terminal (CMD o PowerShell en Windows) y escribe:

go version

Si ves algo como

go version go1.2x.x

¡felicidades! Ya tienes el motor instalado.

3) El Editor de Código: Visual Studio Code

Aunque puedes usar cualquier editor, VS Code es el estándar de la industria para Go debido a su excelente soporte oficial.

1. Descarga VS Code. visualstudio.com/download

2. Ve al apartado de Extensiones (icono de cuadrados en la izquierda).

3. Busca la extensión oficial llamada «Go» (desarrollada por el equipo de Go de Google) e instálala.

Tip Pro: Una vez instalada la extensión, presiona Ctrl+Shift+P, escribe «Go: Install/Update Tools», selecciónalo todo y dale a OK. Esto instalará herramientas de autocompletado y depuración que te harán la vida mucho más fácil.

4) Tu primer espacio de trabajo (Go Modules)

A diferencia de otros lenguajes antiguos, hoy en día Go usa Modules para gestionar proyectos. Para crear tu primer proyecto oficial, crea una carpeta y dentro de la terminal escribe:

go mod init mi-proyecto

Esto creará un archivo go.mod que mantendrá todo en orden mientras crecemos en el estudio.

Anatomía de un archivo .go: ¿Qué estamos escribiendo?

Para el ojo inexperto, un archivo de Go puede parecer confuso, pero en realidad sigue una estructura jerárquica muy lógica. Vamos a desglosar el «Hola Mundo» para entender sus partes:

1. La Declaración del Paquete (package main)

Todo archivo de Go debe comenzar con la palabra package.

• ¿Por qué? Go organiza el código en paquetes para que sea modular y reutilizable.

• ¿Por qué main? El nombre main es especial. Le indica al compilador de Go que este archivo no es una simple librería de funciones, sino un programa ejecutable. Sin un package main, no podrías generar un archivo .exe o un binario para correr.

2. La Sección de Importación (import "fmt")

La palabra import se usa para traer herramientas de otros paquetes.

• ¿Por qué se hace? Por eficiencia. Go es un lenguaje minimalista; no carga todas las funciones del mundo por defecto porque eso haría que tus programas fueran pesados y lentos.

• "fmt": Es el paquete estándar para el formateo de texto (I/O). Si quieres imprimir algo en pantalla o leer datos del teclado, necesitas importar fmt.

3. La Función Principal (func main())

Esta es la «puerta de entrada» de tu programa.

• func: Es la palabra clave para definir una función.

• main(): El programa siempre buscará esta función exacta para empezar a trabajar. Cuando la función main termina su ejecución, el programa se cierra.

• Las llaves { }: Todo lo que esté dentro de estas llaves es el «cuerpo» de la función, es decir, las instrucciones que se ejecutarán una tras otra.

4. La instrucción (fmt.Println)

Aquí estamos llamando a la función Println que vive dentro del paquete fmt que importamos arriba. El punto . sirve para entrar en ese paquete y usar sus herramientas.

Reglas de oro en la estructura de Go:

1. Orden estricto: Primero va el package, luego los import y al final las funciones (func).

2. Importaciones limpias: Si importas un paquete pero no lo usas, Go te dará un error y no te dejará compilar. Esto mantiene tu código libre de «basura».

3. Llaves obligatorias: La llave de apertura { debe ir siempre en la misma línea que la declaración de la función. Si la pones en la línea de abajo, el compilador se quejará.

package main

import "fmt"

func main() {
    fmt.Println("¡Hola, Mundo desde mi blog!")
}

En el mundo de la programación, pocos lenguajes han logrado una adopción tan masiva en tan poco tiempo como Go. A menudo llamado Golang (debido a su dominio original, golang.org), este lenguaje nació de la necesidad de resolver problemas complejos en una era de sistemas distribuidos y multinúcleo.

1. El Origen: ¿Quién y Por Qué?

Go no nació en un garaje, sino en los pasillos de Google en 2007. Sus creadores no son precisamente novatos; hablamos de leyendas de la computación: Robert Griesemer, Rob Pike y Ken Thompson (este último, uno de los padres de Unix y el lenguaje C).

La motivación fue simple: frustración. Los ingenieros de Google sentían que los lenguajes que usaban (como C++ o Java) eran demasiado complejos, lentos de compilar y no estaban diseñados para aprovechar los procesadores modernos con múltiples núcleos.

2. Objetivos de Diseño: Menos es Más

El equipo de Go se propuso crear un lenguaje que combinara lo mejor de dos mundos:

• La eficiencia y seguridad de un lenguaje compilado (como C++).
• La facilidad de uso y velocidad de desarrollo de un lenguaje dinámico (como Python).

Sus pilares fundamentales:

• Simplicidad: Go tiene una sintaxis limpia. Se eliminaron características que suelen causar confusión, como la herencia de clases compleja o la sobrecarga de operadores.
• Concurrencia Nativa: A través de las Goroutines, Go permite ejecutar miles de tareas simultáneamente con un consumo de memoria mínimo.
• Compilación ultra rápida: Olvídate de esperar minutos; los programas en Go se compilan en segundos, generando un único archivo ejecutable sin dependencias externas.

3. ¿Para qué se utiliza Go hoy en día?

Si alguna vez has usado herramientas modernas de infraestructura, es muy probable que estés usando Go sin saberlo. Es el lenguaje detrás de:

• Docker y Kubernetes: Las piezas clave de la «contenedorización».
• Microservicios: Su ligereza lo hace ideal para arquitecturas escalables.
• Herramientas de Red: Por su manejo eficiente de protocolos y APIs.

4. ¿Vale la pena aprenderlo en 2026?

La respuesta es un rotundo sí. Mientras otros lenguajes se vuelven más pesados, Go se mantiene fiel a su minimalismo. Es uno de los lenguajes mejor pagados en la industria y la demanda de desarrolladores que entiendan la concurrencia en Go sigue creciendo.

Ejemplo Práctico: Hola Mundo

package main

import "fmt"

func main() {
    fmt.Println("¡Hola, Mundo desde mi blog!")
}

Comandos básicos:

Para ejecutarlo directamente:

go run hola.go

Salida:

¡Hola, Mundo desde mi blog!

Para compilar un binario:

go build hola.go

Pronto Iniciaremos un estudio sobre Golang desde Cero. Aprenderemos desde la sintaxis básica hasta la creación de microservicios escalables y mucho más. ¡No te lo pierdas!.

En este primer articulo se le mostrara como encriptar cadenas de texto usando el algoritmo aes-256-ctr de la librería crypto de nodeJS y la librería OpenSSL de PHP.

En el siguiente enlace se encuentra la documentación oficial de la librería crypto de nodeJS.

https://nodejs.org/api/crypto.html#cryptocreatecipherivalgorithm-key-iv-options

https://nodejs.org/api/crypto.html#cryptocreatedecipherivalgorithm-key-iv-options

/* crypto.js */

const crypto = require("crypto");

const algorithm = "aes-256-ctr";
const secretKey = "96c8f9d8d51c410532a781cfb37a73ab";
const iv = "d0229568bbc258c6";

const encrypt = (text) => {
    const cipher = crypto.createCipheriv(algorithm, secretKey, iv);
    const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);
    return encrypted.toString("hex");
};

const decrypt = (hash) => {
    const decipher = crypto.createDecipheriv(algorithm, secretKey, iv);
    const decrpyted = Buffer.concat([decipher.update(Buffer.from(hash, "hex")), decipher.final()]);
    return decrpyted.toString();
};

module.exports = {
    encrypt,
    decrypt,
};

Implementación:

/* run.js */

const { encrypt, decrypt } = require("./crypto");

const cadena = "Soy un texto";

const encriptado = encrypt(cadena);
console.log(`Cadena Encriptado: => ${encriptado}`);

const desencriptado = decrypt(encriptado);
console.log(`Cadena Desencriptado: => ${desencriptado}`);

Salida:

Cadena Encriptado: => 684cc5e0d1956c4c470e9986
Cadena Desencriptado: => Soy un texto

<?php
$texto = 'Soy un texto';
$algorithm = 'aes-256-ctr';
$key = '96c8f9d8d51c410532a781cfb37a73ab';
$iv = 'd0229568bbc258c6';

$encrypted_data = bin2hex(openssl_encrypt($texto, $algorithm, $key, OPENSSL_RAW_DATA, $iv));
echo "Encrypted: ".$encrypted_data."\n";

$decrypted_data = openssl_decrypt(hex2bin($encrypted_data), $algorithm, $key, OPENSSL_RAW_DATA, $iv);
echo "Decrypted: ".$decrypted_data."\n";

$decrypted_data = openssl_decrypt(pack('H*', $encrypted_data), $algorithm, $key, OPENSSL_RAW_DATA, $iv);
echo "Decrypted: ".$decrypted_data."\n";

?>

Salida:

Encrypted: 684cc5e0d1956c4c470e9986
Decrypted: Soy un texto
Decrypted: Soy un texto

De este modo se puede enviar y recibir datos entre ambos lenguajes de forma segura, siempre y cuando el ( algoritmo – key – iv ) sean iguales en ambos lenguajes.

Happy Coding!