Golang における文字列フォーマットの基礎

はじめに

この実験では、Golang の文字列フォーマットに関する知識をテストすることを目的としています。さまざまなフォーマット指定子を使用して、整数、浮動小数点数、文字列、構造体などのさまざまな型のデータをフォーマットする必要があります。

文字列フォーマット

Golang でさまざまなフォーマット指定子を使用して、さまざまな型のデータをフォーマットする必要があります。

• データをフォーマットするには、fmt パッケージを使用する必要があります。
• 各データ型に対して正しいフォーマット指定子を使用する必要があります。
• 整数、浮動小数点数、文字列、構造体をフォーマットできる必要があります。
• 出力の幅と精度を制御できる必要があります。
• 出力を左寄せまたは右寄せできる必要があります。

$ 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

以下に完全なコードがあります。

// Go offers excellent support for string formatting in
// the `printf` tradition. Here are some examples of
// common string formatting tasks.

package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {

    // Go offers several printing "verbs" designed to
    // format general Go values. For example, this prints
    // an instance of our `point` struct.
    p := point{1, 2}
    fmt.Printf("struct1: %v\n", p)

    // If the value is a struct, the `%+v` variant will
    // include the struct's field names.
    fmt.Printf("struct2: %+v\n", p)

    // The `%#v` variant prints a Go syntax representation
    // of the value, i.e. the source code snippet that
    // would produce that value.
    fmt.Printf("struct3: %#v\n", p)

    // To print the type of a value, use `%T`.
    fmt.Printf("type: %T\n", p)

    // Formatting booleans is straight-forward.
    fmt.Printf("bool: %t\n", true)

    // There are many options for formatting integers.
    // Use `%d` for standard, base-10 formatting.
    fmt.Printf("int: %d\n", 123)

    // This prints a binary representation.
    fmt.Printf("bin: %b\n", 14)

    // This prints the character corresponding to the
    // given integer.
    fmt.Printf("char: %c\n", 33)

    // `%x` provides hex encoding.
    fmt.Printf("hex: %x\n", 456)

    // There are also several formatting options for
    // floats. For basic decimal formatting use `%f`.
    fmt.Printf("float1: %f\n", 78.9)

    // `%e` and `%E` format the float in (slightly
    // different versions of) scientific notation.
    fmt.Printf("float2: %e\n", 123400000.0)
    fmt.Printf("float3: %E\n", 123400000.0)

    // For basic string printing use `%s`.
    fmt.Printf("str1: %s\n", "\"string\"")

    // To double-quote strings as in Go source, use `%q`.
    fmt.Printf("str2: %q\n", "\"string\"")

    // As with integers seen earlier, `%x` renders
    // the string in base-16, with two output characters
    // per byte of input.
    fmt.Printf("str3: %x\n", "hex this")

    // To print a representation of a pointer, use `%p`.
    fmt.Printf("pointer: %p\n", &p)

    // When formatting numbers you will often want to
    // control the width and precision of the resulting
    // figure. To specify the width of an integer, use a
    // number after the `%` in the verb. By default the
    // result will be right-justified and padded with
    // spaces.
    fmt.Printf("width1: |%6d|%6d|\n", 12, 345)

    // You can also specify the width of printed floats,
    // though usually you'll also want to restrict the
    // decimal precision at the same time with the
    // width.precision syntax.
    fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.45)

    // To left-justify, use the `-` flag.
    fmt.Printf("width3: |%-6.2f|%-6.2f|\n", 1.2, 3.45)

    // You may also want to control width when formatting
    // strings, especially to ensure that they align in
    // table-like output. For basic right-justified width.
    fmt.Printf("width4: |%6s|%6s|\n", "foo", "b")

    // To left-justify use the `-` flag as with numbers.
    fmt.Printf("width5: |%-6s|%-6s|\n", "foo", "b")

    // So far we've seen `Printf`, which prints the
    // formatted string to `os.Stdout`. `Sprintf` formats
    // and returns a string without printing it anywhere.
    s := fmt.Sprintf("sprintf: a %s", "string")
    fmt.Println(s)

    // You can format+print to `io.Writers` other than
    // `os.Stdout` using `Fprintf`.
    fmt.Fprintf(os.Stderr, "io: an %s\n", "error")
}

まとめ

この実験では、Golang の文字列フォーマットに関する知識をテストしました。さまざまなフォーマット指定子を使用してさまざまな型のデータをフォーマットする方法、出力の幅と精度を制御する方法、および出力を左寄せまたは右寄せする方法を学びました。