Dominar el paquete fmt en Go es fundamental para cualquier persona que quiera trabajar con este lenguaje. Más allá de imprimir texto en consola, este paquete ofrece herramientas poderosas para formatear cadenas, insertar variables dinámicamente y conocer el tipo de dato de cualquier variable. A continuación se explican las tres funciones principales y un tip extra que resulta muy práctico en el día a día.
¿Cómo funciona println para imprimir en consola?
La función fmt.Println es la forma más directa de mostrar información en la terminal. Su nombre viene de print (imprimir) más ln (line), lo que significa que agrega automáticamente un salto de línea al final de cada impresión [00:42].
Para usarla, basta con declarar variables y pasarlas como argumento:
go
helloMessage := "hello"
worldMessage := "world"
fmt.Println(helloMessage)
fmt.Println(worldMessage)
Cada llamada a Println imprime el valor en una línea separada. Esto es útil cuando necesitas ver datos de forma rápida sin preocuparte por el formato.
¿Qué hace printf y cómo se formatean variables?
La función fmt.Printf es probablemente la que más se utiliza en proyectos reales. A diferencia de Println, permite insertar variables dentro de un string mediante verbos de formato [01:22].
¿Qué son los verbos de formato como %s, %d y %v?
Los verbos de formato son marcadores que indican qué tipo de dato se espera en esa posición:
- %s: indica que el valor será un string.
- %d: indica que el valor será un entero (int).
- %v: se usa cuando no se tiene certeza del tipo de dato que llegará.
Un ejemplo práctico [01:40]:
go
nombre := "Platzi"
cursos := 500
fmt.Printf("%s tiene más de %d cursos\n", nombre, cursos)
El \n al final es el salto de línea manual, ya que Printf no lo agrega automáticamente como sí lo hace Println.
¿Cuándo usar %v en lugar de %s o %d?
Si en algún momento no sabes qué tipo de dato recibirá la variable, puedes reemplazar el verbo específico por %v [02:28]:
go
fmt.Printf("%v tiene más de %v cursos\n", nombre, cursos)
El resultado es idéntico. Sin embargo, la buena práctica es usar el verbo específico siempre que conozcas el tipo de dato, y reservar %v solo para casos de incertidumbre.
¿Para qué sirve sprintf y en qué se diferencia de printf?
La función fmt.Sprintf trabaja de forma similar a Printf, pero con una diferencia clave: no imprime nada en consola. En su lugar, genera un string formateado y lo guarda en una variable [03:05].
go
message := fmt.Sprintf("%s tiene más de %d cursos", nombre, cursos)
fmt.Println(message)
Esto es especialmente útil cuando necesitas construir mensajes dinámicos para usarlos en otras partes del programa, como enviarlos a un archivo, una API o simplemente reutilizarlos sin repetir código.
Un detalle importante: si usas Sprintf con \n al final y luego lo imprimes con Println, obtendrás un salto de línea extra, porque Println agrega el suyo propio. La solución es quitar el \n del string formateado [03:35].
¿Cómo conocer el tipo de dato de una variable con fmt?
Un tip adicional muy valioso es el uso del verbo %T (con T mayúscula) dentro de Printf. Este verbo imprime el tipo de dato al que pertenece una variable [04:05]:
go
fmt.Printf("helloMessage es de tipo: %T\n", helloMessage)
fmt.Printf("cursos es de tipo: %T\n", cursos)
Al ejecutar, el resultado muestra:
helloMessage es de tipo string.cursos es de tipo int.
Esto resulta extremadamente práctico para depurar código y verificar que las variables contienen el tipo de dato esperado, sobre todo cuando se trabaja con funciones que retornan interfaces o valores genéricos.
El paquete fmt ofrece muchas más opciones de formateo y parseo de datos. Si quieres profundizar en todos los verbos disponibles, la documentación oficial de Go es el mejor recurso. ¿Ya habías usado %T para inspeccionar tipos de dato? Comparte tu experiencia en los comentarios.
