Go Modules creando nuestro primer módulo en Go

Clase 40 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Contenido del curso

Introducción a Go

Nuestra Primera Aplicación Go

Lista de Tareas

Interfaces

Goroutines y Channels

Construyendo un Servidor Web

Tomar examen

Comentarios

Nicoll Idaly Angulo Mejia

student•

si ponen

aparece todo el menu de ayuda de mod

go help mod

Si quieren que go verifique en que lineas y archivos se llama a librerias externas y evitar corrupción en los archivos

go mod tidy

este generará un archivo llamado go.sum y tendra el resgistro codificado de las librerias usadas, en que archivos y lineas se ha usado

Juan José González Ramírez

student•

me gustó mucho la recomendación que pusiste en uno de los vídeos sobre el libro de Go, estoy pensando seriamente en adquirirlo en físico o kindle

Nixon Fernando Ortiz Suarez

student•

go mod init repository-url Genera un archivo que define el modulo

LEONARD CUENCA

student•

No entendí le pedí ayuda al Chat GTP y pude entender esta clase:

1.- Crea un directorio: Lo primero que debes hacer es crear un directorio para el módulo que vas a crear. Este directorio debe tener un nombre que identifique el módulo. Por ejemplo, si estás creando un módulo para manejar fechas, podrías llamar al directorio "fecha".

2.- Crea un archivo go.mod: Dentro del directorio que creaste en el paso anterior, debes crear un archivo llamado go.mod. Este archivo es el que va a contener la información sobre el módulo que estás creando, como el nombre, la versión, las dependencias, entre otros.

3.- Define el nombre y la versión del módulo: En el archivo go.mod, debes especificar el nombre y la versión del módulo que estás creando. Para hacer esto, escribe el siguiente comando en el archivo:

module nombre-del-modulo/v1.0.0

Reemplaza "nombre-del-modulo" con el nombre que elegiste para el módulo y "v1.0.0" con la versión inicial del módulo.

4.- Agrega las dependencias: Si tu módulo depende de otros paquetes o módulos, debes agregarlos al archivo go.mod. Para hacer esto, escribe el siguiente comando en el archivo:

require (nombre-del-paquete/v1.0.0)

Reemplaza "nombre-del-paquete" con el nombre del paquete que estás agregando y "v1.0.0" con la versión del paquete.

5.- Crea los archivos del módulo: Ahora debes crear los archivos que van a conformar el módulo que estás creando. Por ejemplo, si estás creando un módulo para manejar fechas, podrías crear un archivo llamado "fecha.go" que contenga el código para manejar fechas.

6.- Exporta las funciones y estructuras del módulo: Para que otras personas puedan utilizar tu módulo, debes exportar las funciones y estructuras que has creado. Para hacer esto, debes nombrar las funciones y estructuras con una letra mayúscula en la primera letra del nombre. Por ejemplo, si tienes una función llamada "calcularEdad", deberías nombrarla como "CalcularEdad".

7.- Publica el módulo: Una vez que has creado el módulo y has exportado las funciones y estructuras, debes publicarlo en un repositorio para que otras personas puedan utilizarlo. Puedes publicarlo en un repositorio de Git, como GitHub o GitLab, o en un repositorio de Go, como el Registro de Paquetes de Go.

¡Listo! Con estos pasos, has creado tu propio módulo en Go. Recuerda que para utilizarlo en otros proyectos, debes importarlo en el archivo go.mod de ese proyecto.

Juan Pablo Rodríguez Morales

student•

Sería bueno ahondar un poco más en qué propósito cumplen los módulos.

Cristian Blandon

student•

¿Modularizar el código?

Avelino Sánchez

student•

Al crear un paquete a través de módulos, no es necesario tener un main porque este paquete será utilizado por otro programa con su propio punto de inicio. Al no tener main, el paquete requerirá de nombre específico y no main.

Masami Nakada Bedriñana

student•

No se olviden :

git config --global init.defaultBranch main

Para que por default inicialicen con la rama main

Carlos Nassif Trejo Garcia

student•

package mycalculator

import (
	"bufio"
	"fmt"
	"os"
	"regexp"
	"strconv"
)

type calc struct {
	e1 int
	e2 int
}

func (self calc) operate(operador string) int {
	operador1 := self.e1
	operador2 := self.e2

	var resultado int

	switch operador {
	case "+":
		resultado = operador1 + operador2
	case "-":
		resultado = operador1 - operador2
	case "*":
		resultado = operador1 * operador2
	case "/":
		if operador2 == 0{
			fmt.Println("Error: Division entre cero")
			return 0
		}
		resultado = operador1 / operador2
	default:
		fmt.Println("Operador no aceptado")
		resultado = 0
	}

	return resultado
}

func parsear(entrada string) int {
	operador, _ := strconv.Atoi(entrada)
	return operador
}

func leerEntrada() string {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	return scanner.Text()
}

func getOperands(entrada string) ( calc, string ){
	regex := regexp.MustCompile(`^(\d+)([\+\-\*\/])(\d+)$`)

	//entrada := leerEntrada()

	if regex.Match([]byte(entrada)) {
		entrada1 := parsear(regex.ReplaceAllString(entrada, "$1"))
		operador := regex.ReplaceAllString(entrada, "$2")
		entrada2 := parsear(regex.ReplaceAllString(entrada, "$3"))

		c := calc{e1: entrada1, e2: entrada2}
		//toPrint := c.operate(operador)
		return c, operador
		//fmt.Println(toPrint)
	} else {
		return calc{}, ""
	}

}

BALFRE VAZQUEZ CASTREJON

student•

Here is my proyect

PlatziGoCalculator

Cristian Blandon

student•

Recomendación: Curso Profesional de Git y GitHub

package mycalculator

import (
	"bufio"
	"fmt"
	"os"
	"regexp"
	"strconv"
)

type calc struct {
	e1 int
	e2 int
}

func (self calc) operate(operador string) int {
	operador1 := self.e1
	operador2 := self.e2

	var resultado int

	switch operador {
	case "+":
		resultado = operador1 + operador2
	case "-":
		resultado = operador1 - operador2
	case "*":
		resultado = operador1 * operador2
	case "/":
		if operador2 == 0{
			fmt.Println("Error: Division entre cero")
			return 0
		}
		resultado = operador1 / operador2
	default:
		fmt.Println("Operador no aceptado")
		resultado = 0
	}

	return resultado
}

func parsear(entrada string) int {
	operador, _ := strconv.Atoi(entrada)
	return operador
}

func leerEntrada() string {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	return scanner.Text()
}

func getOperands(entrada string) ( calc, string ){
	regex := regexp.MustCompile(`^(\d+)([\+\-\*\/])(\d+)$`)

	//entrada := leerEntrada()

	if regex.Match([]byte(entrada)) {
		entrada1 := parsear(regex.ReplaceAllString(entrada, "$1"))
		operador := regex.ReplaceAllString(entrada, "$2")
		entrada2 := parsear(regex.ReplaceAllString(entrada, "$3"))

		c := calc{e1: entrada1, e2: entrada2}
		//toPrint := c.operate(operador)
		return c, operador
		//fmt.Println(toPrint)
	} else {
		return calc{}, ""
	}

}

Go Modules creando nuestro primer módulo en Go

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos