Paquete fmt: algo más que imprimir en consola

Para los que aprendimos a programar usando C, printf es un viejo coocido 😄

fmt

El paquete fmt es el que se encarga de administrar los inputs y outputs de la terminal.

• Println: Es un print normal con un salto de linea al final. Ejemplo:

fmt.Println("Hola Mundo")

• Printf: Es un print al cual le puedes especificar el tipo de objeto que le vas a dar. Ejemplo:

fmt.Printf("%s tiene más de %d cursos\n", nombre, cursos)

• Sprintf: No imprime nada en consola, simplemente lo guarda como un String. Ejemplo de uso:

var message string = fmt.Sprintf("%v tiene más de %v cursos\n", nombre, cursos)
fmt.Println(message)

Con este paquete podemos imprimir en consola el tipo de dato de variables o constantes. Ejemplo de uso:

package main

import "fmt"

func main() {

	const nombre string = "UltiRequiem"

	fmt.Printf("La variable 'nombre' es de tipo : %T\n", nombre)
}

Mas información en mi repositorio del curso.

Aquí esta el codigó de la clase:

package main

import "fmt"

func main() {
	helloMessage := "Hello"
	worldMessage := "world"

	// Println: Salto de Linea Automatico
	fmt.Println(helloMessage, worldMessage)
	fmt.Println(helloMessage, worldMessage)

	// Printf
	nombre := "Platzi"
	cursos := 500
	// Con valores seguros
	fmt.Printf("%s tiene más de %d cursos\n", nombre, cursos)
	// Con valores inseguros
	fmt.Printf("%v tiene más de %v cursos\n", nombre, cursos)

	// Sprintf
	message := fmt.Sprintf("%v tiene más de %v cursos\n", nombre, cursos)
	fmt.Println(message)

	// Tipo de datos:
	fmt.Printf("helloMessage: %T\n", helloMessage)
	fmt.Printf("cursos: %T\n", cursos)
}

Aporte de esta clase:

package main

import (
	"fmt"
)

func main() {
	// Declaración de variables
	helloMessage := "!Hola"
	worldMessage := "Mundo!"

	// Println: Hace un salto de linea al terminar el mensaje
	fmt.Println(helloMessage, worldMessage)
	fmt.Println(helloMessage, worldMessage)
	fmt.Println("")

	// Printf: Imprime con un formato
	nombre := "Platzi"
	cursos := 700
	// Cuando sabemos que tipo de variables son podemos usar
	/*
		 bool:                    %t
		 int, int8 etc.:          %d
		 uint, uint8 etc.:        %d, %#x if printed with %#v
		 float32, complex64, etc: %g
		 string:                  %s
		 chan:                    %p
		 pointer:                 %p
	        */
	fmt.Printf("%s tiene más de %d cursos\n", nombre, cursos)

	// Si desconocemos el tipo de variable en el formato
	fmt.Printf("%v tiene más de %v cursos\n", nombre, cursos)

	// Sprintf: Genera un string pero no lo imprime en consola
	var message string = fmt.Sprintf("%s es un string", nombre)
	fmt.Println(message)
	fmt.Println("")

	// Imprimir el tipo de variable
	fmt.Printf("HelloMessage es tipo: %T\n", helloMessage)
	fmt.Printf("Cursos es tipo: %T\n", cursos)
	fmt.Println("")

	// Si queremos ignorar el % del formato podemos usar doble %%
	fmt.Printf("%s es de tipo %T y para usarlo en el Printf se hace uso del %%s\n", nombre, nombre)
}

!Hola Mundo!
!Hola Mundo!

Platzi tiene más de 700 cursos
Platzi tiene más de 700 cursos
Platzi es un string

HelloMessage es tipo: string
Cursos es tipo: int

Platzi es de tipo string y para usarlo en el Printf se hace uso del %s

Hola. Aquí un código que al ejecutarse imprime en consola todo lo de la clase:

package main

import (
	"fmt"
	"math"
)

func main() {

	fmt.Println()
	fmt.Println("Tipos de datos primitivos")
	fmt.Println("*************************")
	fmt.Println()

	fmt.Println("Especificar el tipo hace que el rendimiento sea mayor a dejarlo declarado implícitamente")
	fmt.Println("La declaración de los tipos es en minúsculas (No existe String por ejemplo al estilo del lenguaje Java")
	fmt.Println()

	fmt.Println("Textos")
	fmt.Println("------")
	fmt.Println()

	fmt.Println("string = \"mi textico\" >>> el texto se coloca entre comillas dobles")
	fmt.Println()

	fmt.Println("Booleano - lógicos")
	fmt.Println("------------------")
	fmt.Println()

	fmt.Println("bool = true o false >>> Solo esas dos opciones")
	fmt.Println()

	fmt.Println("Números enteros")
	fmt.Println("---------------")
	fmt.Println()

	fmt.Println("int8 >>> -2^7 a 2^7-1 >>>", math.MinInt8, "a", math.MaxInt8)
	fmt.Println("int16 >>> -2^15 a 2^15-1 >>>", math.MinInt16, "a", math.MaxInt16)
	fmt.Println("int32 >>> -2^31 a 2^31-1 >>>", math.MinInt32, "a", math.MaxInt32)
	fmt.Println("int64 >>> -2^63 a 2^63-1 >>>", math.MinInt64, "a", math.MaxInt64)
	fmt.Println()

	fmt.Println("Números enteros positivos")
	fmt.Println("-------------------------")
	fmt.Println()

	fmt.Println("uint8 >>> 0 a 2^8-1 >>>", math.MaxUint8)
	fmt.Println("uint16 >>> 0 a 2^16-1 >>", math.MaxUint16)
	fmt.Println("uint32 >>> 0 a 2^32-1 >>>", math.MaxUint32)
	fmt.Println("uint64 >>> 0 a 2^64-1 >>>", uint64(math.MaxUint64))
	fmt.Println()

	fmt.Println("Números enteros positivos")
	fmt.Println("-------------------------")
	fmt.Println()

	fmt.Println("float32 >>> +/- 1.18e^-38 a +/- 3.4e^38 >>>", math.SmallestNonzeroFloat32, "a", math.MaxFloat32)
	fmt.Println("float64 >>> +/- 2.23e^-308 a +/- 1.8e^308 >>>", math.SmallestNonzeroFloat64, "a", math.MaxFloat64)
	fmt.Println()

	fmt.Println("Números complejos")
	fmt.Println("-------------------------")
	fmt.Println()

	fmt.Println("Complex64 = Real e imaginario, ambos en float32")
	fmt.Println("Complex128 = Real e imaginario, ambos en float64")
	fmt.Println()
	fmt.Println("Se declara: c := 10 + 8i")

	variable := 10 + 8i
	fmt.Println("Su valor es:", variable)

	fmt.Println()
}

Para saber el tipo del dato con la librería fmt:

fmt.Printf("%T\n", variable)

✨ Usamos %T para determinar el tipo de dato de una variable a utilizar.

Para más adelante:
Si se requiere saber tanto llaves como valores de una estructura, Printf ofrece el “+v” como verbo para imprimir llaves y valores

Muy bien

	//Clase paquete fmt
	helloMessage := "Hello"
	worldMessage := "world!"

	//Println
	fmt.Println(helloMessage,worldMessage)
	platzi := "Platzi"
	cursos := 500

	//Printf
	fmt.Printf("%s tiene mas de %d cursos\n",platzi, cursos)
	fmt.Printf("%v tiene mas de %v cursos\n",platzi, cursos)

	//Sprintf
	message := fmt.Sprintf("%s tiene mas de %d cursos\n",platzi, cursos)
	fmt.Print(message)

	//Tipo de Datos
	fmt.Printf("helloMessage %T\n",helloMessage)
	fmt.Printf("cursos %T\n",cursos)

Esto me pareció muy intersante

var sinTipo interface{} =21
	fmt.Printf("Tipo de dato es %T\n", sinTipo)

	sinTipo = "Hola"
	fmt.Printf("Tipo de dato es %T\n", sinTipo)

Podemos utilizar Sprintf, para guardar la concatenación de algunas variables y también podemos ver el tipo de dato con %T.

Algo muy interesante, es que podemos imprimir algunas cositas con una función built-in, que podemos utilizar sin importar nada: println() o print, el ln es para el salto de línea.

Podemos usar %s para los strings o %d para enteros y en caso de que no sepamos que vayamos a meter, entonces %v

Tenemos que poner en orden las variables, si primero pusimos dentro de la cadena %s, para un string, entonces debemos poner al lado del string de primera nuestra variable con un número.

Dentro del paquete fmt, podemos utilizar varios de sus métodos, para imprimir en consola. uno de ellos es Printf, en el cuál solo debemos de señalar con un porcentaje una letra reservada para el tipo de dato que queremos concatenar y luego de la cadena, ponemos una coma, con las variables que queremos allí.

// Declaración de variables
	helloMessage := "Hello"
	worldMessage := "world"

	// Println -> Es un print normal con un salto de linea al final
	fmt.Println(helloMessage, worldMessage)
	fmt.Println(helloMessage, worldMessage)

	// Printf -> Es un print al cual le puedes especificar el tipo de objeto que le vas a dar
	nombre := "Platzi"
	cursos := 500

	fmt.Printf("%s tiene mas de %d cursos\n", nombre, cursos)
	fmt.Printf("%v tiene mas de %v cursos\n", nombre, cursos) // La v es para cuando no hay certeza de que dato va allí

	// Sprintf -> No imprime nada en consola, simplemente lo guarda como un String

	message := fmt.Sprintf("%s tiene mas de %d cursos", nombre, cursos)
	fmt.Println(message)

	// Imprimir el tipo de dato
	fmt.Printf("helloMessage: %T\n", helloMessage)
	fmt.Printf("cursos: %T", cursos)

func main() {
	// Declaracion de variables
	helloMessage := "Hello"
	worldMessage := "world"

	// Println
	fmt.Println(helloMessage, worldMessage)

	// Printf
	nombre := "Platzi"
	cursos := 500

	fmt.Printf("%s tiene mas de %d cursos\n", nombre, cursos)
	// v: no sabes que tipo de dato es
	fmt.Printf("%v tiene mas de %v cursos\n", nombre, cursos)
	
	// Sprintf
	message := fmt.Sprintf("%s tiene mas de %d cursos", nombre, cursos)
	fmt.Println(message)

	// Tipo de dato
	fmt.Printf("helloMessage: %T\n", helloMessage)
	fmt.Printf("cursos: %T", helloMessage)

	
}

package main

import "fmt"

func main() {
	//Declaración de variables
	helloMessage := "Hello"
	worldMessage := "world!!"

	//Println imprime con salto de linea
	fmt.Println(helloMessage, worldMessage)
	fmt.Println(helloMessage, worldMessage)

	//PrintF imprime con formato
	//%v se usara para imprimir si no sabemos el formato
	nombre := "Platzi"
	cursos := 500
	fmt.Printf("%s tiene más de %d cursos \n", nombre, cursos)
	fmt.Printf("%v tiene más de %v cursos \n", nombre, cursos)

	//SprintF sirve para crear una cadena con formato

	message := fmt.Sprintf("%s tiene más de %d cursos ", nombre, cursos)
	fmt.Println(message)

	//%T nos sirve para imprimir el tipo de la variable
	fmt.Printf("helloMessage es del tiipo -> %T\n", helloMessage)
	fmt.Printf("cursos es del tipo -> %T\n", cursos)

}

%s = significa que el valor sera un String
%d = significa que el valor sera un entero int
%T = identificar el tipo de datof

Una práctica de lo visto:

Muy bueno

Un dato de shortcut que puede ser útil en Code, es si al menos en Mac aprietas “Shift + Option + Fecha Arriba/abajo” se copia la linea abajo.

Printf me parece muy útil y combinado con Sprintf aún más =)