Go на примерах: Форматирование строк

Go предоставляет отличную поддержку форматирования строк в традиции `printf`. Вот несколько примеров типичных задач форматирования строк.
	`package main`
	`import ( "fmt" "os" )`
	`type point struct { x, y int }`
	`func main() {`
Go предлагает несколько «глаголов» (verbs) для вывода, предназначенных для форматирования значений Go. Например, здесь выводится экземпляр структуры `point`.	`p := point{1, 2} fmt.Printf("struct1: %v\n", p)`
Если значение — структура, вариант `%+v` выведет также имена полей структуры.	`fmt.Printf("struct2: %+v\n", p)`
Вариант `%#v` выводит представление значения в синтаксисе Go, т.е. фрагмент исходного кода, который создал бы это значение.	`fmt.Printf("struct3: %#v\n", p)`
Для вывода типа значения используй `%T`.	`fmt.Printf("type: %T\n", p)`
Форматирование булевых значений простое.	`fmt.Printf("bool: %t\n", true)`
Для форматирования целых чисел есть много вариантов. Используй `%d` для стандартного десятичного формата.	`fmt.Printf("int: %d\n", 123)`
Выводит двоичное представление.	`fmt.Printf("bin: %b\n", 14)`
Выводит символ, соответствующий данному целому числу.	`fmt.Printf("char: %c\n", 33)`
`%x` выводит в шестнадцатеричном формате.	`fmt.Printf("hex: %x\n", 456)`
Для чисел с плавающей точкой тоже есть несколько вариантов. Для базового десятичного формата используй `%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", "\"string\"")`
Для вывода строк в двойных кавычках как в исходном коде Go используй `%q`.	`fmt.Printf("str2: %q\n", "\"string\"")`
Как и для целых чисел, `%x` выводит строку в шестнадцатеричном формате, по два символа на каждый байт входных данных.	`fmt.Printf("str3: %x\n", "hex this")`
Для вывода представления указателя используй `%p`.	`fmt.Printf("pointer: %p\n", &p)`
При форматировании чисел часто нужно контролировать ширину и точность результата. Для указания ширины целого числа используй число после `%` в глаголе. По умолчанию результат выравнивается по правому краю и дополняется пробелами.	`fmt.Printf("width1: \|%6d\|%6d\|\n", 12, 345)`
Можно также указать ширину для чисел с плавающей точкой, хотя обычно при этом также ограничивают точность десятичной части с помощью синтаксиса ширина.точность.	`fmt.Printf("width2: \|%6.2f\|%6.2f\|\n", 1.2, 3.45)`
Для выравнивания по левому краю используй флаг `-`.	`fmt.Printf("width3: \|%-6.2f\|%-6.2f\|\n", 1.2, 3.45)`
При форматировании строк тоже может понадобиться контролировать ширину, особенно для выравнивания в табличном выводе. Базовое выравнивание по правому краю.	`fmt.Printf("width4: \|%6s\|%6s\|\n", "foo", "b")`
Для выравнивания по левому краю используй флаг `-`, как и для чисел.	`fmt.Printf("width5: \|%-6s\|%-6s\|\n", "foo", "b")`
До сих пор мы использовали `Printf`, который выводит форматированную строку в `os.Stdout`. `Sprintf` форматирует и возвращает строку, не выводя её никуда.	`s := fmt.Sprintf("sprintf: a %s", "string") fmt.Println(s)`
Можно форматировать и выводить в любой `io.Writer`, а не только в `os.Stdout`, с помощью `Fprintf`.	`fmt.Fprintf(os.Stderr, "io: an %s\n", "error") }`

$ go run string-formatting.go
struct1: {1 2}
struct2: {x:1 y:2}
struct3: main.point{x:1, y:2}
type: main.point
bool: true
int: 123
bin: 1110
char: !
hex: 1c8
float1: 78.900000
float2: 1.234000e+08
float3: 1.234000E+08
str1: "string"
str2: "\"string\""
str3: 6865782074686973
pointer: 0xc0000ba000
width1: |    12|   345|
width2: |  1.20|  3.45|
width3: |1.20  |3.45  |
width4: |   foo|     b|
width5: |foo   |b     |
sprintf: a string
io: an error

Далее: Текстовые шаблоны.