Contenido del curso
Fundamentos de Go
Estructuras de Datos y Funciones
- 8

Sentencia switch en Go con ejemplos reales
07:16 min - 9

Arreglos en Go: fijos e inferidos
06:55 min - 10

Creación y uso de slices dinámicos en Go
08:25 min - 11

Mapas en Go: creación, acceso y manipulación de datos clave-valor
09:37 min - 12

Cómo crear y usar funciones personalizadas en Go
07:09 min - 13

Retorno de múltiples valores en Go
07:43 min - 14

Funciones variadic en Go con tres puntos
07:10 min - 15

Funciones recursivas en Go con Fibonacci
06:11 min - 16

Punteros en Go para optimizar rendimiento del sistema
05:19 min - 17

Runas en Go: bytes vs caracteres reales
06:40 min - 18

Declaración y uso de estructuras de datos en Go
09:06 min - 19

Implementación de enumeradores en Go para controlar estados
09:32 min
Manejo de Errores y Concurrencia
Buenas Prácticas en Go
Paquetes en Go sin npm ni pip
Resumen
Trabajar con paquetes en Go cambia la forma en que organizas tu código respecto a lenguajes como Python, Node o Java. Aquí descubrirás cómo importar paquetes como fmt y os, por qué Go te obliga a eliminar lo que no usas y cómo esto impacta directamente en el rendimiento de tus aplicaciones.
¿Por qué Go obliga a importar solo los paquetes que usas?
La filosofía de Go gira alrededor de la velocidad y el tamaño reducido. Por eso, cuando importas un paquete que no usas, el compilador te lanza un error y se niega a ejecutar tu aplicación.
Esto puede parecer molesto al inicio, pero tiene una razón muy clara: Go busca que solo cargues lo estrictamente necesario dentro de tu programa. Si declaras fmt y os pero no los utilizas, vas a ver un mensaje indicando que están importados pero sin uso, y no podrás compilar.
¿Qué pasa si importo un paquete y no lo uso en Go? El compilador marca un error y no te deja ejecutar el programa. Tienes que eliminar el import o usarlo dentro del código.
Y aquí viene lo interesante: esta obsesión por el rendimiento te empuja a escribir código más limpio desde el primer día.
¿Cómo importar fmt y os en un archivo main.go?
Para empezar, crea una carpeta llamada packages y dentro un archivo main.go. Lo primero que necesitas declarar es el paquete principal con package main. Después viene el bloque de imports.
En este caso vamos a importar dos paquetes:
fmt: para imprimir y formatear texto en consola.os: para interactuar con el sistema operativo, como variables de entorno y archivos.
El bloque de import se escribe entre paréntesis y cada paquete va entre comillas dobles. Una vez que los uses dentro de la función main, el error de "imported but not used" desaparece.
¿Cómo acceder a variables de entorno con el paquete os?
Dentro de main, puedes usar el paquete os para leer una variable de entorno como HOME. Con un if puedes verificar si la variable está configurada o no, y luego imprimir su valor con fmt.
Al correr go run main.go desde la terminal, el resultado muestra algo como HOME Amin Espinoza, una variable de entorno común en cualquier distribución de Linux. Ya tienes acceso al sistema operativo gracias a un solo import.
¿Cómo crear archivos desde Go usando os?
El mismo paquete os te permite crear archivos en tu entorno de trabajo. Basta con declarar un archivo, por ejemplo ejemplo.txt, y ejecutar de nuevo go run main.go.
Al refrescar Visual Studio Code, vas a ver que ejemplo.txt aparece dentro de la carpeta packages. Con dos paquetes nativos ya estás leyendo variables de entorno y manipulando el sistema de archivos.
¿En qué se diferencia Go de npm, pip o NuGet?
Aquí está una de las diferencias más grandes entre Go y otros lenguajes populares. En Go no existe pip, npm ni NuGet. No hay un gestor de paquetes externo que instale cientos de dependencias en tu proyecto.
Lo que haces es importar paquetes que Go ya puede referenciar de forma nativa o a través de módulos bien definidos. Esto te obliga a tomar decisiones más conscientes sobre qué necesitas y qué no.
¿Go tiene un gestor de paquetes como npm o pip? No de la misma forma. Go usa un sistema de imports nativo y módulos, sin instalar cientos de dependencias externas en tu proyecto.
El resultado es un trade off: ganas velocidad y tamaño reducido, pero tienes que recordar qué paquetes incluir según la funcionalidad que necesites. Saber qué paquete usar significa que vas a usar solo lo estrictamente necesario dentro de tus aplicaciones.
¿Qué ventajas tiene este enfoque para el rendimiento?
Mantener el estándar de velocidad y tamaño compacto que caracteriza a Go depende justamente de esta disciplina. Algunos beneficios concretos:
- Aplicaciones más pequeñas al compilar.
- Menos dependencias que mantener o actualizar.
- Mayor control sobre lo que entra a tu código.
- Builds más rápidos y predecibles.
Acostumbrarse a este nuevo flujo de trabajo toma tiempo si vienes de Node o Python, pero es parte del ADN de Go. Cada import es una decisión, no un reflejo automático.
¿Has tenido que rediseñar tu forma de pensar los imports al cambiar de lenguaje? Cuéntame en los comentarios qué paquete de Go te ha sorprendido más.