Go в примери: Изглед на низове

Го предлага превъзходна поддръжка за задаване изгледа¹ на низове в духа на printf от езика C. Ето някои примери на чести такива задачи.

formatting – задаване изгледа, външния вид на различни видове данни; форматиране. От др. гръцки морф ( вж. Морфей). Навлязло в употреба при сметалата около 1955 г.

package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {

Го предлага няколко печaтащи „глагола“, изобретени за задаване на изгледа на стойности. Например следното извежда стойността на структурата point.

    p := point{1, 2}
    fmt.Printf("строй 1: %v\n", p)

Ако стойността е структура, разновидността %+v ще включи и имената на полетата.

    fmt.Printf("строй 2: %+v\n", p)

Разновидността %#v отпечатва стойността, представена с правописа на Го, сиреч, изходният код, който би произвел тази стойност.

    fmt.Printf("строй 3: %#v\n", p)

За да отпечатим вида данни на тази стойност, ползваме %T.

    fmt.Printf("вид: %T\n", p)

Булевите стойности се показват така.

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

Има много възможности за задаване изгледа на цели числа. Използвайте глагола %d, за да покажете числата като десетични, независимо как сте ги записали (или са) в изходния код.

    fmt.Printf("int: %d\n", 1133)
    fmt.Printf("int: %d\n", 02155)
    fmt.Printf("int: %d\n", 0x046D)
    fmt.Printf("int: %d\n", 0b10001101101)

%b ни дава двоично представяне.

    fmt.Printf("bin: %b\n", 1133)

%o ни дава осмично представяне.

    fmt.Printf("oct: %o\n", 14)
    fmt.Printf("oct: %o\n", 1133)

Глаголът %c дава знака, съответстващ на подаденото цяло число, независимо от представянето му в изходния код.

    fmt.Printf("знак: %c\n", 1133)          // ѭ
    fmt.Printf("знак: %c\n", 02155)         // ѭ
    fmt.Printf("знак: %c\n", 0x046D)        // ѭ
    fmt.Printf("char: %c\n", 0b10001101101) // ѭ

%x ни показва числото, кодирано като шестнадесетично, независимо от представянето му в изходния код.

    fmt.Printf("hex: %x\n", 1133)
    fmt.Printf("hex: %x\n", 0x046D)
    fmt.Printf("hex: %x\n", 0b10001101101)

Има също няколко възможности за задаванае на изгледа на числа с плаваща запетая. За показване като число с основа десет, ползвайте %f.

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

%e и %E представят десетичната дроб в леко различаващи се разновидности на научно означаване.

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

За обикновено отпечатване на низове, ползвайте %s.

    fmt.Printf("str1: %s\n", "низ")

За ограждане на низ с двойни кавички както в изходния код на Го, ползвайте %q.

    fmt.Printf("str2: %q\n", `"низ"`)

Както при целите числа по-горе, %x представя низа като последователност от двуцифрени шестнадесетични числа за всеки входен байт¹.

Това е малък йотуван юс, в UTF-8 (както е кодиран изходния код на програмите на Го), като всеки байт е представен като шестнадесетично двуцифрено число.

    fmt.Printf("str3: %x\n", "ѭ")

Същият знак, от байтове към низ.

    fmt.Println(`d1ad:`, string([]byte{0xd1, 0xad}))

За да представите указател, ползвайте %p.

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

Когато представяте числа, често ще искате да управлявате ширината и знаците след точката. За да укажете заеманата ширина в знаци, в глагола използвайте цяло число след %. По подразбиране изходът е равнѐн вдясно и предхождан от празноти.

    fmt.Printf("width1: |%6d|%6d|\n", 12, 12345)

Можете да указвате заеманата ширина в знаци и за десетични дроби, но ще искате да укажете и броя знаци след десетичната запетая (точката). Правописът е ширина.точностf. Забележете, че числото бива закръглено автоматично, а не просто отрязано.

    fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.456)
    fmt.Printf("width2: |%6.2f|%6.2f|\n", 12.21, 3.455)
    fmt.Printf("width2: |%6.2f|%6.2f|\n", 123.233, 3.454)

За да равните вляво, използвайте знамето -.

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

Може би искате да управлявате заеманата ширина в знаци, когато задавате изглед на низове, особено в табличен вид. Ето дясно равнен изглед с ширина шест знака.

    fmt.Printf("width4: |%6s|%6s|\n", "пѫт", "молѭ")

За да равните вляво, ползвайте знамето -, както с числата.

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

Дотук видяхме Printf, която задава изглед и пише в os.Stdout. Sprintf задава изгледа и връща низа, без да го пише никъде.

    s := fmt.Sprintf("sprintf: %s", "наниз")
    fmt.Println(s)

Можете да задавате изглед и да пишете и в други обекти, осъществяващи взаимодействието io.Writer, а не само в os.Stdout с помощта на Fprintf.

    fmt.Fprintf(os.Stderr, "изход: %s\n", "грешка")
}