Go fmt.Sprintf formato de cadenas
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
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
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
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
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
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 |Otras extensiones