fmt

package
v1.22.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 26, 2024 License: MIT Imports: 1 Imported by: 0

Documentation

Overview

Package fmtは、Cのprintfおよびscanfに類似した関数を使用してフォーマットされたI/Oを実装します。 フォーマット'verbs'は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の累乗の指数で表される10進数の科学的表記法。
    'b'フォーマットを使用したstrconv.FormatFloatの方法で、例：-123456p-78
%e	科学的表記法、例：-1.234456e+78
%E	科学的表記法、例：-1.234456E+78
%f	小数点を含むが指数を含まない表記法、例：123.456
%F	%fの同義語
%g	大きな指数の場合は%e、それ以外の場合は%f。精度については後述します。
%G	大きな指数の場合は%E、それ以外の場合は%F
%x	16進数表記法（2の累乗の10進数指数を含む）、例：-0x1.23abcp+20
%X	大文字の16進数表記法、例：-0X1.23ABCP+20

文字列とバイトスライス（これらの動詞では同等に扱われます）： 

%s	文字列またはスライスの解釈されていないバイト
%q	Go構文で安全にエスケープされたダブルクォート文字列
%x	16進数、小文字、1バイトあたり2文字
%X	16進数、大文字、1バイトあたり2文字

スライス： 

%p	16進表記法で表された0番目の要素のアドレス。先頭に0xが付きます。

ポインタ： 

%p	先頭に0xが付いた16進表記法
%b、%d、%o、%x、%Xの動詞は、ポインタでも整数と同じように機能し、
整数であるかのように値をフォーマットします。

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

bool:                    %t
int, int8 etc.:          %d
uint, uint8 etc.:        %d, %#vで出力された場合は%#x
float32, complex64, etc: %g
string:                  %s
chan:                    %p
pointer:                 %p

複合オブジェクトの場合、要素は再帰的にこれらのルールを使用して印刷され、次のようにレイアウトされます。 

struct:             {field0 field1 ...}
array, slice:       [elem0 elem1 ...]
maps:               map[key1:value1 key2:value2 ...]
上記へのポインタ：     &{}, &[], &map[]

幅は、動詞の直前にオプションの10進数で指定されます。 省略された場合、幅は値を表すために必要なものです。 精度は、（オプションの）幅の後に、ピリオドに続く10進数で指定されます。 ピリオドが存在しない場合、デフォルトの精度が使用されます。 後続の数字のないピリオドは、精度0を指定します。 例： 

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

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

ほとんどの値について、幅は出力する最小のルーン数であり、必要に応じてフォーマットされた形式をスペースでパディングします。

ただし、文字列、バイトスライス、およびバイト配列の場合、精度は入力をフォーマットするための長さを制限します（出力のサイズではありません）。 必要に応じて切り捨てます。通常、ルーンで測定されますが、これらの型を%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）を生成します。

整数コードポイントまたはルーン文字列（[]rune型）を%qでフォーマットする場合、 無効なUnicodeコードポイントは、strconv.QuoteRuneのようにUnicode置換文字U+FFFDに変更されます。

その他のフラグ： 

'+'	数値の場合は常に符号を印刷します。%qの場合はASCIIのみの出力を保証します（%+q）
'-'	左詰めにするために右側にスペースを詰めます（フィールドを左詰めにします）
'#'	代替フォーマット：2進数の場合は先頭に0bを追加します（%#b）、8進数の場合は0を追加します（%#o）、
	16進数の場合は0xまたは0Xを追加します（%#xまたは%#X）；%pの場合は0xを抑制します（%#p）；
	%qの場合は、strconv.CanBackquoteがtrueを返す場合は生の（バッククォートで囲まれた）文字列を印刷します。
	%e、%E、%f、%F、%g、および%Gの場合は常に小数点を印刷します。
	%gおよび%Gの場合は末尾のゼロを削除しません。
	%Uの場合は、印刷可能な場合はU+0078 'x'のように印刷します（%#U）。
' '	（スペース）数字の場合は符号が省略された場合にスペースを残します（% d）。
	文字列またはスライスを16進数で印刷する場合は、バイト間にスペースを入れます（% x、% X）
'0'	スペースの代わりに先頭にゼロを詰めます。数値の場合、これによりパディングが符号の後に移動します。
	文字列、バイトスライス、およびバイト配列には影響しません。

動詞がそれらを期待していない場合、フラグは無視されます。 たとえば、代替の10進数フォーマットがないため、%#dと%dは同じように動作します。

Printfのような各関数に対して、フォーマットを取らないPrint関数もあります。 これは、すべてのオペランドに対して%vと言うのと同等です。 別のバリアントであるPrintlnは、オペランド間に空白を挿入し、改行を追加します。

動詞に関係なく、オペランドがインターフェース値である場合、 インターフェース自体ではなく、内部の具体的な値が使用されます。 したがって、次のようになります。 

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

とすると、23が出力されます。

％Tおよび％p動詞を使用して印刷される場合を除き、 特定のインターフェースを実装するオペランドには特別なフォーマットが適用されます。 適用順序は次のとおりです。

1. オペランドがreflect.Valueである場合、オペランドは保持する具体的な値に置き換えられ、 次のルールで印刷が続行されます。

2. オペランドがFormatterインターフェースを実装している場合、 それが呼び出されます。この場合、動詞とフラグの解釈はその実装によって制御されます。

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

フォーマット（Printlnなどの暗黙的な%v）が文字列（%s %q %x %X）に対して有効である場合、または%vであり、%#vではない場合、次の2つのルールが適用されます。

4. オペランドがerrorインターフェースを実装している場合、Errorメソッドが呼び出され、 オブジェクトが文字列に変換され、動詞に必要な形式でフォーマットされます（ある場合）。

5. オペランドがString() stringメソッドを実装している場合、 そのメソッドが呼び出され、オブジェクトが文字列に変換され、 動詞に必要な形式でフォーマットされます（ある場合）。

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

ただし、文字列のような動詞（％s％q％x％X）を使用してバイトスライスを印刷する場合、 バイトスライスは文字列と同じように、単一のアイテムとして扱われます。

次のような再帰を避けるために 

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]という表記がある場合、n番目の1から始まる引数が代わりに フォーマットされることを示します。 幅または精度の'*'の前に同じ表記がある場合、 値を保持する引数インデックスが選択されます。 [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" を生成します。

Format errors

動詞に対して無効な引数が指定された場合、例えば%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文字（動詞）が続き、 かっこで囲まれた説明で終わります。

printルーチンによって呼び出されたときに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個以上のスペースを入力で消費して、 単一の改行または入力の終わりに続く改行を消費します。フォーマット文字列内の改行の後に スペースが続く場合、入力で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）は、最初のスペースまたは改行文字で入力の消費を停止します。

整数をフォーマット指定子なしまたは%v動詞でスキャンする場合、 0b（バイナリ）、0oおよび0（8進数）、0x（16進数）のよく知られた基本設定の接頭辞が受け入れられます。 数字を区切るアンダースコアも受け入れられます。

幅は入力テキストで解釈されますが、精度を指定する構文はありません（%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文字（rune）を読み取ることができます。 これは、スキャンルーチンを呼び出すループが入力の一部をスキップする可能性があることを意味します。 これは通常、入力値の間にスペースがない場合にのみ問題になります。 Fscanに提供されたリーダーがReadRuneを実装している場合、そのメソッドが文字を読み取るために使用されます。 また、リーダーがUnreadRuneも実装している場合、そのメソッドが文字を保存し、連続した呼び出しでデータが失われないようにします。 ReadRuneとUnreadRuneのメソッドを持たないリーダーにReadRuneとUnreadRuneのメソッドをアタッチするには、bufio.NewReaderを使用します。

Example (Formats)

これらの例は、フォーマット文字列を使用して印刷する基本的な方法を示しています。Printf、Sprintf、およびFprintfは、次の引数の書式を指定するフォーマット文字列を受け取ります。たとえば、%d（これを「動詞」と呼びます）は、対応する引数を10進数で表示することを意味します。その引数は整数（または整数を含むもの、例えば整数のスライス）でなければなりません。動詞%v（'v'は'value'を意味します）は、引数をそのデフォルトの形式で表示します。PrintまたはPrintlnのように。特別な動詞%T（'T'は'Type'を意味します）は、値ではなく引数の型を表示します。これらの例は網羅的ではありません。詳細については、パッケージのコメントを参照してください。 

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math"
	"github.com/shogo82148/std/time"
)

func main() {

	// %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)
	// 結果: int *int

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

	// ブール値は、%v や %t とともに "true" または "false" として表示されます。
	truth := true
	fmt.Printf("%v %t\n", truth, truth)
	// 結果: 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)
	// 結果: 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)
	// 結果：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)
	// 結果: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)

	// Runesは整数ですが、%cで印刷するとそのUnicode値に対応する文字が表示されます。
	// %qの動詞はクオートされた文字として表示し、%Uは16進数のUnicodeコードポイントとして表示し、
	// %#Uはコードポイントとクオートされた表示可能な形式の両方として表示します。
	smile := '😀'
	fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
	// 結果: 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'

	// 文字列は、%vと%sはそのまま、%qは引用符付き文字列、そして%#qはバッククォート付き文字列としてフォーマットされます。
	placeholders := `foo "bar"`
	fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
	// 結果：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)
	// 結果: 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)
	// 結果: {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))

	// 結果: &{Kim 22} 0x0
	// fmt.Printf("%v %p\n", pointer, pointer)
	// 結果: &{Kim 22} 0x010203 // 上のコメントを参照してください。

	// 配列やスライスは、各要素に対してフォーマットを適用して表示されます。
	greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
	fmt.Printf("%v %q\n", greats, greats)
	// 結果: [北野 小林 黒沢 宮崎 小津] ["北野" "小林" "黒沢" "宮崎" "小津"]

	kGreats := greats[:3]
	fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
	// 結果: [北野 小林 黒沢] ["北野" "小林" "黒沢"] []string{"北野", "小林", "黒沢"}

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

	// Stringerを実装するタイプは文字列と同じように表示されます。Stringerは文字列を返すため、%qなどの文字列専用のフォーマット指定子を使用して印刷することができます。
	now := time.Unix(123456789, 0).UTC()
	fmt.Printf("%v %q\n", now, now)
	// 結果: 1973年11月29日 21時33分09秒 +0000 UTC "1973年11月29日 21時33分09秒 +0000 UTC"

}

Output:

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"
Example (Printers)

Print、Println、およびPrintfは、引数を異なるレイアウトで配置します。この例では、それらの振る舞いを比較することができます。Printlnは常に出力する項目の間に空白を追加しますが、Printは非文字列の引数の間のみ空白を追加し、Printfは正確に指示通りの出力を行います。 Sprint、Sprintln、Sprintf、Fprint、Fprintln、およびFprintfは、ここに示すPrint、Println、およびPrintf関数と同じように動作します。 

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/math"
)

func main() {
	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)

}

Output:

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

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Append added in v1.19.0 

func Append(b []byte, a ...any) []byte

Appendはオペランドのデフォルトフォーマットを使用して、フォーマットを行い、結果をバイトスライスに追加し、更新されたスライスを返します。

func Appendf added in v1.19.0 

func Appendf(b []byte, format string, a ...any) []byte

Appendfはフォーマット指定子に従ってフォーマットを行い、結果をバイトスライスに追加し、更新されたスライスを返します。

func Appendln added in v1.19.0 

func Appendln(b []byte, a ...any) []byte

Appendln はオペランドのデフォルトの書式を使用してフォーマットし、結果をバイトスライスに追加し、更新されたスライスを返します。オペランド間には常にスペースが追加され、改行が追加されます。

func Errorf 

func Errorf(format string, a ...any) error

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

書式指定子に%w動詞とエラー被演算子を含む場合、返されるエラーはUnwrapメソッドを実装し、被演算子を返します。 複数の%w動詞がある場合、返されるエラーは、引数の順序で表示されるすべての%w被演算子を含む[]errorを返します。 エライターフェースを実装していない被演算子を%w動詞として使用することは無効です。それ以外の場合、%w動詞は%vと同義です。

Example

Errorf関数を使用することで、表示形式の機能を使って 詳細なエラーメッセージを作成することができます。 

package main

import (
	"github.com/shogo82148/std/fmt"
)

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

}

Output:

user "bueller" (id 17) not found

func FormatString added in v1.20.0 

func FormatString(state State, verb rune) string

FormatStringは、Stateによってキャプチャされた完全修飾のフォーマットディレクティブを表す文字列を返し、その後に引数の動詞が続きます。（State自体は動詞を含みません。）結果には、先頭にパーセント記号があり、その後にフラグ、幅、および精度が続きます。フラグ、幅、および精度のない場合は省略されます。この関数により、フォーマッタはFormatへの呼び出しをトリガーした元のディレクティブを再構築することができます。

func Fprint 

func Fprint(w io.Writer, a ...any) (n int, err error)

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/os"
)

func main() {
	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")

}

Output:

Kim is 22 years old.
21 bytes written.

func Fprintf 

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

Fprintfはフォーマット指定子に従って書式を整え、wに書き込みます。 書き込んだバイト数とエラーの有無を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/os"
)

func main() {
	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)

}

Output:

Kim is 22 years old.
21 bytes written.

func Fprintln 

func Fprintln(w io.Writer, a ...any) (n int, err error)

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/os"
)

func main() {
	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.")

}

Output:

Kim is 22 years old.
21 bytes written.

func Fscan 

func Fscan(r io.Reader, a ...any) (n int, err error)

Fscan は、r から読み取ったテキストをスキャンし、連続した空白で区切られた値を連続した引数に格納します。改行も空白としてカウントされます。成功したスキャンのアイテム数を返します。引数の数よりも少ない場合、err がなぜエラーが発生したのかを報告します。

func Fscanf 

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

Fscanfはrから読み取ったテキストをスキャンし、 フォーマットに従って連続したスペースで区切られた値を連続した引数に格納します。 成功した解析のアイテム数を返します。 入力の改行はフォーマットの改行と一致する必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/strings"
)

func main() {
	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)
}

Output:

5 true gophers
3

func Fscanln 

func Fscanln(r io.Reader, a ...any) (n int, err error)

FscanlnはFscanに似ていますが、改行でスキャンを終了し、最後の項目の後には改行かEOFが必要です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/strings"
)

func main() {
	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)
	}
}

Output:

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

func Print 

func Print(a ...any) (n int, err error)

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
)

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

	// Print が返すエラーについては心配する必要がないというのは慣習です。

}

Output:

Kim is 22 years old.

func Printf 

func Printf(format string, a ...any) (n int, err error)

Printfはフォーマット指定子に従ってフォーマットを行い、標準出力に書き込みます。 書き込まれたバイト数とエラーがあれば、それらを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
)

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

	// Printfが返すエラーについては心配しないのが通例です。

}

Output:

Kim is 22 years old.

func Println 

func Println(a ...any) (n int, err error)

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
)

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

	// Printlnが返すエラーについては、心配しないのが一般的です。

}

Output:

Kim is 22 years old.

func Scan 

func Scan(a ...any) (n int, err error)

Scanは標準入力から読み取ったテキストをスキャンし、連続するスペースで区切られた値を連続した引数に格納します。改行はスペースとして扱われます。スキャンに成功したアイテムの数を返します。引数の数よりも少ない場合、errにはエラーの理由が報告されます。

func Scanf 

func Scanf(format string, a ...any) (n int, err error)

Scanfは標準入力から読み取ったテキストをスキャンし、形式に応じて連続したスペースで区切られた値を連続した引数に保存します。成功したスキャンのアイテム数を返します。引数の数よりも少ない場合、エラーが発生した理由がerrに報告されます。入力にある改行は、形式にある改行と一致する必要があります。ただし例外として、動詞%cは常に入力の次のルーンをスキャンします。それがスペース（またはタブなど）や改行であってもです。

func Scanln 

func Scanln(a ...any) (n int, err error)

ScanlnはScanに似ていますが、改行でスキャンを停止し、 最後のアイテムの後には改行またはEOFが必要です。

func Sprint 

func Sprint(a ...any) string

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/os"
)

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

	io.WriteString(os.Stdout, s) // シンプルさのためにエラーを無視しています。

}

Output:

Kim is 22 years old.

func Sprintf 

func Sprintf(format string, a ...any) string

Sprintfはフォーマット指定子に従ってフォーマットされた文字列を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/os"
)

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

	io.WriteString(os.Stdout, s) // 単純化のため、エラーを無視しています。

}

Output:

Kim is 22 years old.

func Sprintln 

func Sprintln(a ...any) string

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

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/os"
)

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

	io.WriteString(os.Stdout, s) // シンプルさを考慮してエラーを無視します。

}

Output:

Kim is 22 years old.

func Sscan 

func Sscan(str string, a ...any) (n int, err error)

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

func Sscanf 

func Sscanf(str string, format string, a ...any) (n int, err error)

Sscanfは引数文字列をスキャンし、フォーマットによって決まる連続するスペースで区切られた値を連続した引数に格納します。正常に解析されたアイテムの数を返します。 入力の改行は、フォーマットと一致する必要があります。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
)

func main() {
	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)

}

Output:

2: Kim, 22

func Sscanln 

func Sscanln(str string, a ...any) (n int, err error)

SscanlnはSscanに似ていますが、改行でスキャンを停止し、最後のアイテムの後には改行またはEOFが必要です。

Types

type Formatter 

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

Formatterは、Formatメソッドを持つ任意の値で実装されます。 実装は、Stateとruneの解釈方法を制御し、Sprint()やFprint(f)などを呼び出して出力を生成することができます。

type GoStringer 

type GoStringer interface {
	GoString() string
}

GoStringerは、GoStringメソッドを持つ任意の値で実装されており、 その値のGo構文を定義します。 GoStringメソッドは、%#vフォーマットに渡された値を出力するために使用されます。

Example 
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 

type ScanState interface {
	// ReadRuneは、入力から次のルーン（Unicodeコードポイント）を読み取ります。
	// Scanln、Fscanln、またはSscanln中に呼び出された場合、ReadRune()は、最初の'\n'を返した後、または指定された幅を超えて読み取りを行った後にEOFを返します。
	ReadRune() (r rune, size int, err error)
	// UnreadRuneは、次のReadRune呼び出しで同じルーンを返します。
	UnreadRune() error
	// SkipSpaceは、入力内のスペースをスキップします。
	// 操作に応じて、改行は適切に処理されます。
	// 詳細については、パッケージのドキュメントを参照してください。
	SkipSpace()
	// Tokenは、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)
}

ScanStateはカスタムスキャナーに渡されるスキャナーの状態を表します。 スキャナーは一文字ずつスキャンすることもでき、またScanStateに次のスペース区切りのトークンを見つけるように依頼することもできます。

type Scanner 

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

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

type State 

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
}

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

type Stringer 

type Stringer interface {
	String() string
}

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

Example 
a := Animal{
	Name: "Gopher",
	Age:  2,
}
fmt.Println(a)

Output:

Gopher (2)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.