Wikibooks

「Go/変数」の版間の差分

履歴の双方向閲覧
← 古い編集次の差分 →
削除された内容 追加された内容
ビジュアルウィキテキスト
Ef3 (トーク | 投稿記録)
7,135 回編集
→‎小数以外のビット精度: 低精度整数型の用途
タグ: 2017年版ソースエディター
Ef3 (トーク | 投稿記録)
7,135 回編集
s/予約語/キーワード/、{{Cite book}}
タグ: 2017年版ソースエディター
1 行
=== 変数の利用方法宣言 ===
変数宣言では、1つまたは複数の変数を作成し、対応する識別子を結合し、それぞれに型と初期値を与えます<ref name="Declarations_and_scope">{{cite book
変数を使用するには、var演算子で宣言をする必要がある。（なお JavaScriptが同様に var 演算子を変数の宣言で使う仕様。）
| url = https://golang.org/ref/spec#Declarations_and_scope
 
| title = The Go Programming Language Specification
int などの型は、あっても、なくても、どちらでもイイ。
| chapter = Declarations_and scope ¶
 
| date = Jul 26, 2021
 
| publisher = The Go website
Go言語では、数値変数の他、文字列変数や関数変数や構造体変数なども使える。
}}</ref>。
 
;構文:<syntaxhighlight lang="ebnf">
 
VarDecl = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) ;
==== 型なしの場合 ====
VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) ;
 
</syntaxhighlight>
;コード例
<syntaxhighlight lang="go">
// 型のない場合
 
==== 初期化と型推論 ====
Go言語では、変数宣言の初期値から宣言される変数の型を推論します。
;[https://paiza.io/projects/CaES_qcOAYx229wAJi6YZw?language=go コード例]:<syntaxhighlight lang="go" highlight="6,7" line>
package main
 
import "fmt"
 
var hensu = 5;
 
func main() {
var n = 5
fmt.Println(hensu)
fmt.Printf("var n = 5 => 値:%v 型:%T\n", n, n)
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
var n = 5 => 値:5 型:int
</syntaxhighlight>
;解説:<syntaxhighlight lang="go" start=6 line>
var n = 5
</syntaxhighlight>
で変数 <var>n</var> を初期値を 5 で宣言しています。
明示的に型を伴って宣言していませんが、初期値の 5 から int が型推定されます。
;fmt.Printf:<syntaxhighlight lang="go" start=7 line>
fmt.Printf("var n = 5 => 値:%v 型:%T\n", n, n)
</syntaxhighlight>
fmtパッケージのPrintf関数を使って表示しています。
名前から予想がつく通り、[[C言語]]の標準ライブラリー関数の printf() に習った関数ですが、Go言語の慣習に従って関数名の最初だけ大文字です。
機能的にも、C言語のprintfにはない型指定子 %v（式の値に自然な形式で表示する）と %T（式の型を表示する）の様な拡張が施されています。
 
=== 初期化を伴わない例 ===
 
;[https://paiza.io/projects/kl8iW9-vUfuAVWaOMxl8cg?language=go コード例]:<syntaxhighlight lang="go" highlight=6 line>
;実行結果
5
 
なお、fmt.Println 関数で変数を表示したい場合、単に、丸カッコの中に変数名を書けばいい。
 
 
 
==== 文字と変数を表示したい場合 ====
 
ひとつのfmt.Println 関数で、文字と変数を表示したい場合は、カンマ区切ればいい。
 
;コード例
<syntaxhighlight lang="go">
// 型のない場合
 
package main
 
import "fmt"
 
var hensu = 5;
 
func main() {
var n int
fmt.Println("kazu", hensu)
fmt.Printf("var n int => 値:%v 型:%T\n", n, n)
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
var n int => 値:0 型:int
</syntaxhighlight>
;解説:<syntaxhighlight lang="go" start=6 line>
var n int
</syntaxhighlight>
で int 型の変数 <var>n</var> を初期値なしで宣言しています。
この例は初期値が与えられていないので、明示的に型を指定する必要があります。
この例では変数の値は 0 でしたが、型により暗黙で推定される値が異なるので、初期値を与え型を推定させるスタイルが好まれます。
 
=== 短い変数宣言 ===
変数宣言にはもう1つの構文があります。
;短い変数宣言:短い変数宣言は、以下の構文を使用します。
;構文:<syntaxhighlight lang="ebnf">
ShortVarDecl = IdentifierList ":=" ExpressionList ;
</syntaxhighlight>
これは、初期化式を持つが型を持たない通常の変数宣言の短縮形です。
 
;[https://paiza.io/projects/Aedbpc_Oo9V-jxM9dMBFNw?language=go コード例]:<syntaxhighlight lang="go" highlight=6 line>
;実行結果
kazu 5
 
 
文字列どうしを続けて書いても構わない。変数どうしを続けて書いても構わない。
 
;コード例
<syntaxhighlight lang="go">
// 文字列どうしをつづけた場合
 
package main
 
import "fmt"
 
 
func main() {
n := 5
fmt.Println("トラ", "トラ" , "トラ")
fmt.Printf("var n = 5 => 値:%v 型:%T\n", n, n)
}
</syntaxhighlight>
;実行結果:(略)
;解説:<syntaxhighlight lang="go" start=6 line>
n := 5
</syntaxhighlight>
同じ様に、int 型の変数 <var>n</var> を初期値を 5 で宣言しています。
var を伴った宣言と異なり、初期値は省略できません。
 
短い変数宣言は、if文、switch文やfor文に「文スコープな変数」を宣言する時に使われます。<!--条件分岐と繰り返しにリンクしたいが、文スコープな変数への言及がまだない -->
 
=== 複数の変数の一括宣言 ===
;実行結果
;構文:<syntaxhighlight lang="ebnf">
トラ トラ トラ
VarDecl = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) ;
 
 
 
;コード例
<syntaxhighlight lang="go">
// 変数どうしをつづけた場合
 
package main
 
import "fmt"
 
var hensu1 = 7;
var hensu2 = 5;
var hensu3 = 3;
 
func main() {
fmt.Println(hensu1, hensu2 , hensu3)
}
</syntaxhighlight>
の後半 <code>"(" { VarSpec ";" } ")" </code>は、宣言子の繰り返しを表しています。
 
;[https://paiza.io/projects/cWIqw1qXXju4W-8eZ2GZ0g?language=go コード例]:<syntaxhighlight lang="go" highlight=6 line>
 
;実行結果
7 5 3
 
 
 
余談ですが、変数を複数個まとめてvarと丸カッコ ( ) で宣言することもできます。
 
;コード例
<syntaxhighlight lang="go">
// 複数の変数をまとめて宣言する場合
 
package main
 
113 ⟶ 100行目:
 
var (
hensu1a = 7100;
hensu2b = 5"string";
hensu3v = 3;[]struct {
name string
number int
}{
{ "abc", 1 },
{ "def", 2 },
{ "ghi", 3 },
{ "xyz", 9 },
};
f = 3.14
)
 
func main() {
fmt.PrintlnPrintf(hensu1,"a: hensu2値:%v 型:%T\n", a, hensu3a)
fmt.Printf("b: 値:%v 型:%T\n", b, b)
fmt.Printf("v: 値:%v 型:%T\n", v, v)
fmt.Printf("f: 値:%v 型:%T\n", f, f)
}
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
 
a: 値:100 型:int
 
b: 値:string 型:string
;実行結果
v: 値:[{abc 1} {def 2} {ghi 3} {xyz 9}] 型:[]struct { name string; number int }
7 5 3
f: 値:3.14 型:float64
 
==== 型を付ける場合 ====
なお、型をつける場合、下記のように変数名のあとに型をつける。（もし変数の前に型をつけても、エラーになり、実行できない。）
 
書式はおおむね、たとえば整数型 int の変数の宣言なら、
var 変数名 int = 初期値;
のような書式になる。
（上記のような記法は、C言語にもJavaScriptにもない、Go言語に特有的な記法。）
 
Go言語の数値型には、C言語と同様に整数のint型 、浮動小数の float型 がある。またGo言語には、複素数をあつかえる complex型 がある。
 
Go言語の浮動小数 float では、複素数は'''使えない'''です。
 
そのため、Go言語のfloatを「実数」と呼ぶこともあります。「実数」と言っても、平方根 √2 などの数式処理は不可能ですので、誤解ないように（単に数値計算などでmathパッケージの組み込み関数を使って 平方根や三角関数などの近似値の浮動小数などを求めるのは可能）。
 
 
;コード例
<syntaxhighlight lang="go">
// 型のある場合
 
package main
 
import "fmt"
 
var hensu2 int = 8;
 
func main() {
fmt.Println("kazu2 :", hensu2)
}
</syntaxhighlight>
a,bそれにfはある程度予想が着くと思います。
vは匿名構造体配列の複合リテラルです。<!--リテラルについては単独で立項するべき？-->
この様に fmt.Printf の %v ならびに %T 型指定子は、ユーザー定義を含め任意のオブジェクトの値と型を表示できるので便利です。
 
== 整数と浮動小数点数 ==
;実行結果
上記の例のように、浮動小数点数リテラルの型は float64 です。この他に float32 という型もありますが、 float という型はありません。
kazu2 : 8
異なる数値型の間の演算はエラーにはならず、昇格則が働きます。
 
{{See also|Go/算術演算と数学関数}}
 
==== 異なる型どうしの計算は受け付けない ====
エラーになるコードの例ですが、たとえば int 型の変数に小数を足したり引いたりしても、エラーになります。
 
なお、Go言語における算術演算での加減乗除の方法はC言語など他の言語と同様、演算子 + - * / などの演算子で行えます。
 
 
浮動小数 float には、Go言語では float32 と float64 の2種類があります。float32 型の変数と、float64 型の変数とを足し算または引き算したりしてもエラーです。算術演算のさいには、バイト精度も合わせる必要があります。
 
なお、「float」で宣言した際に float32 になるか float64 になるかについては、Go言語コンパイラが自動的に、ユーザーが使用しているパソコン環境にもとづき、 float32 か float64 かのどちらかを割り当てます。
 
 
Go言語はコードの見た目がなんとなく JavaScript っぽいので、ついつい、整数に小数を足したりしがちですが、しかしGo言語では、型変換して型を浮動小数に合わせないかぎり、エラーになります。
 
==== 「単精度」および「倍精度」という言い方 ====
float32とfloat64について、文献によっては「単精度」および「倍精度」という言い方をしているものがあるが（32ビットを基準に「単精度」とし、64ビットを「倍精度」と呼んでいる）、しかしこの言い方は、多くのC言語コンパイラなどに残っている言い方ではあるが、しかし歴史的な経緯による呼び方であり、あまり論理的な普遍性が無い。
 
事実、C言語コンパイラの多くでは64ビット浮動小数のことを「double」型と呼んでおり32ビット浮動小数だけ「float」型と呼んでいるのにかかわらず、しかしGo言語はこういった呼び方をやめ「float32」および「float64」というように、Go言語ではビット数に関わらずfloatで統一している。そもそも、64ビットだろうが浮動小数点計算であるのだから、Go言語での浮動小数点の分類のほうが合理的ではある。
 
「単精度」「倍精度」などは国際規格で1980年代に定められたIEEE 754に定められている言い方ではあるが、（IEEE 754の2000年以降にも されてはいるが）1980年代の古い発想に基づく規格であり、上述のような理由により今後は避けたほうが無難だろう。
 
 
=== 小数以外のビット精度 ===
浮動小数点数型以外に整数型 int にも、ビット幅を伴った、<code>int32</code>, <code>int64</code> や<code>int8</code>, <code>int16</code> があります。
 
int32
や
int64
などの区別がある。
 
さらに、int8やint16などもある。
 
:しかしint8の範囲は -128～127 なので、有効数字2～3ケタの範囲です。
:int16 の範囲も -32768～32767 というふうに有効数字5ケタ程度です。
 
このような低精度、省フットプリントの整数型にニーズがないと感じることがあるかもしれないが、回帰型ニューラルネットワークなどの人工知能応用では精度は必ずしも必要なく、メモリーフットプリントの削減と計算時間の削減という意味で今後もニーズがあります。
 
このような低精度の整数型にはニーズがないと、感じることがあるかもしれないが回帰型ニューラルネットワークなどの人工知能応用では精度は必ずしも必要なく、メモリーフットプリントの削減と計算時間の削減という意味で今後もニーズがあります。
:int32の範囲 は -2147483647 ～ 2147483647 です。
:int32の範囲 は -9223372036854775808 ～ 9223372036854775807 です。
 
{|class="wikitable"
226 ⟶ 167行目:
 
 
int型には、ビット精度のほかに、さらに正負 ± の符号の有無による区別もあります。（C言語でも同様です。）。
 
型指定で単に「int」だけ入力したときに作成される整数は、通常、「符号ありつき」の型です。
なので、符号ありの整数では、intの前に、なんの接頭辞もつけないのですません。
 
uint64 などの頭文字「u」は、unsigned （符号なし、「アンサインド」と読む）の意味です。数学のプラスマイナスの符号のことを英語で「sign」（サイン）といい、その符号が無いので、打ち消しの接頭辞 un をともない、unsigned という意味です。
 
特別な事情のないかぎり、整数型の指定のときには「int」とだけ入力しておけば、Go言語コンパイラが、アーキテクチャにもとづき、自動でビット精度を判断してくれますので、なるべく「int」とだけ入力してコンパイラに任せておくのが簡便でしょう。
 
==== ローカル変関数スコープ ====
キーワード var を使って宣言した場合も、 簡略表記「:=」を使った場合にも関数の中で宣言された変数のスコープは関数のブロックです（関数の中のfor文やif文で宣言された場合は文スコープになります）。
main関数など何らかの中ならば、演算子「:=」により、その関数の中だけで有効なローカル変数の宣言と初期値の代入を同時にできます。
また簡略表記「:=」はグローバル変数の宣言には使えません。
 
なお、この「:=」演算子は、情報科学では一般に「定義」（ていぎ）と言われますが、しかしGo言語の場合、この演算子の内容は定義ではなく、単にローカル変数を宣言しているだけです。
 
ローカル変数の宣言の書式は
変数名 := 初期値
です。
 
このローカル変数宣言の演算子では、型は不要ですし、そもそも型を記載できません。（むりやり int とかを書いてもエラーになる。）
 
main関数の外のグローバル領域でローカル変数宣言を書いても、エラーになるので、グローバル領域では利用できないです。
 
 
;コード例
<syntaxhighlight lang="go">
package main
 
import "fmt"
 
func main() {
hensu1 := 9;
fmt.Println("aaa :", hensu1)
}
</syntaxhighlight>
 
;実行結果
aaa : 9
 
 
 
いっぽう、従来どおりの var 演算子を使った記法でも、関数内で変数を宣言することは可能です。
 
;コード例
<syntaxhighlight lang="go">
package main
 
import "fmt"
 
 
func main() {
var hensu1 = 10;
fmt.Println("aaa :", hensu1)
}
</syntaxhighlight>
 
;実行結果
aaa : 10
 
 
==== 文字列型 ====
文字列変数を使うには、単初期化に、代入した文字リテラル（"文字列を二重引用符 " の形式）を使い型推論させる方法と、型名 "string でククを明示するだけで方法があります。
単に、代入した文字列を二重引用符 " " でククるだけです。
 
型名として string を後置に付けても構いません。（型名 string は省略可能です。）
 
なお、C++にはstring型はなく標準テンプレートクラスライブラリーの string クラスを使います。JavaScriptには文字列プリミティブとStringオブジェクトがあります（なお標準C言語にはstring型が無く、'\0'で終端されたchar型の配列で表現していますが、文字列の連結などは標準ライブラリの関数となっており、結果を表すバッファのサイズなどへの責任はプログラマ本人が負い。このことが度々バッファオーバープロー等を引き起こし脆弱性の原因となっています。）。
なお、C++やJavaScriptにもString型はあります。（なお標準C言語にはstring型が無く、char型の配列などで代用する仕組みでる。21世紀の今でもLinuxのCコンパイラgccには、標準C言語にはstring型が無い。）
 
==== キーワード ====
以下のキーワードは予約済みで、識別子として使用することはできません<ref name="Keywords">{{cite book
| url = https://golang.org/ref/spec#Keywords
| title = The Go Programming Language Specification
| chapter = Keywords ¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
 
;Goのキーワード一覧:<source lang="text">
;コード例
break default func interface select
<syntaxhighlight lang="go">
case defer go map struct
package main
chan else goto package switch
const fallthrough if range type
continue for import return var
</source>
'''int''' や '''float32''' などの（プリミティブな）型名が含まれていません。
 
このため、<source lang=go inline>var int = 123.456 </source>は、float64型の変数 int 値は 123.456 と「正しく」解釈されます。
import "fmt"
 
PL/Iのようですね。
var moji string = "asdfg"
 
== 型変換 ==
func main() {
変換は，式の型を変換によって指定された型に変更します。変換は，ソースの中で文字通りに現れるかもしれませんし，式が現れる文脈によって暗示されるかもしれません。
fmt.Println("aaa :", moji)
明示的な変換は，T(x)という形式の式で，Tは型であり，xはT型に変換できる式である<ref name="Conversions ">{{cite book
}
| url = https://golang.org/ref/spec#Conversions
| title = The Go Programming Language Specification
| chapter = Conversions ¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
;構文:<syntaxhighlight lang="ebnf">
Conversion = Type "(" Expression [ "," ] ")" .
</syntaxhighlight>
Go言語は静的型システムを導入しており、この意味ではC言語に近く型を厳密に扱います（といってもIntegerとRealの足し算ですら明示的な型変換が必要なPascal程ではありません）。
 
JavaScriptやRubyなどの動的な型システムを採用したシステムは、「数値型に文字列型を足す」、「文字列を１進める」などの異なる型同士の演算に於いて暗黙の型変換が行われます。
;実行結果
aaa : asdfg
 
 
 
==== 予約語 ====
Go言語にかぎらず、プログラム言語において、プログラマーが変数の名前をつけるとき、変数名に使えない文字列があり、そのような文字列のことを予約語（よやくご）と言います。
 
Go言語の場合、たとえば「var」や「import」などは変数名や関数名には使えないので、「var」や「import」は予約語です。（関数については、別の単元で説明する。）
 
 
なお「int」や「float32」などはGo言語では変数名に使えますが（※ Linux の Fedora32 で確認ずみ）、しかし、マギらわしいので使用は避けるべきです。
 
 
ただし「variant」のように変数名の一部に予約語の文字列が入っている場合は使用じたいは可能です。（ただし、検索などの際に、まぎらわしいので、避けたほうが安全です。）
 
少なくとも次の25個の文字列は、それぞれGo言語の予約語であるので、Go言語では変数名には使えない文字列です。
 
break case chan const continue
default defer else fallthrough for
func go goto if import
interface map package range return
select struct switch type var
 
== 型変換 ==
Go言語は、型の扱いについては、C言語に近く、Go言語は比較的に型を厳密に扱います。
 
JavaScriptやPHPなどだと、数値型に文字列型を足したりしても、勝手に型を変換してくれたりますが（2020年6月現在のJavaScriptやPHPはそういう仕様）、しかしGo言語では、こういった型の混在した式の、単純な足し合せは許されない仕様です。
 
Go言語では、どうしても異なる型どうしの複数個の変数を足しあわせる処理などを場合、どちらかの変数の型を変換し、相手ガワの変数の型に合わせるという、型の変換をする必要があります。
 
そのための型変換の機能が、下記のようにGo言語には用意されています。
 
 
=== 数値どうしの型変換 ===
整数型で宣言した数を浮動小数型にしたり、float32型で宣言した数をfloat64型に変換するには、
==== 基本 ====
;[https://paiza.io/projects/puE2WlQcQ4xZEQFRh2SZlg?language=go コード例]:<syntaxhighlight lang="go" line>
整数型で宣言した数を浮動小数型にしたり、float32型で宣言した数をfloat64型に変換するには、下記のようにします。
 
たとえば int 型の変数をfloat64に変換したい場合、
var 変換後の変数名 = float64(変換前の変数) ;
のような書式になります。
 
つまり、数値から数値への型変換は
型(変数)
の書式です。
 
 
;コード例
<syntaxhighlight lang="go">
// 型の変換
 
package main
 
import "fmt"
 
var hensu2 int = 8;
 
func main() {
fmt.Println("kazu2i :",= hensu2)8
fmt.Println("i = ", i)
fmt.Println("i / 3 = ", i / 3)
var hensu3f := float64(hensu2i) ;
fmt.Println("kataf henkan= :", hensu3 + 0.1f)
fmt.Println("f / 3 = ", f / 3)
}
 
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
 
i = 8
;実行結果
i / 3 = 2
<pre>
kazu2f = : 8
f / 3 = 2.6666666666666665
kata henkan : 8.1
</pre>
 
 
==== エラーになる例 ====
いっぽう、ダメな例として
var hensu3 float64 = hensu2 ;
と書いてもエラーになり、この書き方では変換できないです。
 
 
 
=== 数と文字列との変換 ===
C言語では、非標準ライブラリなどの提供する機能によって、 itoa という組み込み関数で、数を文字列にできます。
 
また、atoi という関数で、C言語では文字列を数に変換できます。
 
 
Go言語にも、これと似た組み込み関数があり、 strconv.Itoa() および strconv.Atoi() という組み込み関数があります。
 
Go言語では、これらの組み込み関数を使うために "strconv" パッケージをインポートする必要があります。
 
 
なお、itoa やatoi のaはアスキー（ascii）の「a」だと言われています。itoaやatoiの「i」は integer（整数）の意味だと言われています。
 
また strconv とは string convert などの略です。convert （コンバート）とは、「変換する」という意味の英語です。
 
 
;コード例
<syntaxhighlight lang="go">
// 文字列型への変換
 
package main
 
import (
"fmt"
"strconv"
)
 
func main() {
moji1 := "あああ"
n := 14
moji2 := strconv.Itoa(n)
str := moji1 + moji2
fmt.Println(str)
}
</syntaxhighlight>
 
やや直感的ではありませんが、キーワード var を使った変数宣言で型名を明示した場合の初期値には暗黙の型変換は起こりません。
;実行結果
:<syntaxhighlight lang="go" start=10line>
<pre>
f := float64(i)
あああ14
</syntaxhighlight>
</pre>
は
 
:<syntaxhighlight lang="go" start=10 line>
 
var f float64 = ｉ
=== Sprintfによる方法 ===
itoa とは別の方法で、sprintf という組み込み関数をつかう方法もある。
 
C言語の規格では、itoaをサポートしていないが、sprintfは規格によって公式にサポートされている。
 
もしGo言語で sprintf を使う場合、fmt.Println などで使う "fmt"パッケージに fmt.Sprintf も含まれているので、"fmt"をインポートすれば充分である。
 
<syntaxhighlight lang="go">
// Sprintf による文字列型への変換
 
package main
 
import (
"fmt"
// "strconv"
)
 
func main() {
moji1 := "山田"
var n int = 17
moji2 := fmt.Sprintf("%v", n)
fmt.Printf("名前:%s, 年齢:%s\n", moji1, moji2)
}
</syntaxhighlight>
;コンパイルエラー:<syntaxhighlight lang="text">
# command-line-arguments
./Main.go:10:9: cannot use i (type int) as type float64 in assignment
</syntaxhighlight>
ではなく
:<syntaxhighlight lang="go" start=10 line>
var f float64 = float64(i)
</syntaxhighlight>
とする必要があります。
 
ちなみに C言語の感覚で、
 
:<syntaxhighlight lang="go" start=10 line>
;実行結果
f := 1.0 * i
<pre>
名前:山田, 年齢:17
</pre>
 
 
なお、上記コードの「%v」とは、出力される変数の型に応じて自動で出力フォーマット指定をしてくれる、Go言語特有のフォーマット指定子です。
 
'''C言語の'''フォーマット指定子には、「%v」は'''無い'''です。
 
 
 
なお、「%T」と指定すると、型名が出力されます。%Tの「T」は大文字の「T」である必要があります。（小文字「t」では認識しない。）
 
'''C言語の'''フォーマット指定子には、「%T」は'''無い'''です。
 
;コード例
<syntaxhighlight lang="go">
// %Tのテスト
 
package main
 
import (
"fmt"
// "strconv"
)
 
func main() {
moji1 := "山田"
var n int = 17
 
fmt.Printf("moji1は何型か:%T \n", moji1)
fmt.Printf("nは何型か:%T \n", n)
}
</syntaxhighlight>
とすると f の型は（float64 ではなく）int です。
 
== 脚註 ==
 
<references />
;実行結果
<pre>
moji1は何型か:string
nは何型か:int
</pre>
"https://ja.wikibooks.org/wiki/Go/変数" より作成