¡Aprende haciendo! ¡Calcula tu índice de masa corporal y descubre todo lo que puedes aprender! 💪💻

Hoy vamos a crear un Calculador de Índice de Masa Corporal (IMC) tan increíble que hasta tu entrenador personal querrá aprender a programar. Así que agarra tu proteína en polvo, tu teclado, y ¡vamos a por ello!

Lo que aprenderás en este tutorial 🧠💡

Antes de sumergirnos en el código, echemos un vistazo a los conceptos que vas a dominar hoy:

1. Structs: Aprenderás a crear tus propios tipos de datos complejos. ¡Como armar tu propio Lego!
2. Métodos: Descubrirás cómo darle superpoderes a tus structs con funciones especiales.
3. Manejo de entrada/salida: Dominarás el arte de comunicarte con el usuario a través de la consola.
4. Tipos de datos básicos: Jugaremos con strings y numéricos como un malabarista profesional.
5. Control de flujo: Usaremos if y switch para tomar decisiones más rápido que un árbitro de la NBA.
6. Formateo de strings: Aprenderás a presentar tus resultados con más estilo que un diseñador de moda.
7. Paquetes: Verás cómo usar paquetes externos para potenciar tu código.

Listo, puntualicemos nuestro roadmap:

Nuestro Calculador de IMC hará lo siguiente:

1. Pedirá al usuario su nombre, peso y altura.
2. Calculará su IMC.
3. Determinará en qué categoría de peso está.
4. Mostrará un mensaje personalizado con los resultados.

Paso 1: Preparando el terreno 🏗️

Primero, vamos a crear un nuevo proyecto. Abre tu terminal y escribe:

mkdir calculador-imc
cd calculador-imc
go mod init ejemplo.com/tuuser/calculador-imc

Si tienes dudas sobre la url que se coloca en go mod init puedes visitar nuestro primer post en el que lo explico detalladamente 👉 creemos una calculadora

Paso 2: Creando la estructura de nuestro programa 🏋️‍♂️

Ahora, vamos a crear nuestro archivo principal. Crea un archivo llamado main.go y comencemos con lo básico:

package main

import (
    "fmt"
    "math"
)

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

Paso 3: Definiendo nuestra estructura Person 🧍

En Go, podemos crear nuestros propios tipos de datos usando struct. Vamos a crear una estructura Person que contendrá la información que necesitamos:

type Person struct {
    Name   string
    Weight float64
    Height float64
}

¡Ojo! Acabamos de usar nuestro primer concepto nuevo: las estructuras (structs). Una struct en Go es como una ficha de jugador en un juego de rol: agrupa diferentes características (campos) que pertenecen a una misma entidad. 

Si conoces otros lenguajes de programación quizá recuerdes el concepto de Objetos y Clases. En Go no existen propiamiente estos conceptos. Todo es manejado por structs y receivers. 

Paso 4: Métodos para calcular el IMC y obtener la categoría 🧮

Ahora, vamos a añadir algunos métodos a nuestra estructura Person. Los métodos son funciones asociadas a un tipo específico (también son llamados receivers). Es como si le diéramos superpoderes a nuestra struct:

func (p *Person) CalculateIMC() float64 {
    return p.Weight / math.Pow(p.Height, 2)
}

func (p *Person) GetIMCCategory() string {
    imc := p.CalculateIMC()
    switch {
    case imc < 18.5:
        return "Bajo peso"
    case imc < 25:
        return "Peso normal"
    case imc < 30:
        return "Sobrepeso"
    default:
        return "Obesidad"
    }
}

Paso 5: La función main, el corazón de nuestro programa 💓

Ahora, vamos a implementar nuestra función main. Aquí es donde pediremos los datos al usuario, crearemos una Person, calcularemos su IMC y mostraremos los resultados:

func main() {
    var name string
    var weight, height float64

    fmt.Println("¡Bienvenido al Calculador de IMC en Go!")
    
    fmt.Print("Introduce tu nombre: ")
    fmt.Scanln(&name)     

    fmt.Print("Introduce tu peso en kg: ")
    fmt.Scanln(&weight)

    fmt.Print("Introduce tu altura en metros: ")
    fmt.Scanln(&height)

    person := Person{Name: name, Weight: weight, Height: height}

    imc := person.CalculateIMC()
    category := person.GetIMCCategory()

    fmt.Printf("\n¡Hola %s! Aquí están tus resultados:\n", person.Name)
    fmt.Printf("Tu IMC es: %.2f\n", imc)
    fmt.Printf("Categoría: %s\n", category)

    switch category {
    case "Bajo peso":
        fmt.Println("¡Come un poco más! Estás más flaco que un lápiz.")
    case "Peso normal":
        fmt.Println("¡Perfecto! Mantienes un equilibrio digno de un maestro Jedi.")
    case "Sobrepeso":
        fmt.Println("Un poco de ejercicio no te vendría mal. ¡A mover ese cuerpo!")
    case "Obesidad":
        fmt.Println("Es hora de ponerse en marcha. ¡Tú puedes hacerlo!")
    }
}

¡Guao! Eso es mucho código nuevo. Vamos a descomponerlo:

1. Usamos fmt.Scanln() para leer la entrada del usuario. Pero, ¿qué es ese & antes de las variables?

   fmt.Scanln(&name)
   fmt.Scanln(&weight)
   fmt.Scanln(&height)

   El & es el operador de dirección (puntero) en Go. Cuando lo usamos antes de una variable, obtenemos la dirección de memoria de esa variable. Es como darle a Scanln el mapa para llegar a la casa de nuestra variable. ¿Por qué hacemos esto? Bueno, Scanln necesita saber exactamente dónde guardar los datos que el usuario introduce. Al darle la dirección con &, le estamos diciendo: "Hey, guarda lo que el usuario escriba justo aquí". Es como si en lugar de darte un paquete, el cartero te dijera exactamente dónde va a dejar el paquete en tu casa. Así, Scanln sabe exactamente dónde "dejar el paquete" (los datos del usuario) en la memoria de tu programa.
2. Creamos una instancia de Person con los datos introducidos.
3. Llamamos a los métodos que creamos anteriormente.
4. Usamos fmt.Printf() para imprimir resultados formateados.
5. Añadimos un toque de humor con mensajes personalizados según la categoría.

Paso 6: ¡A calcular se ha dicho! 🚀

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

go run main.go

¡Y voilà! Tienes un calculador de IMC funcionando. Introduce tus datos y observa cómo Go hace sus cálculos más rápido que Flash corriendo por pizza. 

¡Importante! ¡En los siguientes proyectos aprenderás a generar builds! Son literalmente ejecutables, que podras activar sin importar el sistema operativo. 🧙‍♂️

💻Source Code:

🍿https://github.com/Gognition/gognition-nivel2-calculador-imc.git

Conclusión:

Y ahí lo tienes, has creado un Calculador de IMC en Go que haría llorar de emoción a cualquier nutricionista-programador. Has aprendido sobre structs, métodos, switch, fmt para I/O, y más.

Recuerda, la programación es como el ejercicio: al principio puede ser duro, pero con práctica constante, pronto estarás levantando códigos complejos como si fueran pesas de pluma. ¡Sigue practicando y pronto estarás haciendo malabares con goroutines y channels!

¿Quieres más? 💪

Aquí tienes algunas ideas para llevar tu Calculador de IMC al siguiente nivel:

1. Persistencia de datos: Guarda los resultados en un archivo para hacer seguimiento.
2. Múltiples usuarios: Permite calcular y comparar el IMC de varias personas.
3. Estadísticas: Añade funcionalidad para calcular promedios y tendencias.
4. Interfaz gráfica: Dale un toque visual con una biblioteca como fyne.
5. API web: Convierte tu programa en un servicio web con el paquete net/http.

Sí, todo eso puede parecer muy avanzado, y, realmente, sí lo es. Pero no creas que te pediré cosas que no puedas lograr con la práctica.

¡Comparte tu progreso y obtén feedback!

¿Has mejorado el Calculador de IMC? ¿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! 🐹💻🚀