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

package main


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

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

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

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

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")
}

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

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

Das Ausgabeergebnis ist:

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

Grundlegende Syntax der Go-Sprache

Weitere Erweiterungen