Go fmt.Sprintf formato de cadenas

Go 语言基础语法Sintaxis básica del lenguaje Go

Go puede usar fmt.Sprintf para formatear cadenas, el formato es el siguiente:

fmt.Sprintf(格式化样式, 参数列表…)
  • Estilo de formato:En forma de cadena, el símbolo de formato comienza con%inicio, %s formato de cadena, %d formato de entero decimal.
  • Lista de parámetros:Varios parámetros están separados por comas; la cantidad debe corresponderse uno a uno con la cantidad en el estilo de formato, de lo contrario se producirá un error en tiempo de ejecución.

Ejemplo

package main


import (
    "fmt"
    "io"
    "os"
)


func main() {
    // En Go, formatea una cadena y asígnala a una nueva cadena, usando fmt.Sprintf
    // %s representa una cadena
    var stockcode="000987"
    var enddate="2020-12-31"
    var url="Code=%s&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)

    // Otro ejemplo, %d representa un entero
    const name, age = "Kim", 22
    s := fmt.Sprintf("%s is %d years old.\n", name, age)
    io.WriteString(os.Stdout, s) // Por simplicidad, ignora algunos errores
}

El resultado es:

Code=000987&endDate=2020-12-31
Kim is 22 years old.

Ejemplo

package main
import (
    "fmt"
    "io"
    "os"
)
func main() {
 
    // Declarar variables numéricas
    const num1, num2, num3 = 5, 10, 15
 
    // Llamar a la función Sprintf()
    s := fmt.Sprintf("%d + %d = %d", num1, num2, num3)
 
    // Usar la función WriteString() para enviar el resultado a la terminal to write the
    // "os.Stdout" es el contenido de la cadena
    io.WriteString(os.Stdout, s)
 
}

El resultado es:

5 + 10 = 15

Símbolos de formato de cadena en Go:

Formato Descripción
%v Imprime el valor en su forma original
%+v A partir de %v, expande los nombres de campo y los valores de la estructura
%#v Imprime el valor en formato de sintaxis de Go
%T Imprime el tipo y el valor en formato de sintaxis de Go
%% Imprime el propio símbolo %
%b Entero mostrado en binario
%o Entero mostrado en octal
%d Entero mostrado en decimal
%x Entero mostrado en hexadecimal
%X Entero mostrado en hexadecimal con letras mayúsculas
%U Carácter Unicode
%f Número de punto flotante
%p Puntero, mostrado en hexadecimal

Ejemplo

package main

import "fmt"

func main() {
    name := "John"
    age := 30
    height := 175.5

    result := fmt.Sprintf("Name: %s, Age: %d, Height: %.2f", name, age, height)
    fmt.Println(result)
}

En el ejemplo anterior, en la cadena de formato "Name: %s, Age: %d, Height: %.2f", los %s, %d y %.2f son reemplazados respectivamente por los valores de las variables name, age y height, donde%.2frepresenta el formato de punto flotante con dos decimales.

El resultado es:

Name: John, Age: 30, Height: 175.50

%.2fes una opción de formato de punto flotante que se usa para controlar la precisión decimal del número de punto flotante, donde2representa el número de decimales a conservar; puedes modificarlo según sea necesario.

Más ejemplos de uso:

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 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

Alineación

Al utilizar los parámetros de ancho y alineación en la cadena de formato, se puede controlar la alineación de la cadena generada.

Los parámetros de alineación más comunes son:

  • %s: Formato de cadena, se pueden usar los siguientes parámetros de alineación:
    • %s: Alineación predeterminada, alineación a la izquierda.
    • %10s: Alineación a la derecha con ancho de 10.
    • %-10s: Alineación a la izquierda con ancho de 10.
  • %d: Formato de entero, se pueden usar los siguientes parámetros de alineación:
    • %d: Alineación predeterminada, alineación a la derecha.
    • %10d: Alineación a la derecha con ancho de 10.
    • %-10d: Alineación a la izquierda con ancho de 10.
  • %f: Formato de punto flotante, se pueden usar los siguientes parámetros de alineación:
    • %f: Alineación predeterminada, alineación a la derecha.
    • %10f: Alineación a la derecha con ancho de 10.
    • %-10f: Alineación a la izquierda con ancho de 10.

Ejemplo

package main

import "fmt"

func main() {
    str := "Hello"
    num := 42
    floatNum := 3.14159

    fmt.Printf("|%s|\n", str)
    fmt.Printf("|%10s|\n", str)
    fmt.Printf("|%-10s|\n", str)

    fmt.Printf("|%d|\n", num)
    fmt.Printf("|%10d|\n", num)
    fmt.Printf("|%-10d|\n", num)

    fmt.Printf("|%f|\n", floatNum)
    fmt.Printf("|%10f|\n", floatNum)
    fmt.Printf("|%-10f|\n", floatNum)
}

El resultado es:

|Hello|
|     Hello|
|Hello     |
|42|
|        42|
|42        |
|3.141590|
|  3.141590|
|3.141590  |

Go 语言基础语法Sintaxis básica del lenguaje Go

Otras extensiones