Formato de cadenas en Go | Tutoriales de programación

Introducción

Este laboratorio tiene como objetivo poner a prueba tus conocimientos sobre el formato de cadenas en Golang. Se te pedirá que formates diferentes tipos de datos, como enteros, números de punto flotante, cadenas y estructuras, utilizando diversos verbos de formato.

Formato de Cadenas

Se te pide que formes diferentes tipos de datos utilizando diversos verbos de formato en Golang.

Debes utilizar el paquete fmt para formatear los datos.
Debes utilizar el verbo de formato correcto para cada tipo de dato.
Debes ser capaz de formatear enteros, números de punto flotante, cadenas y estructuras.
Debes ser capaz de controlar el ancho y la precisión de la salida.
Debes ser capaz de justificar la salida a la izquierda o a la derecha.

$ go run string-formatting.go
struct1: {1 2}
struct2: {x:1 y:2}
struct3: main.point{x:1, y:2}
type: main.point
bool: true
int: 123
bin: 1110
char:!
hex: 1c8
float1: 78.900000
float2: 1.234000e+08
float3: 1.234000E+08
str1: "string"
str2: "\"string\""
str3: 6865782074686973
pointer: 0xc0000ba000
width1: | 12 | 345 \
  | width2: | 1.20 | 3.45 \
  | width3: | 1.20 | 3.45 \
  | width4: | foo | b \
  | width5: | foo | b \
  | sprintf: a string
io: an error

A continuación, se muestra el código completo:

// Go ofrece una excelente compatibilidad para el formato de cadenas
// en la tradición de `printf`. Aquí hay algunos ejemplos de
// tareas comunes de formato de cadenas.

package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {

    // Go ofrece varios "verbos" de impresión diseñados para
    // formatear valores generales de Go. Por ejemplo, esto imprime
    // una instancia de nuestra estructura `point`.
    p := point{1, 2}
    fmt.Printf("struct1: %v\n", p)

    // Si el valor es una estructura, la variante `%+v` incluirá
    // los nombres de los campos de la estructura.
    fmt.Printf("struct2: %+v\n", p)

    // La variante `%#v` imprime una representación de sintaxis de Go
    // del valor, es decir, el fragmento de código fuente que
    // produciría ese valor.
    fmt.Printf("struct3: %#v\n", p)

    // Para imprimir el tipo de un valor, utiliza `%T`.
    fmt.Printf("type: %T\n", p)

    // Formatear booleanos es sencillo.
    fmt.Printf("bool: %t\n", true)

    // Hay muchas opciones para formatear enteros.
    // Utiliza `%d` para el formato estándar en base 10.
    fmt.Printf("int: %d\n", 123)

    // Esto imprime una representación binaria.
    fmt.Printf("bin: %b\n", 14)

    // Esto imprime el carácter correspondiente al
    // entero dado.
    fmt.Printf("char: %c\n", 33)

    // `%x` proporciona codificación hexadecimal.
    fmt.Printf("hex: %x\n", 456)

    // También hay varias opciones de formato para
    // números de punto flotante. Para el formato decimal básico, utiliza `%f`.
    fmt.Printf("float1: %f\n", 78.9)

    // `%e` y `%E` formatean el número de punto flotante en (ligeramente
    // diferentes versiones de) notación científica.
    fmt.Printf("float2: %e\n", 123400000.0)
    fmt.Printf("float3: %E\n", 123400000.0)

    // Para la impresión básica de cadenas, utiliza `%s`.
    fmt.Printf("str1: %s\n", "\"string\"")

    // Para poner comillas dobles a las cadenas como en el código fuente de Go, utiliza `%q`.
    fmt.Printf("str2: %q\n", "\"string\"")

    // Al igual que con los enteros vistos anteriormente, `%x` representa
    // la cadena en base 16, con dos caracteres de salida por byte de entrada.
    fmt.Printf("str3: %x\n", "hex this")

    // Para imprimir una representación de un puntero, utiliza `%p`.
    fmt.Printf("pointer: %p\n", &p)

    // Al formatear números, a menudo querrás
    // controlar el ancho y la precisión del resultado.
    // Para especificar el ancho de un entero, utiliza un número después del `%` en el verbo.
    // Por defecto, el resultado se justificará a la derecha y se rellenará con espacios.
    fmt.Printf("width1: |%6d|%6d|\n", 12, 345)

    // También puedes especificar el ancho de los números de punto flotante impresos,
    // aunque generalmente también querrás restringir la precisión decimal al mismo tiempo
    // con la sintaxis ancho.precisión.
    fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.45)

    // Para justificar a la izquierda, utiliza la bandera `-`.
    fmt.Printf("width3: |%-6.2f|%-6.2f|\n", 1.2, 3.45)

    // También es posible que desees controlar el ancho al formatear cadenas,
    // especialmente para asegurarte de que se alineen en una salida similar a una tabla.
    // Para un ancho básico justificado a la derecha.
    fmt.Printf("width4: |%6s|%6s|\n", "foo", "b")

    // Para justificar a la izquierda, utiliza la bandera `-` como con los números.
    fmt.Printf("width5: |%-6s|%-6s|\n", "foo", "b")

    // Hasta ahora hemos visto `Printf`, que imprime la cadena formateada en `os.Stdout`.
    // `Sprintf` formatea y devuelve una cadena sin imprimirla en ningún lugar.
    s := fmt.Sprintf("sprintf: a %s", "string")
    fmt.Println(s)

    // Puedes formatear e imprimir en `io.Writers` diferentes de `os.Stdout` utilizando `Fprintf`.
    fmt.Fprintf(os.Stderr, "io: an %s\n", "error")
}

Resumen

Este laboratorio puso a prueba tus conocimientos sobre el formato de cadenas en Golang. Aprendiste cómo formatear diferentes tipos de datos utilizando diversos verbos de formato y cómo controlar el ancho y la precisión de la salida. También aprendiste cómo justificar la salida a la izquierda o a la derecha.

Fundamentos del formato de cadenas en Golang

Introducción

Formato de Cadenas

Resumen