You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

2 Días
8 Hrs
25 Min
56 Seg

Modificando módulos con Go

32/36
Resources

How to use GoModos to manage dependencies efficiently?

Dependency management is a crucial issue in software development, especially when working with large projects in languages such as Go. Using Go modules (GoModes) correctly can be the cornerstone of keeping a project organized and free of potential bugs. In this guide, we will explore how to properly modify dependencies using GoModes, ensuring that your code is always in top condition.

How to clone and modify libraries safely?

To start working with a specific library, the first thing to do is to perform a Git clone to your project:

git clone <url-from-library> .
  • Access the necessary file: Navigate to the file where you want to make changes and edit the information according to your needs.
  • Redirect file usage: Using the CLI, adjust so that your project uses the modified file instead of the original. You can do this by configuring the interaction with GoModes.

How to use Go Modes to edit and replace libraries?

To make temporary modifications to the code of a library, follow these steps:

  1. Open the file go.mod: Edit this file to replace the desired reference.
  2. Replace command: Use go mod edit to perform a specific replacement in your project.
go mod edit -replace=module/original=path/new .
  1. Verify modifications: After modifying, confirm that the new library is being used correctly.

How to remove GoModos replacements?

A common practice is to revert replacements once the changes have been accepted by the original library:

  • Remove replacements: Use the go mod edit -dropreplace command.
go mod edit -dropreplace=module/original
  • Verify code integrity: Run it to ensure that the library is back to its original state and that the code still works properly.

How to package code with the vendor command?

One of the most powerful features of GoModos is the ability to package external code along with your project:

  • Run go mod vendor: This command creates a folder called vendor that contains all the code needed to run your project, including third-party code.
go mod vendor

This ensures that the correct versions are being used, without relying on external sources during code execution or distribution.

How to keep your project clean by removing unnecessary dependencies?

It is essential to remove dependencies that are no longer in use to maintain a healthy and efficient project:

  • Check current dependencies: Check the go.mod and go.sum files for libraries that are no longer needed.
  • Clean up dependencies: Run the go mod tidy command.
go mod tidy

This process will update the dependency files and ensure that no superfluous libraries are included in your project.

How to continue learning about Go and its best practices?

Implementing GoModos not only improves the structure of your project, but also immerses you in the best practices of the Go community. Creating programs and libraries in Go also gives you invaluable hands-on experience. I encourage you to:

  • Develop your first Go program or library, integrating GoModes.
  • Share your project in repositories like GitHub.
  • Explore more about the peculiarities of Go and its active community.

The learning path is continuous. Dependency management is just one step towards mastering Go development. Keep exploring and experimenting!

Contributions 14

Questions 6

Sort by:

Want to see more contributions, questions and answers from the community?

Este profe es bastante bueno, y explica claramente, sin embargo, si le recomiendo mejorar la pronunciación de las palabras en inglés. Porque es fatal

hasta ahora sinceramente me ha encantado el tutoría, pero ciertamente si diría que se revise estas ultimas dos clases, la 32 y la 31. ya que en términos generales se hace algo engorroso ( se que la programación en eso ) pero creo que en parte es redundante y poco explicativo. ojo solo las clases 31 y 32 el resto me parece correcto.

Si quiren saber más sobre como mnejar los modulos en go. Les dejo este link de la documentación oficial.
https://blog.golang.org/using-go-modules

Dejó también un pequeño resumen de los comandos que se explican.

go mod init
  • Crea un nuevo módulo, inicializando el archivo go.mod que lo describe.
go build, go test, and other package-building commands
  • Agrega nuevas dependencias a go.mod según sea necesario.
go list -m all
  • Imprime las dependencias del módulo actual.
go get
  • Cambia la versión requerida de una dependencia (o agrega una nueva dependencia).
go mod tidy

Elimina las dependencias no utilizadas.

Hago una recomendación, actualicen el curso ya que se supone que si se compra un plan y dicen que los cursos son innovadores y es lo último se espera que los cursos estén al día. No solo pasa con este curso, con otros como los de ruby.

go mod edit -replace=exampl e. com/greetings=…/greetings

Go mod verify

Go mod edit -dropreplace …
Go mod vendor
Go sum: Repertorio de todas las librerias (verificar)
Go mod tidy: Limpiar librerias no usadas

Por fin entendi claramente los modulos en Go.

¡Increíble curso! Ojalá prontamente un curso de creación web con Go, sea utilizando Echo o Gin.

Me perdí, se supone que el curso es básico y luego salta a esto .

De manera positiva y como mejora es separar la ultima sección que sea Go mod y todo sus variantes en otro curso

En caso de que les haya aparecido este error

deben instalar este paquete

go mod download github.com/dgrijalva/jwt-go

Mis apuntes:

Movimos la carpeta “echo” en el mismo directorio donde se encuentra “go.mod”:

mv src/echo .

Y corremos el archivo: main.go

Verificamos los archivos con:

go mod verify

Y debería salir:
all modules verified

Significa que todos los modulos estan verificados, todo esta bien

Todo lo anterior es un claro ejemplo de como debes modificar una librería
que vayas a utilizar. Tienes que usar: go mod replace

/////////////////////////////////////////////

Como deshacemos el remplazo…

Escribes lo siguiente, agregando el link que quieres recuperar como el original:

go mod edit -dropreplace github.com/labstack/echo

Y queda normal el archivo de go.mod

Y si vuelves a correr el archivo main.go, la librería queda en su estado
original.

/////////////////////////////////////////

Go mod implemento una forma de guardar todas las librerías, tanto internas
como externas en un solo lugar…

Con el siguiente comando creas una carpeta…

 go mod vendor

Esta carpeta se llamará “vendor”, Vendor es todo el conjunto de código
adicional, aparte del cófigo que viene en el lenguaje, que va a agregar para
que el código que tengas en el main ejecutandose funcione de la forma normal.

/////////////////////////////////////////

Una buena práctica es limpiar los paquetes que ya no se utilicen.

Go.sum

Es un archivo que genera un conjunto de librerías que utilizas (repertorio),
tanto de versión como en el punto que se utiliza la librería en el código con
código encriptado.
Esto es una verificación de que el código este en la mejor salud posible.

¿Cómo hacemos para limpiar las librerías?

Escribes el siguiente comando:

go mod tidy
Esta ha sido de las clases más útiles del curso básico de Go! Excelente

😕

🙄

`go mod tidy` Me pareció de gran ayuda; en proyectos grandes, si no tienes un manejo adecuado de las bibliotecas o paquetes, puedes estar importando "basura".