Go fmt.Sprintf Formatzeichenfolge
Grundlegende Syntax der Go-Sprache
Go kann fmt.Sprintf verwenden, um Zeichenketten zu formatieren, wie folgt:
fmt.Sprintf(格式化样式, 参数列表…)
- Formatierungsstil:In Zeichenkettenform werden die Formatierungssymbole durch%am Anfang angegeben, %s ist das Zeichenkettenformat und %d ist das Format für dezimale Ganzzahlen.
- Parameterliste:Mehrere Parameter werden durch Kommas getrennt, und die Anzahl der Parameter muss eins zu eins mit der Anzahl der Formatbezeichner in der Formatzeichenfolge übereinstimmen; andernfalls wird ein Laufzeitfehler gemeldet.
Beispiel
import (
"fmt"
"io"
"os"
)
func main() {
// In Go eine Zeichenkette mit fmt.Sprintf formatieren und einer neuen Zeichenkette zuweisen
// %s steht für eine Zeichenkette
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)
// Ein weiteres Beispiel, %d repräsentiert eine Ganzzahl
const name, age = "Kim", 22
s := fmt.Sprintf("%s ist %d Jahre alt.\n", name, age)
io.WriteString(os.Stdout, s) // Der Einfachheit halber werden einige Fehler ignoriert
}
Das Ausgabeergebnis ist:
Code=000987&endDate=2020-12-31 Kim is 22 years old.
Beispiel
import (
"fmt"
"io"
"os"
)
func main() {
// Numerische Variablen deklarieren
const num1, num2, num3 = 5, 10, 15
// Die Funktion Sprintf() aufrufen
s := fmt.Sprintf("%d + %d = %d", num1, num2, num3)
// Verwenden Sie die Funktion WriteString(), um das Ergebnis auf dem Terminal auszugeben, um die
// "os.Stdout" ist der Inhalt der Zeichenkette
io.WriteString(os.Stdout, s)
}
Das Ausgabeergebnis ist:
5 + 10 = 15
Go-String-Formatierungssymbole:
| Format | Beschreibung |
|---|---|
| %v | Gibt den Wert unverändert aus |
| %+v | Aufbauend auf %v die Feldnamen und Werte der Struktur erweitern. |
| %#v | Gibt den Wert im Syntaxformat der Sprache Go aus |
| %T | Gibt Typ und Wert im Go-Syntaxformat aus. |
| %% | Gibt % selbst aus |
| %b | Zeigt Ganzzahlen binär an |
| %o | Zeigt Ganzzahlen im Oktalformat an |
| %d | Zeigt Ganzzahlen im Dezimalformat an |
| %x | Zeigt Ganzzahlen im Hexadezimalformat an |
| %X | Zeigt Ganzzahlen im Hexadezimalformat mit Großbuchstaben an. |
| %U | Unicode-Zeichen |
| %f | Gleitkommazahl |
| %p | Zeiger, in hexadezimaler Darstellung angezeigt |
Beispiel
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)
}
Im obigen Beispiel werden %s, %d und %.2f in der Formatzeichenkette "Name: %s, Age: %d, Height: %.2f" jeweils durch die Werte der Variablen name, age und height ersetzt, wobei%.2fein Gleitkommaformat mit zwei Dezimalstellen darstellt.
Das Ausgabeergebnis ist:
Name: John, Age: 30, Height: 175.50
%.2fIst eine Formatierungsoption für Gleitkommazahlen, mit der die Dezimalgenauigkeit von Gleitkommazahlen gesteuert wird, wobei2die Anzahl der beizubehaltenden Dezimalstellen angibt und sie nach Bedarf geändert werden kann.
Weitere Anwendungsbeispiele:
Beispiel
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")
}
Das Ausgabeergebnis ist:
{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
Alignment
Durch die Verwendung von Breiten- und Ausrichtungsparametern in der Formatzeichenkette können Sie die Ausrichtung der generierten Zeichenkette steuern.
Häufig verwendete Ausrichtungsparameter sind:
%s: Für das Zeichenkettenformat können die folgenden Ausrichtungsparameter verwendet werden:%s: Standardausrichtung, linksbündig.%10s: Gibt rechtsbündige Ausrichtung mit einer Breite von 10 an.%-10s: Gibt die linksbündige Ausrichtung mit einer Breite von 10 an.
%d: Für das Ganzzahlformat können die folgenden Ausrichtungsparameter verwendet werden:%d: Standardausrichtung, rechtsbündig.%10d: Gibt rechtsbündige Ausrichtung mit einer Breite von 10 an.%-10d: Gibt die linksbündige Ausrichtung mit einer Breite von 10 an.
%f: Für das Gleitkommaformat können die folgenden Ausrichtungsparameter verwendet werden:%f: Standardausrichtung, rechtsbündig.%10f: Gibt rechtsbündige Ausrichtung mit einer Breite von 10 an.%-10f: Gibt die linksbündige Ausrichtung mit einer Breite von 10 an.
Beispiel
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)
}
Das Ausgabeergebnis ist:
|Hello| | Hello| |Hello | |42| | 42| |42 | |3.141590| | 3.141590| |3.141590 |Weitere Erweiterungen