Go fmt.Printf formato de cadena

Sintaxis básica del lenguaje Go

fmt.Printf es una poderosa función de formato de salida en el lenguaje Go, utilizada principalmente para formatear cadenas y enviar el resultado a la salida estándar (generalmente la consola).

fmt.Printf formatea las variables posteriores según la cadena de formato especificada, la sintaxis es la siguiente:

fmt.Printf(格式化样式, 参数列表…)

Estilos de formato:Formato de cadena: los símbolos de formato comienzan con%el símbolo %, %s formato de cadena, %d formato de entero decimal.
Lista de parámetros:Los múltiples parámetros se separan por comas; el número debe corresponder uno a uno con el número de formatos en el estilo, de lo contrario se producirá un error en tiempo de ejecución.

Ejemplo

package main

import (
"fmt"
"strings"
)

func main() {
name := "John Doe"
age := 27

// Imprime la cadena en minúsculas
fmt.Printf("hello, %s\n", strings.ToLower(name))

// Imprime la cadena en mayúsculas
fmt.Printf("hello, %s\n", strings.ToUpper(name))

// Imprime la edad como número decimal
fmt.Printf("%s is %d years old\n", name, age)

// Imprime la edad como un número flotante con dos decimales
fmt.Printf("%s is %.2f years old\n", name, age)
}

El resultado de salida es:

hello, John Doe
hello, JOHN DOE
John Doe is 27 years old
John Doe is %!f(int=27) years old

Símbolos de formato de cadena en Go:

Símbolo de formato	Descripción	Ejemplo
Formato general
`%v`	Imprime la variable en el formato predeterminado	`fmt.Printf("%v", 42)`
`%+v`	Imprime la estructura con los nombres de los campos	`fmt.Printf("%+v", struct{A int}{A: 42})`
`%#v`	Formatea la salida con la sintaxis de Go	`fmt.Printf("%#v", map[string]int{"a": 1})`
`%T`	Imprime el tipo del valor	`fmt.Printf("%T", 42)`
`%%`	Imprime el símbolo de porcentaje	`fmt.Printf("%%")`
Booleano
`%t`	Salida`true`o`false`	`fmt.Printf("%t", true)`
Entero
`%b`	Representación binaria	`fmt.Printf("%b", 5)`
`%c`	Carácter correspondiente a Unicode	`fmt.Printf("%c", 65)`
`%d`	Representación decimal	`fmt.Printf("%d", 42)`
`%o`	Representación octal	`fmt.Printf("%o", 10)`
`%x`	Representación hexadecimal (letras minúsculas)	`fmt.Printf("%x", 15)`
`%X`	Representación hexadecimal (letras mayúsculas)	`fmt.Printf("%X", 15)`
`%U`	Salida en formato Unicode	`fmt.Printf("%U", 65)`
Número flotante
`%f`	Número flotante decimal	`fmt.Printf("%f", 3.14)`
`%e`	Notación científica (e minúscula)	`fmt.Printf("%e", 3.14)`
`%E`	Notación científica (E mayúscula)	`fmt.Printf("%E", 3.14)`
`%g`	Selección automática`%f`o`%e`de la representación concisa	`fmt.Printf("%g", 3.14)`
Cadenas y bytes
`%s`	Cadena normal	`fmt.Printf("%s", "Go")`
`%q`	Cadena o carácter con comillas dobles	`fmt.Printf("%q", "Go")`
`%x`	Cada byte se representa en hexadecimal con dos caracteres	`fmt.Printf("%x", "abc")`
`%X`	Representación hexadecimal (mayúsculas)	`fmt.Printf("%X", "abc")`
Puntero
`%p`	Dirección del puntero	`fmt.Printf("%p", &x)`

La cadena de formato se compone de texto normal y marcadores de posición de formato.

El marcador de posición de formato comienza% con %, seguido de uno o más caracteres que indican el tipo de formato.

La estructura del marcador de posición de formato es:

%[flags][width][.precision]verb

flags: bandera utilizada para controlar la salida formateada (opcional).
- -: alineación a la izquierda.
- +: siempre muestra el signo del valor numérico.
- 0: rellena con ceros.
- #: agrega prefijo para binario, octal, hexadecimal, etc.
- espacio: agrega un espacio antes de los números positivos y un signo antes de los negativos-。
width: ancho de salida (opcional).
.precision: número de dígitos después del punto decimal para números flotantes (opcional).
verb: especifica el método de formato de los datos.

1. Formatear enteros

fmt.Printf("十进制: %d, 二进制: %b, 八进制: %o, 十六进制: %x\n", 42, 42, 42, 42)
// 输出：十进制: 42, 二进制: 101010, 八进制: 52, 十六进制: 2a

2. Formatear números flotantes

fmt.Printf("普通: %f, 科学计数法: %e, 自动: %g\n", 123.456, 123.456, 123.456)
// 输出：普通: 123.456000, 科学计数法: 1.234560e+02, 自动: 123.456

3. Formatear cadenas

fmt.Printf("普通字符串: %s, 带引号: %q, 十六进制: %x\n", "Go", "Go", "Go")
// 输出：普通字符串: Go, 带引号: "Go", 十六进制: 476f

4. Usar ancho y alineación

fmt.Printf("|%10s|%-10s|\n", "right", "left")
// 输出：|     right|left      |

5. Formatear estructuras

type User struct {
    Name string
    Age  int
}
user := User{Name: "Alice", Age: 30}
fmt.Printf("默认: %v\n带字段名: %+v\nGo语法: %#v\n", user, user, user)
// 输出：
// 默认: {Alice 30}
// 带字段名: {Name:Alice Age:30}
// Go语法: main.User{Name:"Alice", Age:30}

6. Formatear booleanos

fmt.Printf("布尔值: %t, %t\n", true, false)
// 输出：布尔值: true, false

Ejemplo

package main

import (
"fmt"
"os"
)

type point struct {
x, y int
}

func main() {

p := point{1, 2}
fmt.Printf("%v\n", p)

fmt.Printf("%+v\n", p)

fmt.Printf("%#v\n", p)

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

fmt.Printf("%t\n", true)

fmt.Printf("%d\n", 123)

fmt.Printf("%b\n", 14)

fmt.Printf("%c\n", 33)

fmt.Printf("%x\n", 456)

fmt.Printf("%f\n", 78.9)

fmt.Printf("%e\n", 123400000.0)
fmt.Printf("%E\n", 123400000.0)

fmt.Printf("%s\n", "\"string\"")

fmt.Printf("%q\n", "\"string\"")

fmt.Printf("%x\n", "hex this")

fmt.Printf("%p\n", &p)

fmt.Printf("|%6d|%6d|\n", 12, 345)

fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)

fmt.Printf("|%6s|%6s|\n", "foo", "b")

fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

s := fmt.Sprintf("a %s", "string")
fmt.Println(s)

fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

El resultado de salida es:

{1 2}
{x:1 y:2}
main.point{x:1, y:2}
main.point
true
123
1110
!
1c8
78.900000
1.234000e+08
1.234000E+08
"string"
"\"string\""
6865782074686973
0xc0000b4010
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error

Sintaxis básica del lenguaje Go

Otras extensiones