...

パッケージ fmt

import "fmt"
概要
目次

概要 ▾

fmt パッケージは C の printf と scanf に似たフォーマット I/O 関数を実装します。フォーマット形式は C から取られていますが,よりシンプルになっています。

表示

動詞 :

一般:

%v	デフォルトフォーマットの値。
	構造体を表示する場合,プラスフラグ (%+v) はフィールド名を追加します。
%#v	値の Go 構文表現
%T	値の型の Go 構文表現
%%	文字通りのパーセント記号。値を消費しません。

ブール値:

%t	true または false

整数値:

%b	2 進数
%c	対応する Unicode コードポイントで表される文字
%d	10 進数
%o	8 進数
%O	0o が接頭辞としてつく 8 進数
%q	Go 構文で安全にエスケープされた単一引用符文字リテラル
%x	16 進数, a-f は小文字。
%X	16 進数, A-F は大文字。
%U	Unicode 形式; U+1234; "U+%04X" と同じ。

浮動小数点数と複素数の構成要素:

%b 指数が 2 の累乗で,小数のない科学的表記法。
	strconv.FormatFloat の 'b' フォーマット。
	例: -123456p-78
%e 科学的表記法。例: -1.234456e+78
%E 科学的表記法。例: -1.234456E+78
%f 指数のない小数。例: 123.456
%F %f と同義
%g 指数が大きい場合は %e,それ以外の場合は %f。精度については後述します。
%G 大きな指数の場合は %G,それ以外の場合は %F。
%x	16 進表記 (10 進数の 2 のべき乗)。例: -0x1.23abcp+20
%X	大文字の 16 進数表記。例: -0X1.23ABCP+20

文字列とバイトスライス (以下の動詞で同等に処理されます):

%s 文字列またはスライスの未解釈のバイト
%q 二重引用符で囲まれた文字列は Go 構文で安全にエスケープされます
%x 16 進数,小文字, 1 バイトあたり 2 文字
%X 16 進数,大文字, 1 バイトあたり 2 文字

スライス:

%p	16 進表記の 0 番目の要素のアドレス (先頭に 0x を付ける)

ポインター:

%p	16 進表記,先頭に 0x を付ける
%b, %d, %o, %x, および %X 動詞もポインターを処理し,
値が整数であるかのようにフォーマットします。

%v のデフォルトのフォーマットは,次のとおりです。

bool:                    %t
int, int8 など:           %d
uint, uint8 など:         %d。%#v の場合は %#x
float32, complex64 など:  %g
string:                  %s
chan:                    %p
ポインタ:                 %p

複合オブジェクトの場合,要素はこれらの規則を再帰的に使用して,次のように配置されて表示されます。

構造体:              {field0 field1 ...}
配列,スライス:        [elem0 elem1 ...]
マップ:               map[key1:value1 key2:value2 ...]
上へのポインタ:        &{}, &[], &map[]

幅は動詞の直前のオプションの 10 進数で指定されます。 存在しない場合,幅は値を表すのに必要なものになります。 精度は (オプションの) 幅の後にピリオドとそれに続く 10 進数によって指定されます。 ピリオドが存在しない場合は,デフォルトの精度が使用されます。 後続の数字のないピリオドは,精度ゼロを指定します。 例:

%f     デフォルト幅,デフォルト精度
%9f    幅 9 ,デフォルト精度
%.2f   デフォルト幅,精度 2
%9.2f  幅 9 ,精度 2
%9.f   幅 9 ,精度 0

幅と精度は, Unicode コードポイント,つまりルーン文字の単位で測られます。 (これは,単位が常にバイト単位で測られる C の printf とは異なります。) どちらか一方または両方のフラグを文字 '*' に置き換えて,次のオペランド (フォーマットするオペランドの前) から値を取得することができます。 これは int 型でなければなりません。

ほとんどの値では, width は出力するルーンの最小数で,必要に応じてフォーマット済み形式にスペースを埋めます。

ただし,文字列,バイトスライス,およびバイト配列の場合,精度は書式設定される入力の長さを制限し (出力のサイズではない) ,必要に応じて切り捨てます。 通常はルーン文字で測られますが,これらの型では %x または %X フォーマットでフォーマットされた場合,バイト単位で測定されます。

浮動小数点値の場合,幅はフィールドの最小幅を設定し,精度は小数点以下の桁数を設定します (ただし,必要に応じて) 。 ただし,%g/%G 精度では最大有効桁数を設定します (末尾のゼロは削除されます) 。 たとえば, 12.345 の場合,フォーマット %6.3f は 12.345 を表示し,%.3g は 12.3 を表示します。 %e, %f, および %#g のデフォルトの精度は 6 です。 %g の場合,値を一意に識別するために必要な最小桁数です。

複素数の場合,幅と精度は 2 つの要素に独立して適用され,結果は括弧で囲まれるので, 1.2+3.4i に %f を適用すると (1.200000+3.400000i) が生成されます。

その他のフラグ:

+	数値には常に符号を付けます。
	%q (%+q) で ASCII のみの出力を保証します。
-	左側ではなく右側にスペースを埋め込む (フィールドを左寄せにします)
#	alternate format: add leading 0b for binary (%#b), 0 for octal (%#o),
	0x or 0X for hex (%#x or %#X); suppress 0x for %p (%#p);
	for %q, print a raw (backquoted) string if strconv.CanBackquote
	returns true;
	always print a decimal point for %e, %E, %f, %F, %g and %G;
	do not remove trailing zeros for %g and %G;
	write e.g. U+0078 'x' if the character is printable for %U (%#U).
' '	(スペース) は,数字 (% d) の場合,符号用のスペースを空けます。
	16 進数 (% x, % X) の場合,文字列やスライスを表示するバイトの間にスペースを入れます。
0	スペースではなく 0 で先行ゼロをパディングします。
	数字の場合,符号の後にパディングします。

フラグは,それを期待していない動詞では無視されます。 たとえば,代替の 10 進数形式はないため,%#d と%d は同じように動作します。

各 Printf のような関数には,フォーマットを取らず,すべてのオペランドについて %v を指定するのと同じ意味の Print 関数もあります。 別関数 Println は,オペランドの間に空白を挿入して,改行を追加します。

動詞に関係なく,オペランドがインターフェース値の場合は,インターフェース自体ではなく内部の具象値が使用されます。 そのため,

var i interface{} = 23
fmt.Printf("%v\n", i)

は 23 を表示します。

動詞 %T および %p を使用して表示された場合を除き,特定のインターフェースを実装するオペランドには,特別なフォーマットの考慮事項が適用されます。 適用順に:

1. オペランドが reflect.Value である場合,オペランドはそれが保持する具象値に置き換えられ,表示は次の規則で続行されます。

2. オペランドが Formatter インターフェースを実装している場合は,それが呼び出されます。 Formatter は書式設定を細かく制御できます。

3. %v 動詞が # フラグ (%#v) とともに使用され,オペランドが GoStringer インターフェースを実装している場合は,それが呼び出されます。

フォーマット (Println などでは暗黙的に %v) が文字列 (%s %q %v %x %X) で有効である場合,次の 2 つの規則が適用されます。

4. オペランドが error インターフェースを実装している場合は, Error メソッドが呼び出されてオブジェクトを文字列に変換します。 その後,動詞のリクエストに応じてフォーマットされます (存在する場合) 。

5. オペランドがメソッド String() string を実装している場合,そのメソッドはオブジェクトを文字列に変換するために呼び出され,動詞のリクエストに応じてフォーマットされます (存在する場合)。

スライスや構造体などの複合オペランドの場合,フォーマットは各オペランドの要素に再帰的に適用され,オペランド全体には適用されません。 したがって,%q は文字列のスライスの各要素を引用符で囲み,%6.2f は浮動小数点配列の各要素の書式を制御します。

ただし,文字列のような動詞 (%s %q %x %X) を使用してバイトスライスを表示すると,文字列と同じように 1 つの項目として扱われます。

以下のような場合に再帰を避けるには,

type X string
func (x X) String() string { return Sprintf("<%s>", x) }

再帰の前に値を変換します。

func (x X) String() string { return Sprintf("<%s>", string(x)) }

その型に String メソッドがある場合,それ自体を要素として含むスライスなどの自己参照データ構造によっても,無限再帰が引き起こされることがあります。 しかし,そのような状況はまれであり,パッケージは保護しません。

構造体を表示するとき, fmt は,エクスポートされていないフィールドに対して Error や String などのフォーマットメソッドを呼び出すことはできません。

明示的な引数インデックス:

Printf, Sprintf ,および Fprintf では,デフォルトの動作は,各フォーマット設定動詞が引数を一つずつフォーマットすることです。 ただし,動詞の直前の表記 [n] は,1 で始まるインデックスで n 番目の引数を代わりにフォーマットすることを示しています。 幅または精度の '*' の前に,同じ表記で,値を保持している引数インデックスを選択します。 大括弧で囲まれた式 [n] を処理した後は,特に指示がない限り,後続の動詞は引数 n+1, n+2 などを使用します。

たとえば,

fmt.Sprintf("%[2]d %[1]d\n", 11, 22)

は "22 11" になりますが,

fmt.Sprintf("%[3]*.[2]*[1]f", 12.0, 2, 6)

fmt.Sprintf("%6.2f", 12.0)

と等価であり, " 12.00" となります。 明示的なインデックスは後続の動詞に影響を与えるため,この表記法を使用して,繰り返して表示したい最初の引数のインデックスをリセットすることで同じ値を複数回表示できます。

fmt.Sprintf("%d %d %#[1]x %#x", 16, 17)

は "16 17 0x10 0x11" になります。

フォーマットエラー:

%d への文字列渡しなど,動詞に無効な引数が与えられた場合,生成された文字列には,次の例のように問題の説明が含まれます。

Wrong type or unknown verb: %!verb(type=value)
	Printf("%d", "hi"):        %!d(string=hi)
Too many arguments: %!(EXTRA type=value)
	Printf("hi", "guys"):      hi%!(EXTRA string=guys)
Too few arguments: %!verb(MISSING)
	Printf("hi%d"):            hi%!d(MISSING)
Non-int for width or precision: %!(BADWIDTH) or %!(BADPREC)
	Printf("%*s", 4.5, "hi"):  %!(BADWIDTH)hi
	Printf("%.*s", 4.5, "hi"): %!(BADPREC)hi
Invalid or invalid use of argument index: %!(BADINDEX)
	Printf("%*[2]d", 7):       %!d(BADINDEX)
	Printf("%.[2]d", 7):       %!d(BADINDEX)

すべてのエラーは文字列 "%!" で始まります。 時には 1 つの文字 (動詞) が続き,括弧で囲まれた説明で終わります。

Error または String メソッドが表示ルーチンによって呼び出されたときにパニックをトリガーした場合, fmt パッケージはパニックからのエラーメッセージを再フォーマットし,それが fmt パッケージを介したものであることを示すメッセージで装飾します。 たとえば, String メソッドが panic("bad") を呼び出すと,フォーマットされたメッセージはこのようになります

%!s(PANIC=bad)

%!s は,障害が発生したときに使用されていた表示動詞を示しているだけです。 しかし,パニックが Error または String メソッドへの nil レシーバによって引き起こされている場合,出力は装飾されていない文字列 "<nil>" です。

スキャン

同様の一連の関数が,フォーマットされたテキストをスキャンして値を生成します。 Scan, Scanf, Scanln は os.Stdin から読み取ります。 Fscan, Fscanf, Fscanln は,指定された io.Reader から読み取ります。 Sscan, Sscanf, Sscanln は引数文字列から読み取ります。

Scan, Fscan, Sscan は入力の改行をスペースとして扱います。

Scanln, Fscanln, Sscanln は改行でスキャンを停止します。アイテムの後に改行または EOF が続く必要があります。

Scanf, Fscanf, Sscanf は, Printf のフォーマット文字列と同様に,フォーマット文字列に従って引数を解析します。 以下のテキストで, "スペース" は改行を除くすべての Unicode 空白文字を意味します。

フォーマット文字列では,% 文字で始まる動詞は入力を消費して解析します。 これらの動詞については,後で詳しく説明します。 フォーマット内の %,スペース,または改行以外の文字は,その入力文字を正確に消費します。 その文字は存在する必要があります。 フォーマット文字列中の,0 個以上のスペースのあとの改行は,入力内の 0 個以上のスペースとそれに続く 1 つの改行または入力の終わりを消費します。 フォーマット文字列中の,改行に続くスペースは,入力で 0 個以上のスペースを消費します。 それ以外の場合,フォーマット文字列内の 1 つ以上のスペースは,入力内で可能な限り多くのスペースを消費します。 フォーマット文字列内のスペースのまとまりが改行の隣でない限り,そのまとまりは入力から少なくとも 1 つのスペースを消費するか,入力の終わりを見つける必要があります。

スペースと改行の扱いは C の scanf ファミリの扱いとは異なります。 C では,改行は他のスペースと同様として扱われ,フォーマット文字列内のスペースのまとまりで,入力にスペースが見つからなくてもエラーにはなりません。

動詞は Printf の動詞と同じように動作します。 たとえば,%x は整数を 16 進数としてスキャンし,%v は値の既定の表現形式をスキャンします。 Printf 動詞 %p と %T ,およびフラグ # と + は実装されていません。 浮動小数点または複素数値の場合,すべてのフォーマット動詞 ((%b %e %E %f %F %g %G %x %X %v) はすべて同等で, 10 進表記と 16 進表記の両方(例: "2.3e+7", "0x4.5p-8") およびアンダースコアで区切られた数字(例: "3.14159_26535_89793") を受け入れます。

動詞によって処理される入力は暗黙のうちにスペースで区切られます。 %c を除くすべての動詞は残りの入力から先頭のスペースをまず破棄し,%s 動詞 (および %v 文字列の読み込み) は最初のスペースあるいは改行文字で入力の消費を停止します。

よく知られている基数設定プレフィックス 0b (2 進数) , 0o および 0 (8 進数) ,および 0x (16 進数) は,数字区切りアンダースコアのように,フォーマットなしまたは %v 動詞で整数をスキャンする場合に使用できます。

幅は入力テキスト内で解釈されますが,精度を指定してスキャンするための構文はありません (%5.2f はありません,%5f のみ) 。 幅が指定されている場合,先行スペースが切り捨てられた後に適用され,動詞を満たすために読み取るルーンの最大数を指定します。 たとえば,

Sscanf(" 1234567 ", "%5s%d", &s, &i)

は s を "12345" に, i を 67 に設定し,

Sscanf(" 12 34 567 ", "%5s%d", &s, &i)

は s を "12" に, i を 34 に設定します。

すべてのスキャン関数で,復帰改行とそれに続く改行は,改行として扱われます (\r\n は \n と同じ意味です) 。

すべてのスキャン関数で,オペランドがメソッド Scan を実装 (つまり Scanner インターフェースを実装) している場合,そのメソッドはそのオペランドのテキストをスキャンするために使用されます。 また,スキャンされた引数の数が渡された引数の数より少ない場合,エラーが返されます。

スキャンされるすべての引数は,基本型へのポインタまたは Scanner インターフェースの実装のいずれかでなければなりません。

Scanf や Fscanf のように, Sscanf は入力全体を消費する必要はありません。 Sscanf がどれだけ使用したかを取得する方法はありません。

注: Fscan などは,返される入力を超えて 1 文字 (ルーン) を読み取ることができます。これは,スキャンルーチンを呼び出すループが入力の一部をスキップする可能性があることを意味します。 これは通常,入力値の間にスペースがない場合にのみ問題になります。 Fscan に渡されるリーダーが ReadRune を実装している場合,そのメソッドは文字の読み取りに使用されます。 リーダーが UnreadRune も実装している場合,そのメソッドはキャラクターを保存するために使用され,連続した呼び出しはデータを失いません。 ReadRune および UnreadRune メソッドをその機能のないリーダーにアタッチするには, bufio.NewReader を使用します。

例 (Formats)

これらの例は,フォーマット文字列を使用した表示の基本を示しています。 Printf , Sprintf ,および Fprintf はすべて,後続の引数のフォーマット方法を指定するフォーマット文字列を取ります。たとえば, %d("動詞" と呼ぶ) は,対応する引数を 10 進数で整数 (または整数のスライスなどの整数を含む何か) で出力するように指示します。動詞 %v('value' の 'v') は,常にデフォルトの形式で引数をフォーマットします。 Print または Println が表示する方法だけです。特別な動詞 %T ('T' for 'Type') は,値ではなく引数の型を出力します。例は完全ではありません。詳細については,パッケージのコメントを参照する。

コード:

// %v がデフォルトの形式,この場合は整数の 10 進数であり, %d で明示的にリクエストできることを示す基本的な例のセット。出力は, Println が生成するものです。
integer := 23
// これらはそれぞれ "23" (引用符なし) を表示します。
fmt.Println(integer)
fmt.Printf("%v\n", integer)
fmt.Printf("%d\n", integer)

// 特別な動詞 %T は,値ではなくアイテムの型を示します。
fmt.Printf("%T %T\n", integer, &integer)
// Result: int *int

// Println(x) は Printf("%v\n", x) と同じなので,次の例では Printf のみを使用します。それぞれが,整数や文字列など,特定の型の値をフォーマットする方法を示しています。各フォーマット文字列を %v で開始してデフォルトの出力を表示し,それに続いて 1 つ以上のカスタムフォーマットを使用します。

// ブール値は, %v または %t で "true" または "false" として出力されます。
truth := true
fmt.Printf("%v %t\n", truth, truth)
// Result: true true

// 整数は, %v と %d の 10 進数として,または %x の 16 進数, %o の 8 進数,または %b の 2 進数として表示されます。
answer := 42
fmt.Printf("%v %d %x %o %b\n", answer, answer, answer, answer, answer)
// Result: 42 42 2a 52 101010

// フロートには複数の形式があります。 %v と %g はコンパクトな表現を出力し, %f は小数点を出力し, %e は指数表記を使用します。ここで使用される形式 %6.2f は,浮動小数点値の外観を制御するために幅と精度を設定する方法を示しています。この場合, 6 は値の表示テキストの合計幅 (出力に余分なスペースがあることに注意する) , 2 は表示する小数点以下の桁数です。
pi := math.Pi
fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
// Result: 3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00

// 複素数は,虚数部の後に "i" が付いた,フロートの括弧で囲まれたペアとしてフォーマットされます。
point := 110.7 + 22.5i
fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)
// Result: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)

// ルーン文字は整数ですが, %c で表示すると,その Unicode 値の文字が表示されます。 %q 動詞は,それらを引用文字として, %U を 16 進 Unicode コードポイントとして, %#U をコードポイントおよびルーン文字が表示可能な場合は引用可能な表示可能フォームとして表示します。
smile := '😀'
fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
// Result: 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'

// 文字列は, %v と %s をそのまま, %q を引用符付き文字列, %#q を逆引用符付き文字列としてフォーマットします。
placeholders := `foo "bar"`
fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
// Result: foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`

// %v でフォーマットされたマップは,デフォルトのフォーマットでキーと値を表示します。 %#v フォーム (# はこのコンテキストでは "フラグ" と呼ばれます) は, Go ソース形式でマップを表示します。マップは一貫した順序で表示され,キーの値でソートされます。
isLegume := map[string]bool{
    "peanut":    true,
    "dachshund": false,
}
fmt.Printf("%v %#v\n", isLegume, isLegume)
// Result: map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}

// %v でフォーマットされた構造体は,デフォルト値でフィールド値を表示します。 %+v 形式は名前でフィールドを表示し, %#v は Go ソース形式で構造体をフォーマットします。
person := struct {
    Name string
    Age  int
}{"Kim", 22}
fmt.Printf("%v %+v %#v\n", person, person, person)
// Result: {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}

// ポインターのデフォルトの形式は,アンパサンドが前にある基本的な値を示します。 %p 動詞は,ポインター値を 16 進数で出力します。ここでは, %p への引数に型付き nil を使用します。これは, nil 以外のポインターの値が実行ごとに変わるためです。コメントアウトされた Printf を実行して確認する。
pointer := &person
fmt.Printf("%v %p\n", pointer, (*int)(nil))
// Result: &{Kim 22} 0x0
// fmt.Printf("%v %p\n", pointer, pointer)
// Result: &{Kim 22} 0x010203 // See comment above.

// 配列とスライスは,各要素にフォーマットを適用することによりフォーマットされます。
greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
fmt.Printf("%v %q\n", greats, greats)
// Result: [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]

kGreats := greats[:3]
fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
// Result: [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}

// バイトスライスは特別です。 %d のような整数動詞は,その形式で要素を出力します。 %s および %q 形式は,スライスを文字列のように扱います。 %x 動詞には,バイト間にスペースを挿入するスペースフラグのある特別な形式があります。
cmd := []byte("a⌘")
fmt.Printf("%v %d %s %q %x % x\n", cmd, cmd, cmd, cmd, cmd, cmd)
// Result: [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98

// Stringer を実装する型は,文字列と同じように表示されます。 Stringers は文字列を返すため, %q などの文字列固有の動詞を使用して表示できます。
now := time.Unix(123456789, 0).UTC() // time.Time は fmt.Stringer を実装します。
fmt.Printf("%v %q\n", now, now)
// Result: 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

出力:

23
23
23
int *int
true true
42 42 2a 52 101010
3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00
(110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
{Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
&{Kim 22} 0x0
[Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
[Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
[97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

例 (Printers)

Print, Println ,および Printf は,引数を別々にレイアウトします。この例では,それらの動作を比較できます。 Println は,表示するアイテムの間に常に空白を追加しますが, Print は,文字列以外の引数の間にのみ空白を追加し, Printf は指定されたとおりに実行します。 Sprint, Sprintln, Sprintf, Fprint, Fprintln ,および Fprintf は,ここに示す対応する Print, Println ,および Printf 関数と同じように動作します。

コード:

a, b := 3.0, 4.0
h := math.Hypot(a, b)

// どちらも文字列でない場合, Print は引数の間に空白を挿入します。出力に改行は追加されないため,明示的に追加します。
fmt.Print("The vector (", a, b, ") has length ", h, ".\n")

// Println は常に引数の間にスペースを挿入するため,この場合, Print と同じ出力を生成するために使用することはできません。出力には余分なスペースがあります。また, Println は常に改行を出力に追加します。
fmt.Println("The vector (", a, b, ") has length", h, ".")

// Printf は完全な制御を提供しますが,より複雑です。出力に改行は追加されないため,書式指定子文字列の末尾に明示的に改行を追加します。
fmt.Printf("The vector (%g %g) has length %g.\n", a, b, h)

出力:

The vector (3 4) has length 5.
The vector ( 3 4 ) has length 5 .
The vector (3 4) has length 5.

func Errorf

func Errorf(format string, a ...interface{}) error

Errorf はフォーマット指定子に従ってフォーマットし,error を満たす値として文字列を返します。

エラーオペランドがあり,書式指定子に %w 動詞が含まれている場合,返されるエラーは,オペランドを返す Unwrap メソッドを実装します。 複数の %w 動詞を含めること,またはエラーインターフェースを実装しないオペランドを指定することは無効です。 それ以外の場合, %w 動詞は %v の同義語です。

Errorf 関数を使用すると,フォーマット機能を使用して説明的なエラーメッセージを作成できます。

コード:

const name, id = "bueller", 17
err := fmt.Errorf("user %q (id %d) not found", name, id)
fmt.Println(err.Error())

出力:

user "bueller" (id 17) not found

func Fprint

func Fprint(w io.Writer, a ...interface{}) (n int, err error)

Fprint は,オペランドにデフォルトのフォーマットを使用して w に書き込みます。 どちらも文字列でない場合は,オペランド間にスペースが追加されます。 書き込まれたバイト数と発生した書き込みエラーを返します。

コード:

const name, age = "Kim", 22
n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")

// Fprint からの n および err の戻り値は,内部の io.Writer によって返される値です。
if err != nil {
    fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
}
fmt.Print(n, " bytes written.\n")

出力:

Kim is 22 years old.
21 bytes written.

func Fprintf

func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)

Fprintf はフォーマット指定子に従ってフォーマットし, w に書き込みます。 書き込まれたバイト数と発生した書き込みエラーを返します。

コード:

const name, age = "Kim", 22
n, err := fmt.Fprintf(os.Stdout, "%s is %d years old.\n", name, age)

// Fprintf からの n および err の戻り値は,内部の io.Writer によって返される値です。
if err != nil {
    fmt.Fprintf(os.Stderr, "Fprintf: %v\n", err)
}
fmt.Printf("%d bytes written.\n", n)

出力:

Kim is 22 years old.
21 bytes written.

func Fprintln

func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

Fprintln は,オペランドにデフォルトのフォーマットを使用してフォーマットし, w に書き込みます。 オペランドの間には常にスペースが追加され,最後に改行が追加されます。 書き込まれたバイト数と発生した書き込みエラーを返します。

コード:

const name, age = "Kim", 22
n, err := fmt.Fprintln(os.Stdout, name, "is", age, "years old.")

// Fprintln からの n および err の戻り値は,内部の io.Writer によって返される値です。
if err != nil {
    fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)
}
fmt.Println(n, "bytes written.")

出力:

Kim is 22 years old.
21 bytes written.

func Fscan

func Fscan(r io.Reader, a ...interface{}) (n int, err error)

Fscan は, r から読み取られたテキストをスキャンし,スペースで区切られた連続した値を連続した引数に格納します。 改行はスペースとして数えます。 正常にスキャンされたアイテムの数を返します。 それが引数の数より少ない場合, err はその理由を報告します。

func Fscanf

func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)

Fscanf は, r から読み取られたテキストをスキャンし,フォーマットで決定されたとおりに,スペースで区切られた連続した値を連続した引数に格納します。 正常に解析されたアイテムの数を返します。 入力の改行はフォーマットの改行と一致しなければなりません。

コード:

var (
    i int
    b bool
    s string
)
r := strings.NewReader("5 true gophers")
n, err := fmt.Fscanf(r, "%d %t %s", &i, &b, &s)
if err != nil {
    fmt.Fprintf(os.Stderr, "Fscanf: %v\n", err)
}
fmt.Println(i, b, s)
fmt.Println(n)

出力:

5 true gophers
3

func Fscanln

func Fscanln(r io.Reader, a ...interface{}) (n int, err error)

Fscanln は Fscan と似ていますが,改行でスキャンを停止し,最後の項目の後に改行または EOF がなければなりません。

コード:

s := `dmr 1771 1.61803398875
    ken 271828 3.14159`
r := strings.NewReader(s)
var a string
var b int
var c float64
for {
    n, err := fmt.Fscanln(r, &a, &b, &c)
    if err == io.EOF {
        break
    }
    if err != nil {
        panic(err)
    }
    fmt.Printf("%d: %s, %d, %f\n", n, a, b, c)
}

出力:

3: dmr, 1771, 1.618034
3: ken, 271828, 3.141590

func Print

func Print(a ...interface{}) (n int, err error)

Print は,オペランドのデフォルトフォーマットを使用してフォーマットし,標準出力に書き込みます。 どちらも文字列でない場合は,オペランド間にスペースが追加されます。 書き込まれたバイト数と発生した書き込みエラーを返します。

コード:

const name, age = "Kim", 22
fmt.Print(name, " is ", age, " years old.\n")

// Print によって返されるエラーを心配しないのが一般的です。

出力:

Kim is 22 years old.

func Printf

func Printf(format string, a ...interface{}) (n int, err error)

Printf はフォーマット指定子に従ってフォーマットし,標準出力に書き出します。 書き込まれたバイト数と発生した書き込みエラーを返します。

コード:

const name, age = "Kim", 22
fmt.Printf("%s is %d years old.\n", name, age)

// Printf から返されるエラーを心配しないのが一般的です。

出力:

Kim is 22 years old.

func Println

func Println(a ...interface{}) (n int, err error)

Println は,オペランドのデフォルトフォーマットを使用してフォーマットし,標準出力に書き込みます。 オペランドの間には常にスペースが追加され,最後に改行が追加されます。 書き込まれたバイト数と発生した書き込みエラーを返します。

コード:

const name, age = "Kim", 22
fmt.Println(name, "is", age, "years old.")

// Println によって返されるエラーを心配しないのが一般的です。

出力:

Kim is 22 years old.

func Scan

func Scan(a ...interface{}) (n int, err error)

Scan は標準入力から読み込まれたテキストをスキャンし,連続したスペース区切りの値を連続した引数に格納します。 改行はスペースとして数えます。 正常にスキャンされたアイテムの数を返します。 それが引数の数より少ない場合, err はその理由を報告します。

func Scanf

func Scanf(format string, a ...interface{}) (n int, err error)

Scanf は,標準入力から読み取られたテキストをスキャンし,フォーマットで決定されたとおりに,スペースで区切られた連続した値を連続した引数に格納します。 正常にスキャンされたアイテムの数を返します。 それが引数の数より少ない場合, err はその理由を報告します。 入力の改行はフォーマットの改行と一致しなければなりません。 1 つの例外: 動詞 %c は,スペース (またはタブなど) や改行であっても,入力内の次のルーン文字を常にスキャンします。

func Scanln

func Scanln(a ...interface{}) (n int, err error)

Scanln は Scan に似ていますが,改行でスキャンを停止し,最後の項目の後に改行または EOF がなければなりません。

func Sprint

func Sprint(a ...interface{}) string

Sprint は,オペランドにデフォルトのフォーマットを使用してフォーマットし,結果の文字列を返します。 どちらも文字列でない場合は,オペランド間にスペースが追加されます。

コード:

const name, age = "Kim", 22
s := fmt.Sprint(name, " is ", age, " years old.\n")

io.WriteString(os.Stdout, s) // 簡単にするためにエラーを無視します。

出力:

Kim is 22 years old.

func Sprintf

func Sprintf(format string, a ...interface{}) string

Sprintf はフォーマット指定子に従ってフォーマットし,結果の文字列を返します。

コード:

const name, age = "Kim", 22
s := fmt.Sprintf("%s is %d years old.\n", name, age)

io.WriteString(os.Stdout, s) // 簡単にするためにエラーを無視します。

出力:

Kim is 22 years old.

func Sprintln

func Sprintln(a ...interface{}) string

Sprintln はそのオペランドにデフォルトのフォーマットを使用してフォーマットし,結果の文字列を戻します。 オペランドの間には常にスペースが追加され,最後に改行が追加されます。

コード:

const name, age = "Kim", 22
s := fmt.Sprintln(name, "is", age, "years old.")

io.WriteString(os.Stdout, s) // 簡単にするためにエラーを無視します。

出力:

Kim is 22 years old.

func Sscan

func Sscan(str string, a ...interface{}) (n int, err error)

Sscan は引数文字列をスキャンし,連続したスペース区切り値を連続した引数に格納します。 改行はスペースとして数えます。 正常にスキャンされたアイテムの数を返します。 それが引数の数より少ない場合, err はその理由を報告します。

func Sscanf

func Sscanf(str string, format string, a ...interface{}) (n int, err error)

Sscanf は引数の文字列をスキャンし,フォーマットで決定されたとおりに,スペースで区切られた連続した値を連続した引数に格納します。 正常に解析されたアイテムの数を返します。 入力の改行はフォーマットの改行と一致しなければなりません。

コード:

var name string
var age int
n, err := fmt.Sscanf("Kim is 22 years old", "%s is %d years old", &name, &age)
if err != nil {
    panic(err)
}
fmt.Printf("%d: %s, %d\n", n, name, age)

出力:

2: Kim, 22

func Sscanln

func Sscanln(str string, a ...interface{}) (n int, err error)

Sscanln は Sscan と似ていますが,改行でスキャンを停止し,最後の項目の後に改行または EOF がなければなりません。

type Formatter

Formatter は,カスタムフォーマッタを使った値によって実装されるインターフェースです。 Format の実装は,その出力を生成するために Sprint(f) または Fprint(f) などを呼び出すことができます。

type Formatter interface {
    Format(f State, c rune)
}

type GoStringer

GoStringer は,その値の Go 構文を定義する GoString メソッドを持つ任意の値によって実装されます。 GoString メソッドは,オペランドとして渡された値を %#v フォーマットに出力するために使用されます。

type GoStringer interface {
    GoString() string
}

コード:

package fmt_test

import (
    "fmt"
)

// Address には City, State と Country があります。
type Address struct {
    City    string
    State   string
    Country string
}

// Person には Name, Age と Address があります。
type Person struct {
    Name string
    Age  uint
    Addr *Address
}

// GoString は, Person が GoStringer インターフェースを満たすようにします。
// 返り値は, Person 構造体を生成するのに使える正しい Go コードです。
func (p Person) GoString() string {
    if p.Addr != nil {
        return fmt.Sprintf("Person{Name: %q, Age: %d, Addr: &Address{City: %q, State: %q, Country: %q}}", p.Name, int(p.Age), p.Addr.City, p.Addr.State, p.Addr.Country)
    }
    return fmt.Sprintf("Person{Name: %q, Age: %d}", p.Name, int(p.Age))
}

func ExampleGoStringer() {
    p1 := Person{
        Name: "Warren",
        Age:  31,
        Addr: &Address{
            City:    "Denver",
            State:   "CO",
            Country: "U.S.A.",
        },
    }
    // GoString() が実装されていなかったなら,`fmt.Printf("%#v", p1)` の出力は以下のようになります。
    // Person{Name:"Warren", Age:0x1f, Addr:(*main.Address)(0x10448240)}
    fmt.Printf("%#v\n", p1)

    p2 := Person{
        Name: "Theia",
        Age:  4,
    }
    // GoString() が実装されていなかったなら,`fmt.Printf("%#v", p2)` の出力は以下のようになります。
    // Person{Name:"Theia", Age:0x4, Addr:(*main.Address)(nil)}
    fmt.Printf("%#v\n", p2)

    // Output:
    // Person{Name: "Warren", Age: 31, Addr: &Address{City: "Denver", State: "CO", Country: "U.S.A."}}
    // Person{Name: "Theia", Age: 4}
}

type ScanState

ScanState は,カスタムスキャナに渡されたスキャナの状態を表します。 スキャナは,一度に 1 つずつスキャンを実行するか,または ScanState に次のスペース区切りのトークンを検出するように依頼します。

type ScanState interface {
    // ReadRune は入力から次のルーン文字 (Unicode コードポイント) を読み取ります。
    // Scanln, Fscanln ,または Sscanln 中に呼び出された場合, ReadRune() は最初の '\n' を返した後,または指定された幅を超えて読み取りを行ったときに EOF を返します。
    ReadRune() (r rune, size int, err error)
    // UnreadRune は,次の ReadRune の呼び出しで同じルーンを返します。
    UnreadRune() error
    // SkipSpace は入力内のスペースをスキップします。
    // 改行は実行される操作に対して適切に扱われます。
    // 詳しくは,パッケージの資料を参照してください。
    SkipSpace()
    // skipSpace が true の場合,トークンは入力内のスペースをスキップし, f(c) を満たす Unicode コードポイント c のランを返します。
    // f が nil の場合, !unicode.IsSpace(c) が使用されます。
    // つまり,トークンはスペース以外の文字を保持します。
    // 改行は実行される操作に対して適切に扱われます。
    // 詳しくは,パッケージの資料を参照してください。
    // 返されたスライスは, Token への次の呼び出し, ScanState を入力として使用した Scan 関数の呼び出し,または呼び出し側の Scan メソッドが戻ったときに上書きされる可能性がある共有データを指します。
    Token(skipSpace bool, f func(rune) bool) (token []byte, err error)
    // Width は幅オプションの値とそれが設定されているかどうかを返します。
    // 単位は Unicode コードポイントです。
    Width() (wid int, ok bool)
    // ReadRune はインターフェースによって実装されているため, Read はスキャンルーチンによって呼び出されるべきではなく, ScanState の有効な実装は常に Read からエラーを返すようにすることができます。
    Read(buf []byte) (n int, err error)
}

type Scanner

Scanner は,入力から値の表現をスキャンし,結果をレシーバに格納する Scan メソッドを持つ任意の値によって実装されます。 有用であるためには,レシーバはポインタでなければなりません。 Scan メソッドは,それを実装する Scan, Scanf, または Scanln の引数に対して呼び出されます。

type Scanner interface {
    Scan(state ScanState, verb rune) error
}

type State

State は,カスタムフォーマッタに渡されるプリンタの状態を表します。 io.Writer インターフェースへのアクセスに加えて,オペランドのフォーマット指定子のフラグとオプションに関する情報を提供します。

type State interface {
    // Write は,表示するためにフォーマットされた出力を発行するために呼び出す関数です。
    Write(b []byte) (n int, err error)
    // Width は幅オプションの値とそれが設定されているかどうかを返します。
    Width() (wid int, ok bool)
    // Precision は精度オプションの値と,それが設定されているかどうかを返します。
    Precision() (prec int, ok bool)

    // Flag は,フラグ c (文字) が設定されているかどうかを報告します。
    Flag(c int) bool
}

type Stringer

Stringer は, String メソッドを持つ任意の値によって実装されます。 このメソッドは,その値の "ネイティブ" フォーマットを定義します。 String メソッドは,オペランドとして渡された値を,文字列を受け入れる形式または Print などの書式なしプリンタに表示するために使用されます。

type Stringer interface {
    String() string
}

コード:

package fmt_test

import (
    "fmt"
)

// Animal には動物を表す Name と Age があります。
type Animal struct {
    Name string
    Age  uint
}

// String は, Animal が Stringer インターフェースを満たすようにします。
func (a Animal) String() string {
    return fmt.Sprintf("%v (%d)", a.Name, a.Age)
}

func ExampleStringer() {
    a := Animal{
        Name: "Gopher",
        Age:  2,
    }
    fmt.Println(a)
    // Output: Gopher (2)
}