Paquetes en Go sin npm ni pip

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:004:58

Paquetes en Go sin npm ni pip

Curso de Go

Clase 3 de 28

Clase 3 / 28

Recursos

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.

Jehú Frayle

Hace un año

📝 Algunas notas que he tomado de esta clase respecto a la sintaxis y estructura de Go:* package main: Todo programa ejecutable en Go debe declarar el paquete main, ya que es el punto de entrada. El compilador busca la función main() dentro de este paquete para iniciar la ejecución.

Importación de paquetes (import): Go permite importar paquetes estándar (o personalizados) que encapsulan funcionalidades:
- fmt: ofrece funciones para imprimir mensajes en consola, con o sin formato. Es equivalente a print o console.log en otros lenguajes, pero más poderoso.
- os: proporciona funciones para interactuar con el sistema operativo, como leer variables de entorno, manejar archivos, procesos, etc.
Acceso a variables de entorno (os.Getenv): os.Getenv("HOME") obtiene el valor de la variable de entorno HOME. Si no está definida, retorna una cadena vacía. Esto es útil para personalizar el comportamiento de programas según el entorno del sistema.
Estructura if sin paréntesis: En Go, a diferencia de otros lenguajes como C o Java, no se usan paréntesis alrededor de condiciones (if cond {}), pero las llaves {} son obligatorias incluso para bloques de una sola línea.
Llamada a os.Create y múltiples valores de retorno: Una característica clave de Go es que muchas funciones devuelven más de un valor. En este caso:file, err := os.Create("archivo.txt") devuelve:
- file: un puntero al archivo creado (de tipo *os.File), y
- err: un valor de tipo error, que será nil si todo salió bien. Este patrón permite manejar errores de forma explícita y sin excepciones, lo cual es una filosofía central en Go.
El valor nil: nil representa la ausencia de valor o la nada. Puede ser comparado con null en otros lenguajes, pero en Go puede aplicarse a interfaces, punteros, slices, maps, channels y errores. Cuando err != nil, significa que ocurrió un error, y debe manejarse (por ejemplo, imprimiéndolo o retornando).
defer para limpieza de recursos: defer se usa para posponer la ejecución de una instrucción hasta que la función actual finalice. Es muy útil en el manejo de recursos como archivos o conexiones de red, donde debes asegurarte de liberar esos recursos (por ejemplo, cerrar un archivo) sin importar si ocurre un error antes.defer file.Close() Esta línea garantiza que el archivo se cierre correctamente al salir de main(), aunque haya errores más adelante.
Escritura en archivos y manejo de errores: Al escribir en un archivo usando file.WriteString("texto"), también puede ocurrir un error (por ejemplo, por falta de espacio en disco). Es buena práctica capturar el resultado:_, err = file.WriteString("Hola, mundo!") if err != nil { fmt.Println("Error al escribir:", err) } Aquí usamos _ para ignorar el número de bytes escritos, ya que no lo necesitamos en este caso.

Me está gustando mucho la sintaxis de Go por lo sencilla y a la vez potente que es. Se siente como programar C++ pero con una sintaxis más propia de Python (y con llaves {} como Dios manda).

Comentarios (17)17 comentarios

Sebastian Pérez

David Ricardo

Hace 9 meses

Jesús Murillo Velasco

Mauricio Sebastian Gutierrez Perdomo

Hace 10 meses

Deiby Alejandro Triana Archila

Juan Andrés Hernández uñates

Hace 12 días

Dario Bublitz

Hace 4 meses

JUAN DAVID SALCEDO SANCHEZ

German Dario Perdomo Salas

Hace 7 meses

Juan Diego Mejia Maestre

Deivy Quesada Muñoz

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

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

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Paquetes en Go sin npm ni pip