Go fmt.Printf Formatstrings

Grundlegende Syntax der Go-Sprache

fmt.Printf ist eine leistungsstarke Funktion zur Ausgabeformatierung in der Go-Sprache, die hauptsächlich dazu dient, Strings zu formatieren und das Ergebnis an die Standardausgabe (üblicherweise die Konsole) auszugeben.

fmt.Printf formatiert nachfolgende Variablen gemäß dem angegebenen Formatstring; die Syntax lautet wie folgt:

fmt.Printf(格式化样式, 参数列表…)
  • Formatierungsstil:String-Form, Formatierungssymbole beginnen mit%Beginnt mit %; %s ist String-Format, %d ist Dezimal-Ganzzahlformat.
  • Parameterliste:Mehrere Parameter werden durch Kommas getrennt, und ihre Anzahl muss eins zu eins mit der Anzahl im Formatstring übereinstimmen, andernfalls wird zur Laufzeit ein Fehler gemeldet.

Beispiel

package main

import (
   "fmt"
   "strings"
)


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

  // Gibt den String in Kleinbuchstaben aus
  fmt.Printf("hello, %s\n", strings.ToLower(name))

  // Gibt den String in Großbuchstaben aus
  fmt.Printf("hello, %s\n", strings.ToUpper(name))

  // Alter als Dezimalzahl ausgeben
  fmt.Printf("%s ist %d Jahre alt\n", name, age)

  // Alter als Gleitkommazahl mit zwei Dezimalstellen ausgeben
  fmt.Printf("%s ist %.2f Jahre alt\n", name, age)
}

Ausgabeergebnis:

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

Go-String-Formatierungssymbole:

FormatbezeichnerBeschreibungBeispiel
Allgemeines Format
%vVariable im Standardformat ausgebenfmt.Printf("%v", 42)
%+vStruct mit Feldnamen ausgebenfmt.Printf("%+v", struct{A int}{A: 42})
%#vAusgabe in Go-Syntax formatierenfmt.Printf("%#v", map[string]int{"a": 1})
%TTyp des Ausgabewertsfmt.Printf("%T", 42)
%%Prozentzeichen ausgebenfmt.Printf("%%")
Boolescher Wert
%tAusgabetrueoderfalsefmt.Printf("%t", true)
Integer
%bBinäre Darstellungfmt.Printf("%b", 5)
%cEntsprechendes Unicode-Zeichenfmt.Printf("%c", 65)
%dDezimale Darstellungfmt.Printf("%d", 42)
%oOktale Darstellungfmt.Printf("%o", 10)
%xHexadezimale Darstellung (Kleinbuchstaben)fmt.Printf("%x", 15)
%XHexadezimale Darstellung (Großbuchstaben)fmt.Printf("%X", 15)
%UAusgabe im Unicode-Formatfmt.Printf("%U", 65)
Gleitkommazahl
%fDezimal-Gleitkommazahlfmt.Printf("%f", 3.14)
%eWissenschaftliche Schreibweise (kleines e)fmt.Printf("%e", 3.14)
%EWissenschaftliche Schreibweise (großes E)fmt.Printf("%E", 3.14)
%gAutomatische Auswahl%foder%eKompakte Darstellungfmt.Printf("%g", 3.14)
Zeichenketten und Bytes
%sEinfache Zeichenkettefmt.Printf("%s", "Go")
%qZeichenkette oder Zeichen mit doppelten Anführungszeichenfmt.Printf("%q", "Go")
%xJedes Byte wird durch zwei Hexadezimalzeichen dargestelltfmt.Printf("%x", "abc")
%XHexadezimale Darstellung (Großbuchstaben)fmt.Printf("%X", "abc")
Zeiger
%pZeigeradressefmt.Printf("%p", &x)

Der Format-String besteht aus normalem Text und Formatplatzhaltern.

Formatierungsplatzhalter mit% Beginnt mit %, gefolgt von einem oder mehreren Zeichen, die den Formattyp angeben.

Der Aufbau eines Formatierungsplatzhalters ist:

%[flags][width][.precision]verb
  • flagsFlags zur Steuerung der formatierten Ausgabe (optional).
    • -: Linksbündig.
    • +: Immer das Vorzeichen des Werts anzeigen.
    • 0: mit Nullen aufgefüllt.
    • #Fügt ein Präfix für Binär-, Oktal-, Hexadezimal- usw. hinzu.
    • Space: Positive Zahlen mit vorangestelltem Leerzeichen, negative Zahlen mit vorangestelltem-。
  • width: Ausgabebreite (optional).
  • .precisionAnzahl der Nachkommastellen für Gleitkommazahlen (optional).
  • verb: Wird verwendet, um die Formatierungsmethode der Daten anzugeben.

1. Formatieren von Ganzzahlen

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

2. Formatieren von Gleitkommazahlen

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

3. Formatieren von Zeichenketten

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

4. Verwenden von Breite und Ausrichtung

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

5. Formatieren von Structs

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. Formatieren von booleschen Werten

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

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

Ausgabeergebnis:

{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

Grundlegende Syntax der Go-Sprache

Weitere Erweiterungen