5. Formatierte Ausgabe in der Go-Sprache

1. Universell formatierte Ausgabe

Für formatierte Ausgaben in der Go-Sprache wird normalerweise das fmt-Paket verwendet. Das übliche Ausgabeformat ist in der folgenden Tabelle dargestellt:

Ausgabeformat	Inhalte ausgeben
%v	Die Standardformatdarstellung des Werts
%+v	Ähnlich wie %v, jedoch werden bei der Ausgabe der Struktur Feldnamen hinzugefügt
%#v	Go-Syntaxdarstellung von Werten
%T	Go-Syntaxdarstellung von Werttypen

package main

import "fmt"

func main() {
	var s string = "ajwlf"
	var z int = 1
	var r rune = '一'

	fmt.Printf("s: %v\n", s)
	fmt.Printf("s: %+v\n", s)
	fmt.Printf("s: %#v\n", s)
	fmt.Printf("s: %T\n", s)

	fmt.Printf("z: %v\n", z)
	fmt.Printf("z: %T\n", z)

	fmt.Printf("r: %v\n", r)
	fmt.Printf("r: %T\n", r)
}

aus:

s: ajwlf
s: ajwlf
s: "ajwlf"
s: string
z: 1
z: int
r: 19968
r: int32

2.Boolescher Typ

Ausgabeformat	Inhalte ausgeben
%T	Wort wahr oder falsch

package main
import "fmt"
func main() {
    var flag bool
    fmt.Printf("%T, %t \n", flag, flag)
    flag = true
    fmt.Printf("%T, %t \n", flag, flag)
}

// 结果
bool, false
bool, true

3. Integer-Typ

Ausgabeformat	Inhalte ausgeben
%B	Binär dargestellt
%C	Der diesem Wert entsprechende Unicode-Codewert
%D	Wird als Dezimalzahl ausgedrückt
%8d	Dies bedeutet, dass die Länge der Ganzzahl 8 beträgt. Wenn sie kleiner als 8 ist, fügen Sie vor dem Wert ein Leerzeichen ein. Wenn sie 8 überschreitet, hat der tatsächliche Wert Vorrang.
%08d	Dies bedeutet, dass die Länge der Ganzzahl 8 beträgt. Wenn sie kleiner als 8 ist, fügen Sie 0 vor dem Wert hinzu. Wenn sie 8 überschreitet, hat der tatsächliche Wert Vorrang.
%Ö	Wird als Oktal dargestellt
%Q	Der diesem Wert entsprechende Zeichenliteralwert der Go-Sprachsyntax wird in einfache Anführungszeichen gesetzt und bei Bedarf durch ein sicheres Escapezeichen dargestellt.
%X	Im Hexadezimalformat ausgedrückt, verwenden Sie a~f
%X	Im Hexadezimalformat ausgedrückt, verwenden Sie A~F
%U	Dargestellt als Unicode-Format: U+1234, entspricht U+%04X
%P	Zeigertyp

package main
import "fmt"
func main() {
    fmt.Printf("%T, %d \n", 123, 123)
    fmt.Printf("%T, %5d \n", 123, 123)
    fmt.Printf("%T, %05d \n", 123, 123)
    fmt.Printf("%T, %b \n", 123, 123)
    fmt.Printf("%T, %o \n", 123, 123)
    fmt.Printf("%T, %c \n", 97, 97)
    fmt.Printf("%T, %q \n", 97, 97)
    fmt.Printf("%T, %x \n", 123, 123)
    fmt.Printf("%T, %X \n", 123, 123)
    fmt.Printf("%T, %U \n", '一', '一')
}

// 结果
int, 123
int,   123
int, 00123
int, 1111011
int, 173
int, a
int, 'a'
int, 7b
int, 7B
int32, U+4E00

4. Gleitkommatyp und komplexer Zahlentyp

Ausgabeformat	Inhalte ausgeben
%B	Wissenschaftliche Notation ohne Dezimalteil und binären Exponenten, z. B. -123456p-78
%e	(=%.6e) Wissenschaftliche Notation mit 6 Dezimalstellen, z. B. -1234,456e+78
%E	Wissenschaftliche Notation, z. B. -1234,456E+78
%F	(=%.6f) hat 6 Dezimalstellen, z. B. 123,456123
%F	Entspricht %f
%G	Verwenden Sie je nach tatsächlicher Situation das %e- oder %f-Format (erhalten Sie eine prägnantere und genauere Ausgabe).
%G	Verwenden Sie je nach tatsächlicher Situation das %E- oder %F-Format (erhalten Sie eine prägnantere und genauere Ausgabe).

package main
import "fmt"
func main() {
    fmt.Printf("%b \n", 123.123456)
    fmt.Printf("%f \n", 123.1)
    fmt.Printf("%.2f \n", 123.125456)
    fmt.Printf("%e \n", 123.123456)
    fmt.Printf("%E \n", 123.123456)
    fmt.Printf("%.1e \n", 123.123456)
    fmt.Printf("%F \n", 123.123456)
    fmt.Printf("%g \n", 123.123456)
    fmt.Printf("%G \n", 123.123456)
}

// 结果
8664042977533870p-46
123.100000
123.13
1.231235e+02
1.231235E+02
1.2e+02
123.123456
123.123456
123.123456

5. Strings und Byte-Arrays

Ausgabeformat	Inhalte ausgeben
%S	String oder Byte-Array direkt ausgeben
%Q	Der diesem Wert entsprechende Go-Syntax-String-Literalwert ist in doppelte Anführungszeichen gesetzt und wird bei Bedarf sicher maskiert.
%X	Jedes Byte wird durch eine zweistellige Hexadezimalzahl dargestellt, wobei a~f verwendet wird
%X	Jedes Byte wird durch eine zweistellige Hexadezimalzahl dargestellt, wobei A~F verwendet wird

package main
import "fmt"
func main() {
    arr := []byte{'x', 'y', 'z', 'z'}
    fmt.Printf("%s \n", "欢迎访问")
    fmt.Printf("%q \n", "欢迎访问")
    fmt.Printf("%x \n", "欢迎访问")
    fmt.Printf("%X \n", "欢迎访问")
    fmt.Printf("%T, %s \n", arr, arr)
    fmt.Printf("%T, %q \n", arr, arr)
    fmt.Printf("%T, %x \n", arr, arr)
    fmt.Printf("%T, %X \n", arr, arr)
}

//
欢迎访问
"欢迎访问"
e6aca2e8bf8ee8aebfe997aee5beaee5ada6e88b91
E6ACA2E8BF8EE8AEBFE997AEE5BEAEE5ADA6E88B91
[]uint8, xyzz
[]uint8, "xyzz"
[]uint8, 78797a7a
[]uint8, 78797A7A