¡Aprende haciendo! ¡Creemos una calculadora en Go! 🧮💻

¿Otra vez el simple proyecto de una calculadora?, ¡sí!, puedes sentir total orgullo. Vas a aprender haciendo, y qué mejor que una calculadora para entender:

• ¿Cómo inicializar un proyecto en Go?
• ¿Cómo importar paquetes?
• ¿Cómo declarar variables?
• ¿Cómo se manejan los errores? (Psss, ven te susurro algo: "¡En Go no existen try catch!)
• ¿Cómo se utilizan estructuras de control: if, switch?
• ¿Cómo parsear ciertos datos?

Si aún no tienes instalado Go en tu máquina, sigue estos pasos propuestos por la documentación: https://go.dev/dl/ (Si te bloqueas o tienes algún problema, contáctame que con gusto te apoyaré). 

Muy bien, hoy vamos a crear una calculadora asombrosa. Así que agarra tu teclado, prepara tu cerebro y ¡vamos a ello!

Paso 1: Preparando el terreno 🏗️

Primero, necesitamos crear un nuevo proyecto. Abre tu terminal (sí, esa cosa negra que da miedo y aprenderás a amar), escribe:

mkdir super-calculadora
cd super-calculadora
go mod init ejemplo.com/tuusuario/super-calculadora

¡Ojo! Ese último comando merece una explicación extra. 🧐

El go mod init crea un nuevo módulo Go, pero el argumento que le sigue (ejemplo.com/super-calculadora) es solo un identificador único para tu módulo. No necesitas tener un repositorio real en GitHub ni en ningún otro lado para empezar. Aquí tienes algunas opciones:

1. Si estás trabajando localmente y no planeas (por ahora) subir tu código a ningún repositorio, puedes usar cualquier nombre que quieras, como:

   go mod init super-calculadora

2. Si tienes planes de subir tu código a un repositorio en el futuro, puedes usar el formato de la URL donde planeas alojarlo. Por ejemplo:
• Para GitHub: go mod init github.com/tuusuario/super-calculadora
• Para GitLab: go mod init gitlab.com/tuusuario/super-calculadora
• Para Bitbucket: go mod init bitbucket.org/tuusuario/super-calculadora
3. Si estás trabajando en un proyecto para tu empresa o personal, puedes usar un dominio que te pertenezca:

   go mod init tuempresa.com/super-calculadora

Lo importante es que el nombre sea único y tenga sentido para ti. No te preocupes, ¡esto no conecta mágicamente tu código a internet ni nada por el estilo!

Ahora que hemos aclarado ese punto, ¿qué te parece si seguimos cocinando nuestra super calculadora? 🍳🧮

Paso 2: El esqueleto de nuestra calculadora 💀

Ahora, vamos a crear el archivo principal de nuestro programa. Crea un archivo llamado main.go y escribe esto:

package main

import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    // Aquí irá nuestra lógica principal
}

¡Ojo! Acabamos de usar nuestro primer concepto fundamental de Go: los paquetes. El package main le dice a Go: "Hey, este es el plato principal, no un simple aperitivo, por aquí es donde tienes que empezar el programa".

Paso 3: Funciones, ¡las superestrellas! 🌟

Ahora, vamos a crear funciones para cada operación. Pero antes, déjame explicarte cómo funciona una función en Go, porque son como los superhéroes de nuestro código: ¡tienen superpoderes y una estructura muy particular!

La estructura básica de una función en Go es así:

func nombreDeLaFuncion(parametro1 tipo, parametro2 tipo) tipoDeRetorno {
    // Cuerpo de la función
    return valorDeRetorno
}

Vamos a descomponerlo:

• func: Esta palabrita mágica le dice a Go "¡Ey, aquí viene una función!"
• nombreDeLaFuncion: Es como el nombre de superhéroe de nuestra función.
• (parametro1 tipo, parametro2 tipo): Son los superpoderes que nuestra función necesita para trabajar. Cada parámetro tiene un nombre y un tipo de dato.
• tipoDeRetorno: Es lo que nuestra función promete devolvernos después de hacer su trabajo.

Ahora, añade estas funciones después de la función main:

func sumar(a, b float64) float64 {
    return a + b
}

func restar(a, b float64) float64 {
    return a - b
}

func multiplicar(a, b float64) float64 {
    return a * b
}

func dividir(a, b float64) float64 {
    if b == 0 {
        fmt.Println("¡Ups! No puedo dividir por cero. ¿Quieres destruir el universo?")
        return 0
    }
    return a / b
}

Vamos a analizar la función sumar como ejemplo:

• func sumar: Declaramos una función llamada "sumar".
• (a, b float64): Esta función toma dos parámetros, a y b, ambos del tipo float64 (números con decimales).
• float64: Después de los parámetros, este float64 indica que la función devolverá un número con decimales.
• return a + b: La función devuelve la suma de a y b.

¿Ves cómo todas nuestras funciones siguen el mismo patrón? Toman dos float64, hacen algo con ellos, y devuelven otro float64. 

La función dividir tiene un truco extra: verifica si estamos intentando dividir por cero. Si es así, nos advierte del peligro y devuelve 0. 

Estas funciones son la columna vertebral de nuestra calculadora. Son simples, pero poderosas. Y lo mejor es que podemos usarlas una y otra vez sin tener que reescribir todo el código de la operación cada vez.

Ahora que tenemos nuestras funciones superestrella, ¿estás listo para ver cómo las ponemos a trabajar juntas? ¡Sigue al siguiente paso para descubrirlo!

Paso 4: La lógica principal, ¡el cerebro de la operación! 🧠

Ahora, vamos a llenar nuestra función main. Reemplázala con esto: 

func main() {
    if len(os.Args) != 4 {
        fmt.Println("Uso: go run main.go <número1> <operación> <número2>")
        fmt.Println("Operaciones disponibles: +, -, *, /")
        os.Exit(1)
    }

    num1, err := strconv.ParseFloat(os.Args[1], 64)
    if err != nil {
        fmt.Println("Error: El primer número no es válido")
        os.Exit(1)
    }

    operacion := os.Args[2]

    num2, err := strconv.ParseFloat(os.Args[3], 64)
    if err != nil {
        fmt.Println("Error: El segundo número no es válido")
        os.Exit(1)
    }

    var resultado float64

    switch operacion {
    case "+":
        resultado = sumar(num1, num2)
    case "-":
        resultado = restar(num1, num2)
    case "*":
        resultado = multiplicar(num1, num2)
    case "/":
        resultado = dividir(num1, num2)
    default:
        fmt.Println("Operación no válida.")
        os.Exit(1)
    }

    fmt.Printf("El resultado de %.2f %s %.2f es: %.2f\n", num1, operacion, num2, resultado)
}

¡Guau! Eso es mucho código nuevo. Vamos a descomponerlo y explicar cada parte:

1. Argumentos de línea de comandos (os.Args):

   if len(os.Args) != 4 {
       // ...
   }

   os.Args es un slice (una lista dinámica) que contiene los argumentos pasados a nuestro programa. os.Args[0] es siempre el nombre del programa, y los argumentos comienzan desde os.Args[1]. Aquí, verificamos si tenemos exactamente 3 argumentos (número1, operación, número2).
2. Conversión de tipos (strconv.ParseFloat):

   num1, err := strconv.ParseFloat(os.Args[1], 64)

   strconv.ParseFloat convierte una cadena (string) a un número de punto flotante (float64). El '64' indica que queremos un float de 64 bits. Entonces, como notas, cuando obtenemos un valor con strconv siempre será en string y por lo tanto deberá de ser parseado (o convertido al tipo de dato que necesitamos) (No te preocupes si te hace ruido el 64 del float. Hay float32 float64, lo vas a ir entendiendo mientras más avancemos)
3. Manejo de errores:

   if err != nil {
       fmt.Println("Error: El primer número no es válido")
       os.Exit(1)
   }

   En Go, muchas funciones devuelven un valor y un error. Si err no es nil, significa que ocurrió un error. En este caso, imprimimos un mensaje y salimos del programa con un código de error (1).
4. Declaración de variables:

   operacion := os.Args[2]
   var resultado float64

   Usamos := para declarar e inicializar variables en una línea. Para resultado, usamos var porque solo la declaramos sin inicializarla aún. Nota que el primero, el que tiene := además de asignar el valor, también infiere su tipo, es muy poderoso y es el que más vas a utilizar.
5. Estructura de control switch:

   switch operacion {
   case "+":
       resultado = sumar(num1, num2)
   // ...
   }

   switch es como un if mejorado. Compara operacion con varios casos y ejecuta el código correspondiente. 
6. Llamadas a funciones:

   resultado = sumar(num1, num2)

   Aquí llamamos a nuestras funciones definidas anteriormente, pasando num1 y num2 como argumentos.
7. Salida formateada (fmt.Printf):

   fmt.Printf("El resultado de %.2f %s %.2f es: %.2f\n", num1, operacion, num2, resultado)

   Printf nos permite imprimir texto formateado. %.2f significa "imprime un float con 2 decimales", y %s es para strings.

Has aprendido varios conceptos fundamentales de Go:

• Manejo de argumentos de línea de comandos con os.Args
• Conversión de strings a números con strconv.ParseFloat
• Manejo básico de errores (¡muy importante en Go!)
• Estructura de control switch
• Llamadas a funciones
• Salida formateada

Cada una de estas piezas juega un papel crucial en hacer que nuestra calculadora funcione. ¡Es como armar un rompecabezas donde cada pieza es un concepto de Go!

Paso 5: ¡A calcular se ha dicho! 🚀

Ahora, guarda tu archivo y prepárate para la magia. En tu terminal, puedes ejecutar:

go run main.go 5 + 3

Y verás:

El resultado de 5.00 + 3.00 es: 8.00

¡Eureka! Has creado una calculadora en Go. ¡Dale una palmadita en la espalda a tu computadora! Uff, pero más suave. Quiero que mantengas tu emoción controlada:

¿Sabías que muchos abandonan sus estudios porque constantemente están con altos niveles de dopamina, y entonces, cuando llegan a conceptos más difíciles, se rinden? Este no será tu caso, y por ello, respira profundo y continúa aprendiendo 🧙‍♂️

💻Source Code:

🍿https://github.com/Gognition/gognition-nivel1-calculadora.git

Conclusión: 

Y ahí lo tienes, has creado una calculadora en Go que haría llorar de emoción a Pitágoras. Has aprendido sobre paquetes, funciones, manejo de errores, estructuras de control y más.

Recuerda, la programación es como la cocina: al principio puedes quemar algunas cosas, pero con práctica, pronto estarás haciendo delicias dignas de un chef con estrellas Michelin. ¡Sigue practicando y pronto estarás haciendo más magia con Go!

¿Quieres más?

Aquí tienes algunas ideas para llevar tu calculadora al siguiente nivel:

1. Operaciones avanzadas: ¿Qué tal si añades funciones para calcular potencias, raíces cuadradas o incluso funciones trigonométricas?
2. Interfaz de usuario: Prueba a crear una interfaz de línea de comandos más amigable, o da el salto y crea una interfaz gráfica con una biblioteca como "fyne".
3. Persistencia: Añade una función para guardar el historial de cálculos en un archivo.
4. Modo científico: Implementa un modo científico que pueda manejar operaciones más complejas y constantes matemáticas.
5. Comparte tu creación: Sube tu código a GitHub y compártelo con la comunidad. ¡Quién sabe, tal vez otros programadores quieran contribuir a tu proyecto!

¡Comparte tu progreso y obtén feedback!

¿Has mejorado la calculadora? ¿Has creado algo completamente nuevo? ¡Nos encantaría verlo y ayudarte a mejorarlo aún más! Aquí tienes cómo puedes compartir tu trabajo y recibir valiosos comentarios:

1. Sube tu código a GitHub: Si aún no lo has hecho, crea un repositorio en GitHub y sube tu proyecto. Asegúrate de incluir un README.md que explique qué hace tu programa y cómo utilizarlo.
2. Comparte tu repositorio: Deja un comentario abajo con el enlace a tu repositorio de GitHub.
3. Revisión de código: Nuestro equipo y la comunidad estaremos encantados de revisar tu código. Haremos un "code review" y te daremos feedback constructivo para ayudarte a mejorar tu programa y tus habilidades en Go.
4. Aprende y mejora: Usa los comentarios que recibas para mejorar tu código. Recuerda, incluso los programadores más experimentados siempre están aprendiendo.
5. Comparte en redes: ¿Orgulloso de tu creación? ¡Compártela en redes sociales y etiquétanos! Nos encantará ver y compartir tu progreso.

Recuerda, cada línea de código que escribes y cada revisión que recibes te acerca un paso más a ser un maestro de Go y dedicarte completamente como Go Developer. Así que, ¿a qué esperas? ¡Comparte tu código y únete a la conversación!

Y si te ha gustado este tutorial, no olvides compartirlo con tus amigos programadores. ¡Juntos podemos crear una comunidad de Gophers imparable!

¡Feliz coding y espero ver tus creaciones pronto! 🐹💻🚀