Manejo de Dependencias y Módulos en Go

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Contenido del curso

Introducción

Programación orientada a objetos

Go Modules

Testing

Concurrencia

Proyecto: servidor con worker pools

Conclusión

30
Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia
02:34 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:24

Manejo de Dependencias y Módulos en Go

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Clase 15 de 30

Clase 15 / 30

Recursos

¿Cómo manejar dependencias en Go?

Entender cómo manejar las dependencias en Go puede ser el primer paso para integrar módulos de otros proyectos de manera eficiente. Al igual que en Node.js o Python utilizas herramientas como NPM o PIP, en Go también existe un sistema que te facilitará la vida. ¡Veamos cómo funciona!

¿Cómo se crea un módulo en Go?

El proceso es sencillo y se inicia desde la terminal:

Dirígete a la carpeta donde quieres crear el módulo.
Ejecuta el siguiente comando para inicializar un nuevo módulo:
```
go mod init github.com/tu-usuario/nombre-modulo
```

Esta convención no solo crea el módulo, sino que también prepara el entorno para hacer uso de dependencias futuras.

¿Cómo instalar una dependencia?

Una vez que tengas tu módulo listo, instalar dependencias externas es fácil:

Usa el comando go get seguido del repositorio y módulo que deseas:
```
go get github.com/usuario/modulo
```

Esto modifica automáticamente el archivo go.mod, donde se registran las dependencias utilizadas, y genera un archivo go.sum para verificar la integridad del código adquirido.

¿Qué hacer si no uso una dependencia?

Para eliminar dependencias no utilizadas, emplea el siguiente comando:

go mod tidy

Este comando limpia las referencias innecesarias, asegurando que solo mantengas lo esencial para tu proyecto.

¿Cómo usar caché para mejorar la gestión de dependencias?

Cuando descargas módulos, Go los almacena en un caché para optimizar futuras instalaciones. Para visualizar este caché:

go mod download -json

Esto muestra en detalle dónde y cómo se almacenan localmente tus dependencias.

¿Cómo utilizar las dependencias en tu proyecto?

Para utilizar un módulo que has instalado, importa el paquete en tu archivo main.go y llama las funciones necesarias. Supongamos que ya instalaste hello-mode, he aquí cómo podrías hacerlo:

package main

import (
    "github.com/usuario/hello-mode"
)

func main() {
    hello-mode.SayHello("Platzi")
}

La herramienta de autocompletar de tu editor facilitará el proceso, sugiriéndote funciones de los módulos importados.

¿Cómo manejar múltiples versiones de un módulo?

Si necesitas diferentes versiones de un mismo módulo, puedes hacerlo como sigue:

Realiza la instalación de la versión específica:
```
go get github.com/usuario/modulo/v2
```

Utiliza alias en tu importación para diferenciarlas:

import (
    moduloV1 "github.com/usuario/modulo/v1"
    moduloV2 "github.com/usuario/modulo/v2"
)

Cuando invoques sus funciones, usa estos alias para especificar qué versión estás utilizando.

Consejos prácticos para manejar dependencias

Verificar la documentación: Antes de actualizar o instalar un nuevo módulo, revisa la documentación para prever cambios que podrían afectar tu código.
Compatibilidad de versiones: Ten cuidado al usar nuevas versiones, ya que podrían incluir cambios incompatibles. Usar alias puede ayudarte a manejar distintas versiones simultáneamente.
Uso del archivo go.sum: Este archivo comprueba la integridad del código descargado. Si ves discrepancias en los checksums, revisa el código para asegurarte de que no hay cambios sospechosos.

Mantente siempre curioso y dispuesto a experimentar. La gestión de dependencias es esencial para el desarrollo de software a gran escala, y dominarla te dará mayor flexibilidad y control sobre tus proyectos. ¡Sigue así!

Introducción

Programación Orientada a Objetos y Concurrencia en Go

Concurrencia y Testing en Go: Go Routinas y Worker Pools

Fundamentos de Programación en Go: Structs, Apuntadores y Manejo de Errores

Go Routines, Canales y Apuntadores en Golang

Programación orientada a objetos

Programación Orientada a Objetos en Go: Análisis y Comparativa

Equivalente de Clases en Go: Uso de Structs y Propiedades

Métodos en Structs: Implementación de Receiver Functions en Go

Implementación de Constructores en Go: Ejemplos y Mejores Prácticas

Herencia y Composición en Programación Orientada a Objetos

Interfaces y Polimorfismo en TypeScript y Go

Patrón Abstract Factory: Interfaces y Polimorfismo en Go

Implementación del Patrón Factory en Go para Notificaciones

Funciones Anónimas en Go: Uso y Consideraciones Prácticas

Funciones Variádicas y Retornos con Nombre en Go

Go Modules

Manejo de Dependencias y Módulos en Go

Creación y Publicación de Módulos en GitHub con Go

Testing

Tests unitarios y code coverage en Go

Cobertura de Código y Testing en Go: Mejorando la Calidad del Software

Profiling de Código en Go para Optimización de Rendimiento

Testing Unitario en Go: Uso de Mock Services

Testeo Unitario de Funciones con MOOC en Go

Concurrencia

Canales con y sin buffer en Go: diferencias y uso práctico

Sincronización de Rutinas en Go con Wait Group

"Uso de Canales con Buffer como Semáforos en Go"

Manejo de Canales de Lectura y Escritura en Go

Concurrencia en Go: Creación de Worker Pools y Fibonacci

Multiplexación de Canales en Go con Select y Case

Proyecto: servidor con worker pools

Creación de un Web Server con Worker Pool en Go

Creación de un Servidor Web Concurrente con Go

Conclusión

Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia

Manejo de Dependencias y Módulos en Go