Go Modules creando nuestro primer módulo en Go

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

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

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.

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

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.

No se olviden :

git config --global init.defaultBranch main

Para que por default inicialicen con la rama main

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{}, ""
	}

}

Here is my proyect

PlatziGoCalculator

Recomendación: Curso Profesional de Git y GitHub