Go podle Příkladů: Formátování řetězců

Go nabízí výbornou podporu pro formátování řetězců v tradici printf. Zde jsou některé příklady běžných úkolů pro formátování řetězců.

package main
import "fmt"
import "os"
type point struct {
    x, y int
}
func main() {

Go nabízí několik “verbs” (sloves) navržených pro formátování obecných Go hodnot. Například tohle vytiskne instanci naši struktury point.

    p := point{1, 2}
    fmt.Printf("%v\n", p)

Pokud je hodnota struktura, varianta %+v bude obsahovat také názvy prvků struktury.

    fmt.Printf("%+v\n", p)

Varianta %#v vypíše hodnotu reprezentovanou pomocí Go syntaxe, tj. například kus zdrojového kódu který by danou hodnotu vytvořil.

    fmt.Printf("%#v\n", p)

Pro vypsání typu hodnoty, použijte %T.

    fmt.Printf("%T\n", p)

Formátování boolean proměnných je přímočaré.

    fmt.Printf("%t\n", true)

Je hodně možností jak formátovat integery. Použij %d pro standardní formátování v desítkové soustavě.

    fmt.Printf("%d\n", 123)

Toto vypíše binární reprezentaci.

    fmt.Printf("%b\n", 14)

Toto vypíše znak odpovídající danému integeru.

    fmt.Printf("%c\n", 33)

%x poskytuje hodnotu v hexadecimálním kódu.

    fmt.Printf("%x\n", 456)

Máme také několik možností formátování pro floaty. Pro základní desetinné formátování použijte %f.

    fmt.Printf("%f\n", 78.9)

Slovesa %e a %E formátují floaty do (trochu odlišné verzi) vědeckého zápisu.

    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

Pro běžný tisk řetězců použijte %s.

    fmt.Printf("%s\n", "\"string\"")

Pro tisk řetězce obaleného uvozovkami jako v Go kódu, použijte %q.

    fmt.Printf("%q\n", "\"string\"")

Jako jsme viděli už dříve s integery, %x renderuje řetězec v 16-kové soustavě se dvěma výstupními znaky pro jeden vstupní bajt.

    fmt.Printf("%x\n", "hex this")

Pro výpis reprezentace ukazatele, použijte %p.

    fmt.Printf("%p\n", &p)

Při formátování čísel často budete chtít ovládat šířku a přesnost výsledného čísla. Pro specifikaci délku integeru, použije číslo za slovesem %. Ve výchozím stavu bude výsledek zarovnaný doprava a zleva doplněný mezerami.

    fmt.Printf("|%6d|%6d|\n", 12, 345)

Také můžete specifikovat šířku vypisovaných floatů, ačkoliv obvzkle také budete chtít omezit desetinnou přesnost pomocí syntaxe se zápisem šířka.přesnost

    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

Pro levé zarovnání použij příznak -.

    fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)

Také možná budete chtít ovládat šířku při formátování řetězců, obzvlášť pro dosažení jejích zarovnání v tavulkovém výstupu. Pro základní pravé zarovnání na šířku.

    fmt.Printf("|%6s|%6s|\n", "foo", "b")

Pro levé zarovnání použitje příznak - stejně jako u čísel.

    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

Zatím jsme viděli Printf, který vupisuje formátovaný řetězec na os.Stdout. Sprintf formátuje a vrací řezězec bež toho aby ho někam vypisoval..

    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

Také můžete s pomocí Fprintf vypsat+formátovat i do jiných io.Writers než jen os.Stdout.

    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}
$ go run string-formatting.go
{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
0x42135100
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error

Další příklad: Regulární výrazy.