Go/式のソースを表示

{{Nav}}

= 式 =
式(An expression)は、演算子や関数をオペランドに適用して値を計算することを指定します<ref name="Expressions">{{cite book
| url = https://golang.org/ref/spec#Expressions
| title = The Go Programming Language Specification
| chapter = Expressions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。

== オペランド ==
オペランド(Operands)とは、式の中の基本的な値を表すものです<ref name="Operands">{{cite book
| url = https://golang.org/ref/spec#Operands
| title = The Go Programming Language Specification
| chapter = Operands¶
| date = March 10, 2022
| publisher = The Go website
}}</ref>。オペランドは、リテラル、定数、変数、関数を表す（修飾されている場合もある）ブランクでない識別子、または括弧で囲まれた式です。

;構文:<syntaxhighlight lang="ebnf">
Operand     = Literal | OperandName [ TypeArgs ] | "(" Expression ")" ;
Literal     = BasicLit | CompositeLit | FunctionLit ;
BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit ;
OperandName = identifier | QualifiedIdent ;
</syntaxhighlight>
:Go1.18からオペランドも型仮引数を持つことが出来るようになりました。

ジェネリック関数を示すオペランド名の後に、型引数のリストを続けることができます；結果として生じるオペランドは、インスタンス化された関数です。
空白の識別子(<code>_</code>)は，代入の左側においてのみオペランドとして現れることができます。

;実装上の制限
:オペランドの型が空の型パラメータである場合、コンパイラはエラーを報告する必要はありません。
:このような型パラメータを持つ関数はインスタンス化できません。
::インスタンス化しようとすると、その場所でエラーになります。

== 修飾された識別子 ==
修飾された識別子(''Qualified identifiers'')とは、パッケージ名のプレフィックスで修飾された識別子のことです<ref name="Qualified_identifiers">{{cite book
| url = https://golang.org/ref/spec#Qualified_identifiers
| title = The Go Programming Language Specification
| chapter = Qualified_identifiers¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。パッケージ名と識別子の両方が空白であってはなりません。

;構文:<syntaxhighlight lang="ebnf">
QualifiedIdent = PackageName "." identifier ;
</syntaxhighlight>
修飾された識別子は、別のパッケージにある識別子にアクセスするもので、インポートされなければなりません。識別子は、そのパッケージのパッケージブロックにエクスポートして宣言する必要があります。
;例:<syntaxhighlight lang=go>
math.Sin // パッケージmathのSin関数を示す。
</syntaxhighlight>

== 複合リテラル ==
複合リテラル(Composite literals)は、評価されるたびに新しい複合値を構築します<ref name="Composite_literals">{{cite book
| url = https://golang.org/ref/spec#Composite_literals
| title = The Go Programming Language Specification
| chapter = Composite literals¶
| date = March 10, 2022
| publisher = The Go website
}}</ref>。複合リテラルは、リテラルの型に続いて、要素の中括弧付きリストで構成されます。各要素の前には、対応するキーを付けることができます。

;構文:<syntaxhighlight lang="ebnf">
CompositeLit  = LiteralType LiteralValue ;
LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType | SliceType | MapType | TypeName ;
LiteralValue  = "{" [ ElementList [ "," ] ] "}" ;
ElementList   = KeyedElement { "," KeyedElement } ;
KeyedElement  = [ Key ":" ] Element ;
Key           = FieldName | Expression | LiteralValue ;
FieldName     = identifier ;
Element       = Expression | LiteralValue ;
</syntaxhighlight>

LiteralType のコア型 T は、構造体、配列、スライス、またはマップ型でなければなりません (文法では、型が TypeName として指定される場合を除き、この制約が適用されます)。
要素とキーの型は、型Tのそれぞれのフィールド、要素、キー型に割り当て可能でなければなりません。
キーは、構造体リテラルではフィールド名として、配列およびスライスリテラルではインデックスとして、マップリテラルではキーとして解釈されます。
マップリテラルの場合、すべての要素にキーが必要です。
同じフィールド名や定数キー値で複数の要素を指定するとエラーになります。
<!-- 定数でないマップキーについては、評価順序のセクションを参照してください。 -->

== 関数リテラル ==
関数リテラル(A function literal )は、匿名関数を表します<ref name="Function_literals">{{cite book
| url = https://golang.org/ref/spec#Function_literals
| title = The Go Programming Language Specification
| chapter = Function literals¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
;構文:<syntaxhighlight lang="ebnf">
FunctionLit = "func" Signature FunctionBody ;
</syntaxhighlight>
;例:<syntaxhighlight lang=go>
func(a, b int, z float64) bool { return a*b < int(z) }
</syntaxhighlight>
関数リテラルは、変数に代入したり、直接呼び出すことができます。
;例:<syntaxhighlight lang=go>
f := func(x, y int) int { return x + y } 
func(ch chan int) { ch <- ACK }(replyChan)
</syntaxhighlight>
関数リテラルはクロージャであり、周囲の関数で定義された変数を参照することができます。これらの変数は、周辺の関数と関数リテラルの間で共有され、アクセス可能である限り存続します。

;[https://play.golang.org/p/R2yVrKuRpL3 例]:<syntaxhighlight lang=go>
package main

import "fmt"

func Map(f func(int) int, array []int) []int {
	result := make([]int, len(array))
	for i, v := range array {
		result[i] = f(v)
	}
	return result
}

func main() {
	fmt.Println(Map(func(x int) int { return 2*x + 1 }, []int{1, 2, 3}))
}
</syntaxhighlight>

== 一次式 ==
一次式(Primary expressions)は、単項式や二項式のオペランドになります<ref name="Primary_expressions">{{cite book
| url = https://golang.org/ref/spec#Primary_expressions
| title = The Go Programming Language Specification
| chapter = Primary expressions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
;構文:<syntaxhighlight lang="ebnf">
PrimaryExpr =
	Operand |
	Conversion |
	MethodExpr |
	PrimaryExpr Selector |
	PrimaryExpr Index |
	PrimaryExpr Slice |
	PrimaryExpr TypeAssertion |
	PrimaryExpr Arguments ;

Selector       = "." identifier ;
Index          = "[" Expression "]" ;
Slice          = "[" [ Expression ] ":" [ Expression ] "]" |
                 "[" [ Expression ] ":" Expression ":" Expression "]" ;
TypeAssertion  = "." "(" Type ")" ;
Arguments      = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" ;
</syntaxhighlight>
;例:<syntaxhighlight lang=go>
x
2
(s + ".txt")
f(3.1415, true)
Point{1, 2}
m["foo"]
s[i : j + 1]
obj.color
f.p[i].x()
</syntaxhighlight>

== セレクター ==
セレクター(''Selectors'')<ref name="Selectors">{{cite book
| url = https://golang.org/ref/spec#Selectors
| title = The Go Programming Language Specification
| chapter = Selectors¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

次の x がパッケージ名でない一次式であれば、セレクター式です。

:<syntaxhighlight lang=go>
x.f
</syntaxhighlight>

は、値xのフィールドまたはメソッドfを表します（*xの場合もあります。
識別子fは、（フィールドまたはメソッド）セレクターと呼ばれ、ブランク識別子であってはなりません。
xがパッケージ名の場合は、修飾された識別子のセクションを参照してください。

セレクターfは、型Tのフィールドやメソッドfを示すこともあれば、Tの入れ子になった埋め込みフィールドのフィールドやメソッドfを参照することもあります。
fに到達するまでに走査された埋め込みフィールドの数を、Tにおける深さ(''The depth'')と呼びます。
Tの埋め込みフィールドAで宣言されたフィールドまたはメソッドfの深さは、Aのfの深さに1を加えたものです。

セレクタには以下のルールが適用されます。

# Tがポインターやインタフェース型ではないTまたは*T型の値xに対しては、x.fはTの中で最も浅い深さにあるフィールドまたはメソッドを示し、そのようなfが存在します。
# Iがインタフェース型であるI型の値xに対して、x.fはxの動的な値の名前fを持つ実際のメソッドを示す。Iのメソッドセットに名前fを持つメソッドがない場合、セレクター式は違法である。
# 例外として、xの型が定義されたポインター型で、(*x).fがフィールド（メソッドではない）を表す有効なセレクター式の場合、x.fは(*x).fの短縮形となります。それ以外の場合には、x.fは不正です。
# xがポインター型で値がnilであり、x.fが構造体のフィールドを示す場合、x.fへの代入や評価はランタイム・パニックを引き起こします。
# xがインターフェイス型で値がnilの場合、メソッドx.fを呼び出したり評価したりすると、ランタイム・パニックが発生します。

;宣言の例:<syntaxhighlight lang=go>
type T0 struct {
	x int
}

func (*T0) M0()

type T1 struct {
	y int
}

func (T1) M1()

type T2 struct {
	z int
	T1
	*T0
}

func (*T2) M2()

type Q *T2

var t T2     // with t.T0 != nil
var p *T2    // with p != nil and (*p).T0 != nil 
var q Q = p
</syntaxhighlight>
;次のように書けます:<syntaxhighlight lang=go>
t.z          // t.z
t.y          // t.T1.y
t.x          // (*t.T0).x

p.z          // (*p).z
p.y          // (*p).T1.y
p.x          // (*(*p).T0).x

q.x          // (*(*q).T0).x        (*q).x is a valid field selector

p.M0()       // ((*p).T0).M0()      M0 expects *T0 receiver
p.M1()       // ((*p).T1).M1()      M1 expects T1 receiver
p.M2()       // p.M2()              M2 expects *T2 receiver
t.M2()       // (&t).M2()           M2 expects *T2 receiver, see section on Calls
</syntaxhighlight>

;以下は無効です:<syntaxhighlight lang=go>
q.M0()       // (*q).M0 is valid but not a field selector
</syntaxhighlight>

== メソッド式 ==
メソッド式(''Method expressions'')<ref name="Method_expressions">{{cite book
| url = https://golang.org/ref/spec#Method_expressions
| title = The Go Programming Language Specification
| chapter = Method expressions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

Mが型Tのメソッドの集合にある場合、T.Mは、Mと同じ引数にメソッドのレシーバーである追加の引数を前置した通常の関数として呼び出し可能な関数である。

;構文:<syntaxhighlight lang="ebnf">
MethodExpr    = ReceiverType "." MethodName ; 
ReceiverType  = Type ;
</syntaxhighlight>

T型の構造体に、T型のレシーバーを持つMvと、*T型のレシーバーを持つMpという2つのメソッドがあるとします。

:<syntaxhighlight lang=go>
type T struct {
	a int
}
func (tv  T) Mv(a int) int         { return 0 }  // value receiver
func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
 
var t T
</syntaxhighlight>
;式:<syntaxhighlight lang=go>
T.Mv
</syntaxhighlight>
は、Mvと同等の関数を生成しますが、第1引数に明示的なレシーバーを指定します。これは、
;シグネチャ:<syntaxhighlight lang=go>
func(tv T, a int) int
</syntaxhighlight>
この関数は通常、明示的なレシーバーを使って呼び出すことができるので、これらの5つの呼び出しは同等です。
;さまざまな呼び出し:<syntaxhighlight lang=go>
t.Mv(7)
T.Mv(t, 7)
(T).Mv(t, 7)
f1 := T.Mv; f1(t, 7) 
f2 := (T).Mv; f2(t, 7)
</syntaxhighlight>
同様に、
;式:<syntaxhighlight lang=go>
(*T).Mp
</syntaxhighlight>
のシグネチャーを持つMpを表す関数値が得られます。
----
:<syntaxhighlight lang=go>
func(tp *T, f float32) float32
</syntaxhighlight>
値のレシーバーを持つメソッドでは，明示的なポインターのレシーバーを持つ関数を派生させることができます．

:<syntaxhighlight lang=go>
(*T).Mv
</syntaxhighlight>
というシグネチャを持つMvを表す関数値が得られます。

:<syntaxhighlight lang=go>
func(tv *T, a int) int
</syntaxhighlight>
このような関数は、レシーバーを介して間接的に値を生成し、基礎となるメソッドにレシーバーとして渡します。このメソッドは、関数呼び出しでアドレスが渡された値を上書きしません。

ポインター・レシーバー・メソッドに対する値レシーバー関数という最後のケースは、ポインター・レシーバー・メソッドが値型のメソッド・セットに含まれていないため、違法です。

メソッドから派生した関数値は、関数呼び出し構文で呼び出され、レシーバーは呼び出しの第一引数として提供されます。つまり、f := T.Mvが与えられた場合、fはt.f(7)ではなくf(t, 7)として呼び出されます。レシーバーを束縛する関数を構築するには、関数リテラルまたはメソッド値を使用します。

インターフェイス型のメソッドから関数値を派生させることは合法です。結果として得られる関数は、そのインタフェース型の明示的なレシーバーを取ります。

== メソッドの値 ==
メソッドの値(''Method values'')<ref name="Method_values">{{cite book
| url = https://golang.org/ref/spec#Method_values
| title = The Go Programming Language Specification
| chapter = Method values¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

式xが静的型Tを持ち、Mが型Tのメソッドセットにある場合、x.Mはメソッド値と呼ばれる。メソッド値x.Mは、x.Mのメソッド呼び出しと同じ引数で呼び出し可能な関数値である。式xはメソッド値の評価中に評価されて保存され、保存されたコピーは後に実行される可能性のある呼び出しのレシーバーとして使用される。

型Tはインターフェイス型でも非インターフェイス型でもよい。

前述のメソッド式の説明と同様に、型Tの構造体に2つのメソッドMv（レシーバーがT型）とMp（レシーバーが*T型）があるとします。
:<syntaxhighlight lang=go>
type T struct {
	a int
}

func (tv T) Mv(a int) int          { return 0 } // 値のレシーバー
func (tp *T) Mp(f float32) float32 { return 1 } // ポインターレシーバー

var t T
var pt *T

func makeT() T
</syntaxhighlight>

;式:<syntaxhighlight lang=go>
t.Mv
</syntaxhighlight>
:は、次の型の関数値を得ることができます。
:<syntaxhighlight lang=go>
func(int) int
</syntaxhighlight>

次の2つの呼び出しは等価です。
:<syntaxhighlight lang=go>
t.Mv(7)
f := t.Mv; f(7)
</syntaxhighlight>

同様に、
;式:<syntaxhighlight lang=go>
pt.Mp
</syntaxhighlight>
:は、次の型の関数値が得られます。
:<syntaxhighlight lang=go>
func(float32) float32
</syntaxhighlight>

セレクタと同様に、ポインタを使った値のレシーバを持つ非インターフェイスのメソッドを参照すると、そのポインタは自動的に参照解除されます：pt.Mvは(*pt).Mvと同等です。

メソッドコールと同様に、アドレス指定可能な値を使用したポインターレシーバを持つ非インターフェースメソッドへの参照は、自動的にその値のアドレスを取ります：t.Mpは(&t).Mpと同等です。

:<syntaxhighlight lang=go>
f := t.Mv; f(7)  // t.Mv(7)と同じです。
f := pt.Mp; f(7) // pt.Mp(7)のようになります。
f := pt.Mv; f(7) // (*pt).Mv(7)のようになります。
f := t.Mp; f(7)  // (&t).Mp(7)のようになります。
f := makeT().Mp  // 無効：makeT()の結果はアドレス指定できない
</syntaxhighlight>
上記の例では非インターフェイス型を使用していますが、インターフェイス型の値からメソッドの値を生成することも合法です。

:<syntaxhighlight lang=go>
var i interface { M(int) } = myVal
f := i.M; f(7) // i.M(7)のようなもの
</syntaxhighlight>

== インデックス式 ==
インデックス式(''Index expressions'')<ref name="Index_expressions">{{cite book
| url = https://golang.org/ref/spec#Index_expressions
| title = The Go Programming Language Specification
| chapter = Index expressions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

;一次式:<syntaxhighlight lang=go>
a[x]
</syntaxhighlight>
は、配列の要素、配列へのポインタ、スライス、文字列、マップのうち、x でインデックスされたものを表し、以下のルールが適用されます。

;<code>a</code> がマップでない場合
: インデックス <code>x</code> は、整数型または型付けされていない定数でなければなりません。
: 定数のインデックスは非負であり、<code>int</code>型の値で表現できなければならない。
: 型付けされていない定数のインデックスは<code>int</code>型で与えられる。
: インデックス <code>x</code> は、<code>0 <= x < len(a)</code> の場合は ''in range'' であり、そうでない場合は ''out of range'' である。
;<code>a</code>が配列型 <code>A</code> の場合
: aの定数インデックスは範囲内でなければならない
: 実行時に <code>x</code> が範囲外の場合、ランタイム・パニックが発生します。
: <code>a[x]</code> はインデックス <code>x</code> の配列要素であり、<code>a[x]</code> の型は <code>A</code> の要素の型である。
;<code>a</code>が配列型へのポインタ <code>A</code> の場合
: <code>a[x]</code>は <code>(*a)[x]</code> の省略形です。
;<code>a</code>がスライス型 <code>S</code> の場合
: 実行時にxが範囲外の場合、ランタイム・パニックが発生する
: <code>a[x]</code> はインデックス <code>x</code> のスライス要素であり、<code>a[x]</code> の型は <code>S</code> の要素型です。
;<code>a</code>が文字列型の場合
: 文字列aが定数の場合、定数のインデックスは範囲内でなければなりません。
: 実行時に <code>x</code> が範囲外の場合、ランタイム・パニックが発生します。
: <code>a[x]</code> はインデックス <code>x</code> の非定数のバイト値であり、<code>a[x]</code> の型はbyteである。
: <code>a[x]</code> に代入することはできない。
;<code>a</code>がマップ型 <code>M</code> の場合
: <code>x</code>の型は、<code>M</code> のキー型に割り当て可能でなければならない。
: マップにキーxのエントリがある場合、<code>a[x]</code> はキーxのマップ要素であり、<code>a[x]</code> のタイプは <code>M</code> の要素タイプである。
: マップが nil であるか、そのようなエントリを含まない場合、<code>a[x]</code> は <code>M</code> の要素タイプのゼロ値である．
: それ以外の場合、<code>a[x]</code> は不正である。

map[K]V型のマップaに対するインデックス式で、特別な形式の代入または初期化で使用されます。

;例:<syntaxhighlight lang=go>
v, ok = a[x] (v, ok = a[x])
v, ok := a[x] (v, ok = a[x])
var v, ok = a[x].
</syntaxhighlight>

は、追加の型付けされていない真理値をもたらします。ok の値は、キー x がマップ内に存在する場合は '''true'''、そうでない場合は '''false''' です。

nilマップの要素に代入するとランタイムパニックを起こします。

== スライス式 ==
スライス式(''Slice expressions'')は、文字列、配列、配列へのポインタ、スライスから部分文字列やスライスを構成します<ref name="Slice_expressions">{{cite book
| url = https://golang.org/ref/spec#Slice_expressions
| title = The Go Programming Language Specification
| chapter = Slice expressions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。下限と上限を指定する単純な形式と、容量の上限も指定する完全な形式の2つのバリエーションがあります。

=== 単純なスライス式 ===
単純なスライス式(''Simple slice expressions'')

文字列、配列、配列へのポインタ、またはスライス a に対して、

;一次式:<syntaxhighlight lang=go>
a[low : high]
</syntaxhighlight>
は、部分文字列またはスライスを構成します。添字 low と high は、オペランド a のどの要素が結果に現れるかを選択します。結果は0から始まるインデックスを持ち、長さはhigh - lowになります。配列aをスライスした後
:<syntaxhighlight lang=go>
a := [5]int{1, 2, 3, 4, 5} 
s := a[1:4]
</syntaxhighlight>
このスライスsは、型が[]int、長さが3、容量が4、そして要素が
:<syntaxhighlight lang=go>
s[0] == 2
s[1] == 3
s[2] == 4
</syntaxhighlight>
便宜上、いずれかのインデックスを省略することができます．低位のインデックスがない場合のデフォルトはゼロで、高位のインデックスがない場合のデフォルトはスライスされたオペランドの長さとなります。

:<syntaxhighlight lang=go>
a[2:] // a[2:len(a)] と同じです。
a[:3] // a[0:3] と同じです。
a[:] // a[0:len(a)]と同じです。
</syntaxhighlight>

aが配列へのポインタの場合、a[low : high]は(*a)[low : high]の省略形です．

配列や文字列の場合、0 <= low <= high <= len(a) であればインデックスは範囲内にあり、そうでなければ範囲外となります．スライスの場合、インデックスの上限は、長さではなく、スライスの容量cap(a)です。定数インデックスは、非負であり、int型の値で表現できなければならない。配列や定数文字列の場合、定数インデックスも範囲内でなければならない。配列や定数文字列の場合、定数インデックスも範囲内でなければなりません。また、両方のインデックスが定数の場合、low <= highを満たさなければなりません。実行時にインデックスが範囲外の場合、ランタイムパニックが発生します。

型付けされていない文字列を除き、スライスされたオペランドが文字列またはスライスの場合、スライス操作の結果はオペランドと同じ型の非定数値になります。型付けされていない文字列オペランドの場合、結果はstring型の非定数値となります。スライスされたオペランドが配列の場合、それはアドレス可能でなければならず、スライス操作の結果は、配列と同じ要素タイプのスライスとなります。

有効なスライス式のスライスされたオペランドが nil スライスの場合、結果は nil スライスになります。それ以外の場合、結果がスライスであれば、オペランドと基礎となる配列を共有します。

:<syntaxhighlight lang=go>
var a [10]int
s1 := a[3:7] // s1の基底配列は配列a; &s1[2] == &a[5] です。
s2 := s1[1:4] // s2の下の配列は、s1の下の配列であり、配列aである。
s2[1] = 42 // s2[1] == s1[2] == a[5] == 42; これらはすべて、同じ基礎となる配列要素を参照しています。
</syntaxhighlight>

=== 完全なスライス式 ===
完全なスライス式(''Full slice expressions'')

配列、配列へのポインタ、スライスa（文字列は不可）の場合、一次式は

:<syntaxhighlight lang=go>
a[low : high : max]
</syntaxhighlight>

は、単純なスライス式a[low : high]と同じ長さと要素を持つ、同じ型のスライスを構築します。さらに、結果として得られるスライスの容量を max - low に設定して制御します。最初のインデックスだけは省略可能で、デフォルトでは0です。

:<syntaxhighlight lang=go>
a := [5]int{1, 2, 3, 4, 5}
t := a[1:3:5]
</syntaxhighlight>

スライスtの型は[]int、長さ2、容量4、要素は

:<syntaxhighlight lang=go>
t[0] == 2
t[1] == 3
</syntaxhighlight>

単純なスライス式としては、aが配列へのポインタの場合、a[low : high : max]は(*a)[low : high : max]の省略形となります。スライスされたオペランドが配列の場合は、アドレス指定可能でなければなりません。

添字は、0 <= low <= high <= max <= cap(a) であれば範囲内、そうでなければ範囲外となります。定数のインデックスは、非負で、int型の値で表現できなければなりません。複数のインデックスが定数の場合、存在する定数はお互いに範囲内でなければなりません。実行時にインデックスが範囲外である場合、ランタイム・パニックが発生します。

== 型アサーション ==
型アサーション(''Type assertions'')<ref name="Type_assertions">{{cite book
| url = https://golang.org/ref/spec#Type_assertions
| title = The Go Programming Language Specification
| chapter = Type assertions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

インターフェイス型の式xと型Tに対して、一次式の

:<syntaxhighlight lang=go>
x.(T)
</syntaxhighlight>

は、xがnilではないことと、xに格納されている値がT型であることを主張します。x.(T)という表記はタイプアサーションと呼ばれる。

より正確には、Tがインターフェース型でない場合、x.(T)はxの動的型がT型と同一であることを主張する。
この場合、Tはxの（インターフェース）型を実装しなければならない。
そうでなければ、xがT型の値を格納することはできないので、型の主張は無効である。
Tがインターフェイス型の場合、xの動的型がインターフェイスTを実装していることをx.(T)が主張する。

型の主張が成り立つ場合、式の値はxに格納されている値であり、その型はTである。
型の主張が偽の場合、ランタイムパニックが発生する。
つまり、xの動的な型は実行時にしかわからないにもかかわらず、正しいプログラムではx.(T)の型はTであることがわかっているのです。

:<syntaxhighlight lang=go>
var x interface{} = 7 // x は動的型が int で値が 7 です。
i := x.(int) // iはint型で値は7です。

type I interface { m() }.

func f(y I) {.
	s := y.(string) // 不正: stringはIを実装していない (メソッドmがない)
	r := y.(io.Reader) // r は io.Reader 型であり、y の動的型は I と io.Reader の両方を実装していなければならない
	...
}
</syntaxhighlight>

特殊な形式の代入または初期化で使用されるタイプアサーション

:<syntaxhighlight lang=go>
v, ok = x.(T)
v, ok := x.(T)
var v, ok = x.(T)
var v, ok interface{} = x.(T) // v と ok の動的な型は T と bool です。
</syntaxhighlight>

は、追加の型付けされていないブール値を出力します。
アサーションが成立していれば ok の値は真です。
それ以外の場合は偽となり、vの値はT型のゼロ値となります。
この場合、ランタイム・パニックは発生しません。

== 呼び出し ==
呼び出し(''Calls'')<ref name="Calls">{{cite book
| url = https://golang.org/ref/spec#Calls
| title = The Go Programming Language Specification
| chapter = Calls¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

関数型Fの式fが与えられます。

:<syntaxhighlight lang=go>
f(a1, a2, ... an)
</syntaxhighlight>

は、引数 a1, a2, ... an で f を呼び出します。1つの特別な場合を除いて、引数はFのパラメータ型に割り当て可能な単一値の式でなければならず、関数が呼び出される前に評価されます。
式の型はFの結果の型です。メソッドの呼び出しも同様ですが、メソッド自体は、メソッドのレシーバ型の値のセレクタとして指定されます。

:<syntaxhighlight lang=go>
math.Atan2(x, y) // 関数呼び出し
var pt *Point
pt.Scale(3.5) // レシーバ pt でのメソッド呼び出し
</syntaxhighlight>

関数呼び出しでは、関数値と引数が通常の順序で評価されます。
評価された後、呼び出しのパラメータは値で関数に渡され、呼び出された関数は実行を開始します。
関数の戻りパラメータは、関数が戻るときに呼び出し元に値で返されます。

nilの関数値を呼び出すと、ランタイム・パニックが発生します。

特殊なケースとして、関数やメソッドgの戻り値が同数で、別の関数やメソッドfのパラメータに個別に割り当て可能な場合、f(g(parameters_of_g))という呼び出しは、gの戻り値をfのパラメータに順に束縛した後にfを呼び出すことになります。
fの呼び出しには、gの呼び出し以外のパラメータを含んではならず、gは少なくとも1つの戻り値を持っていなければなりません。
fに最後の...パラメータがある場合は、通常のパラメータを割り当てた後に残ったgの戻り値が割り当てられます。

:<syntaxhighlight lang=go>
func Split(s string, pos int) (string, string) {。
	return s[0:pos], s[pos:].
}

func Join(s, t string) 文字列 {.
	return s + t
}

if Join(Split(value, len(value)/2)) !=value {。
	log.Panic("test fails")
}
</syntaxhighlight>

メソッドコール x.m() は、x の (その型の) メソッドセットに m が含まれ、引数リストが m のパラメータリストに割り当てられる場合に有効です。
x がアドレス可能で、&x のメソッドセットに m が含まれる場合、x.m() は (&x).m() の短縮形となります。

:<syntaxhighlight lang=go>
var p ポイント
p.Scale(3.5)
</syntaxhighlight>
明確なメソッドタイプはなく、メソッド・リテラルも存在しません。

== 仮引数に ... パラメーターを渡す ==
仮引数に ... パラメーターを渡す(''Passing arguments to ... parameters'')<ref name="Passing_arguments_to_..._parameters">{{cite book
| url = https://golang.org/ref/spec#Passing_arguments_to_..._parameters
| title = The Go Programming Language Specification
| chapter = Passing arguments to ... parameters¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>

fが、最終パラメータpが...T型のバリアディック型である場合、f内ではpの型は[]T型と同等です。
fがpの実際の引数を持たずに呼び出された場合、pに渡される値はnilです。
そうでなければ、渡される値は[]T型の新しいスライスで、連続した要素が実際の引数である新しい基礎的な配列であり、これらは全てTに割り当て可能でなければなりません。
したがって、スライスの長さと容量はpに束縛された引数の数であり、各呼び出しサイトで異なる可能性があります。

次のような関数と呼び出しがあります。

:<syntaxhighlight lang=go>
func Greeting(prefix string, who ...string)
Greeting("nobody")
Greeting("hello:", "Joe", "Anna", "Eileen")
</syntaxhighlight>

Greetingの中で、whoは最初の呼び出しではnilという値を持ち、2回目の呼び出しでは[]string{"Joe", "Anna", "Eileen"}という値を持ちます。

最後の引数がスライスタイプ []T に割り当て可能で、その後に ... が続く場合、それは ...T パラメータの値として変更されずに渡されます。この場合、新しいスライスは作成されません。

スライスsとコールが与えられると

:<syntaxhighlight lang=go>
s := []string{"James", "Jasmine"}
Greeting("goodbye:", s...)
</syntaxhighlight>
を呼び出すと、Greetingの中では、同じ配列を持つsと同じ値を持つことになります。

== 演算子 ==
演算子(''Operators'')は、は、オペランドを組み合わせて式を作ります<ref name="Operators">{{cite book
| url = https://golang.org/ref/spec#Operators
| title = The Go Programming Language Specification
| chapter = Operators¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
;構文:<syntaxhighlight lang="ebnf">
Expression = UnaryExpr | Expression binary_op Expression ;
UnaryExpr  = PrimaryExpr | unary_op UnaryExpr ;

binary_op  = "||" | "&&" | rel_op | add_op | mul_op ;
rel_op     = "==" | "!=" | "<" | "<=" | ">" | ">=" ;
add_op     = "+" | "-" | "|" | "^" .
mul_op     = "*" | "/" | "%" | "<<" | ">>" | "&" | "&^" ;

unary_op   = "+" | "-" | "!" | "^" | "*" | "&" | "<-" ;
</syntaxhighlight>
比較については別の場所で説明します。他の二項演算子では、シフトや型付けされていない定数を含む演算でない限り、オペランドの型は同一でなければなりません。定数のみを扱う演算については、定数式の項を参照してください。

シフト演算を除き、一方のオペランドが型付けされていない定数で、もう一方のオペランドが型付けされていない場合、定数は暗黙のうちにもう一方のオペランドの型に変換されます。

シフト式の右オペランドは、整数型であるか、またはuint型の値で表現可能な型付けされていない定数でなければなりません。定数ではないシフト式の左オペランドが型付けされていない定数の場合、まずその左オペランドだけでシフト式を置き換えた場合に想定される型に暗黙のうちに変換されます。

;例:<syntaxhighlight lang=go>
var a [1024]byte
var s uint = 33

// The results of the following examples are given for 64-bit ints.
var i = 1<<s                   // 1 has type int
var j int32 = 1<<s             // 1 has type int32; j == 0
var k = uint64(1<<s)           // 1 has type uint64; k == 1<<33
var m int = 1.0<<s             // 1.0 has type int; m == 1<<33
var n = 1.0<<s == j            // 1.0 has type int32; n == true
var o = 1<<s == 2<<s           // 1 and 2 have type int; o == false
var p = 1<<s == 1<<33          // 1 has type int; p == true
var u = 1.0<<s                 // illegal: 1.0 has type float64, cannot shift
var u1 = 1.0<<s != 0           // illegal: 1.0 has type float64, cannot shift
var u2 = 1<<s != 1.0           // illegal: 1 has type float64, cannot shift
var v float32 = 1<<s           // illegal: 1 has type float32, cannot shift
var w int64 = 1.0<<33          // 1.0<<33 is a constant shift expression; w == 1<<33
var x = a[1.0<<s]              // panics: 1.0 has type int, but 1<<33 overflows array bounds
var b = make([]byte, 1.0<<s)   // 1.0 has type int; len(b) == 1<<33

// The results of the following examples are given for 32-bit ints,
// which means the shifts will overflow.
var mm int = 1.0<<s            // 1.0 has type int; mm == 0
var oo = 1<<s == 2<<s          // 1 and 2 have type int; oo == true
var pp = 1<<s == 1<<33         // illegal: 1 has type int, but 1<<33 overflows int
var xx = a[1.0<<s]             // 1.0 has type int; xx == a[0] 
var bb = make([]byte, 1.0<<s)  // 1.0 has type int; len(bb) == 0
</syntaxhighlight>

== 演算子の優先順位 ==
演算子の優先順位(''Operator precedence'')

単項演算子(UnaryExpr)が最も高い優先順位を持ちます。
++および--演算子は、式ではなく文を形成するため、演算子の階層から外れます。
そのため、文 *p++ は (*p)++ と同じになります。

二項演算子には5つの優先順位があります。
乗算演算子の優先順位が最も高く、次に加算演算子、比較演算子、&&（論理AND）、最後に｜｜（論理OR）が続きます。
{| class="wikitable"
|+ 二項演算子には5つの優先順位
! 優先順位 !! 演算子
|-
! 5
| <syntaxhighlight lang=go inline>  *  /  %  <<  >>  &  &^ </syntaxhighlight>
|-
! 4
| <syntaxhighlight lang=go inline> +  -  |  ^ </syntaxhighlight>
|-
! 3
| <syntaxhighlight lang=go inline> ==  !=  <  <=  >  >= </syntaxhighlight>
|-
! 2
| <syntaxhighlight lang=go inline> && </syntaxhighlight>
|-
!    1 
| <syntaxhighlight lang=go inline> || </syntaxhighlight>
|}

同じ優先順位の二項演算子は、左から右へと関連付けられます。例えば、x / y * z は、(x / y) * z と同じです。
:代入は演算子ではなく文なので、結合法則とは無関係です（Goでは、C言語のような多重代入 <syntaxhighlight lang=c inline> a = b = 0 </syntaxhighlight> は許されません）。

;例:<syntaxhighlight lang=go>
+x
23 + 3*x[i]
x <= f()
^a >> b
f() || g() 
x == y+1 && <-chanInt > 0
</syntaxhighlight>

=== 算術演算子 ===
算術演算子(Arithmetic operators)は、数値に適用され、第一オペランドと同じ型の結果を得ることができます。4つの標準的な算術演算子(+, -, *, /) は、整数型、浮動小数点型、複素数型に適用され、+は文字列にも適用されます。ビットごとの論理演算子とシフト演算子は、整数型にのみ適用されます<ref name="Arithmetic_operators">{{cite book
| url = https://golang.org/ref/spec#Arithmetic_operators
| title = The Go Programming Language Specification
| chapter = Arithmetic operators¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
{| class="wikitable"
|+ 算術演算子
! 記号 !! 意味 !! 取りうるオペランド
|-
! +
| 和（連結 文字列）|| 整数型、浮動小数点数型、複素数値、文字列型
|-
! -
| 差 || 整数型、浮動小数点数型、複素数値、文字列型
|-
! *
| 積 || 整数型、浮動小数点数型、複素数値
|-
! /
| 商 || 整数型、浮動小数点数型、複素数値
|-
! %
| 剰余 || 整数型
|-
! &
| ビット毎の論理積 || 整数型
|-
! <nowiki>|</nowiki>
| ビット毎の論理和 || 整数型
|-
! ^
| ビット毎の排他的論理和 || 整数型
|-
! &^
| ビットクリア (AND NOT) || 整数型
|-
! <<
| 左シフト || 整数 << 整数 >= 0
|-
! >>
| 右シフト || 整数 >> 整数 >= 0
|}

==== 整数演算子 ====
整数演算子(''Integer operators'')<ref name="Arithmetic_operators"/>

2つの整数値xとyに対して、整数の商 <math inline>q = x / y</math> と、剰余 <math inline>r = x \% y</math> は以下の関係を満たす。

:<math>
x = q * y + r \land |r| < |y|
</math>

x / yを0に向かっての切捨て
{| class="wikitable" style="text-align:right"
|+ 除算の切捨て
|-
! x !! y !! x / y !!x % y
|-
| 5 || 3 || 1 || 2
|-
| -5 || 3 || -1 || -2
|-
| 5 || -3 || -1 || 2
|-
| -5 || -3 || 1 || -2
|}

唯一の例外は、被除数xがint型のxに対して最も負の値である場合、2の補数の整数オーバーフローにより、商q = x / -1はxに等しい（およびr = 0）ということです。
{| class="wikitable" style="text-align:right"
|-
| || x, q
|-
! int8
| -128
|-
! int16
| -32768
|-
! int32
| -2147483648
|-
! int64
| -9223372036854775808
|}

除数が定数の場合は、ゼロであってはなりません。実行時に除数がゼロの場合、ランタイムパニックが発生します。被除数が非負で除数が定数の2乗の場合、除算は右シフトで置き換えられ、余剰の計算はビットごとのAND演算で置き換えられます。
{| class="wikitable" style="text-align:right"
|-
! x !! x / 4 !! x % 4 !! x >> 2 !! x & 3
|-
| 11 || 2 || 3 || 2 || 3
|-
|-11 || -2 || -3 || -3 || 1
|}

シフト演算子は、左オペランドを右オペランドで指定されたシフトカウントだけシフトします。実行時にシフトカウントが負の値であった場合、ランタイム・パニックが発生します。シフト演算子は、左オペランドが符号付き整数の場合は算術シフトを、符号なし整数の場合は論理シフトを実行します。シフト回数には上限がありません。シフトは、シフトカウントnに対して、左オペランドが1ずつn回シフトされたように動作します。その結果、x << 1 は x*2 と同じで、x >> 1 は x/2 と同じですが、負の無限大に向かって切り捨てられます。

整数のオペランドに対して、単項演算子の+、-、^は以下のように定義されています。
{| class="wikitable"
| +x || || 0 + x に等しい
|-
| -x || 符号反転 || 0 - x に等しい
|-
| ^x || ビットごとの補数 || 符号なしのxの場合はm = "すべてのビットを1にする "となり、符号付きxではm = -1
|}

===== 整数のオーバーフロー =====
整数のオーバーフロー(''Integer overflow'')<ref name="Arithmetic_operators"/>

符号なし整数値の場合、+, -, *, <<の演算は剰余演算2n（nは符号なし整数の型のビット幅）で計算されます。
大雑把に言うと、これらの符号なし整数の演算はオーバーフロー時に上位ビットを捨てるので、プログラムでは「ラップアラウンド」に頼ることになります。

符号付き整数の場合、 +, -, *, /, <<の各演算は合法的にオーバーフローしても構いませんが、結果として得られる値は符号付き整数表現、演算、およびそのオペランドによって決定論的に定義され、存在します。
オーバーフローはランタイム パニックを引き起こしません。
コンパイラは、オーバーフローが発生しないことを前提にコードを最適化することはできません。
例えば、x < x + 1 が常に真であると仮定することはできません。

==== 浮動小数点演算子 ====
浮動小数点演算子(''Floating-point operators'')<ref name="Arithmetic_operators"/>

浮動小数点および複素数の場合、+xはxと同じで、-xはxの（算術）否定です。浮動小数点または複素数のゼロ除算の結果は、IEEE-754規格以上には規定されておらず、ランタイム・パニックが発生するかどうかは実装に依存します。

実装では、複数の浮動小数点演算を1つの融合した演算にまとめ、場合によっては文をまたいで実行し、丸めて得られる値とは異なる結果を生成することがあります。明示的な浮動小数点型の変換では、対象となる型の精度に合わせて丸めるので、その丸め方を捨ててしまうような融合を防ぐことができます。

たとえば、一部のアーキテクチャでは、中間結果 x*y を丸めずに x*y + z を計算する「融合積和演算」（"fused multiply and add"; FMA）命令が提供されています。これらの例では、Goの実装がその命令を使用できる場合を示しています。

;例:<syntaxhighlight lang=go>
// x*yが明示的に丸められていないので、rを計算するためにFMAが許可されています。
r  = x*y + z
r  = z;   r += x*y
t  = x*y; r = t + z
*p = x*y; r = *p + z
r  = x*y + float64(z)

// FMAは、x*yの丸めを省略することになるので、rの計算には使えません。
r  = float64(x*y) + z
r  = z; r += float64(x*y) 
t  = float64(x*y); r = t + z
</syntaxhighlight>

==== 文字列の連結 ====
文字列の連結(''String concatenation'')<ref name="Arithmetic_operators"/>

文字列は、+演算子や+=代入演算子を使って連結することができます。

;例:<syntaxhighlight lang=go>
s := "こんにちは" + string(c)
s += " そして、さようなら "
</syntaxhighlight>

文字列の加算では、オペランドを連結して新しい文字列を作成します。

=== 比較演算子 ===
比較演算子(''Comparison operators'')は、2つのオペランドを比較し、型付けされていないブール値を出力します<ref name="Comparison_operators">{{cite book
| url = https://golang.org/ref/spec#Comparison_operators
| title = The Go Programming Language Specification
| chapter = Comparison operators¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。

{| class="wikitable"
|+ 比較演算子
|-
| == || 一致
|-
| != || 不一致
|-
| < || より小
|-
| <= || より小あるいは一致
|-
| > || より大
|-
| >= || より大あるいは一致
|}

どのような比較においても、第1オペランドは第2オペランドの型に代入可能でなければならず、またその逆も同様です。

等式演算子 == および != は、比較可能なオペランドに適用されます。順序付け演算子 <, <=, >, >= は、オペランドが順序付けられている場合に適用されます。これらの用語と比較の結果は次のように定義されます。

* ブール値は比較可能です。2つのブール値は、それらが両方とも<code>true</code>または両方とも<code>false</code>である場合、等しい。
* 整数値は、通常の方法で比較可能であり、順序付けられています。
* 浮動小数点値は、IEEE-754規格で定義されているように、比較可能で順序付けられています。
* 複素数の値は比較可能です。<code>u</code>と<code>v</code>の2つの複素数値は、 <code>real(u) == real(v)</code>と <code>imag(u) == imag(v)</code>の両方であれば等しい。
* ポインター値は比較可能です。2つのポインター値は、それらが同じ変数を指しているか、または両方が値 <code>nil</code> を持っている場合、等しい。異なるゼロサイズの変数へのポインターは、等しいかもしれないし、そうでないかもしれない。
* チャネル値は比較可能です。2つのチャンネル値は、<code>make</code>の同じ呼び出しによって作成された場合、または両方とも値が<code>nil</code>である場合には等しい。
* インターフェース値は比較可能です。2つのインタフェース値は、それらが同一のダイナミック・タイプと同一のダイナミック・バリューを持っているか、または両方が値<code>nil</code>を持っている場合、等しい。
* 非インタフェース型の <code>X</code> の値 <code>x</code> とインタフェース型の <code>T</code> の値 <code>t</code> は、 <code>X</code> 型の値が比較可能で、 <code>X</code> が <code>T</code> を実装している場合には、比較可能である。<code>t</code>の動的な型が<code>X</code>と同一であり、 <code>t</code>の動的な値が<code>x</code>と等しい場合、それらは同等である。
* 構造体の値は、それらのすべてのフィールドが同等であれば、同等である。2つの構造体の値は、それらの対応する非空白のフィールドが等しい場合、等しいです。
* 配列要素タイプの値が比較可能な場合、配列値は比較可能です。2つの配列値は、それらの対応する要素が等しい場合、等しいです。

ダイナミック・タイプが同一の 2 つのインターフェイス値を比較すると、そのタイプの値が比較できない場合、ランタイム・パニックが発生します。この動作は、直接的なインタフェース値の比較だけでなく、インタフェース値の配列やインタフェース値のフィールドを持つ構造体を比較する場合にも適用されます。

スライス、マップ、および関数の値は比較できません。ただし、特別な場合として、スライス、マップ、関数の値を事前に宣言された識別子 <code>nil</code> と比較することができる。ポインター、チャネル、インタフェースの値を<code>nil</code>と比較することも許されており、上記の一般的なルールに従っている。

;例:<syntaxhighlight lang=go>
const c = 3 < 4 // c は型付けされていない真理値定数 true

type MyBool bool
var x, y int
var (
	// 比較の結果は型付けされていない真理値です。
	// 通常の代入規則が適用されます。
	b3 = x == y // b3 の型は bool
	b4 bool = x == y // b4 の型は bool
	b5 MyBool = x == y // b5 の型は MyBool
)
</syntaxhighlight>

=== 論理演算子 ===
論理演算子(''Logical operators'')は、真理値に適用され、オペランドと同じ型の結果を得ることができます。右のオペランドは短絡評価されます<ref name="Logical_operators">{{cite book
| url = https://golang.org/ref/spec#Logical_operators
| title = The Go Programming Language Specification
| chapter = Logical operators¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。

:{| class="wikitable"
|+ 論理演算子
|-
| && || 条件付きAND || p && q || もし p なら q さもなくば false
|-
| <nowiki>||</nowiki> || 条件付きOR || p <nowiki>||</nowiki> q || もし p なら true さもなくば q
|-
| ! || 論理否定 || !p  ||  もし p なら false さもなくば true
|}

=== アドレス演算子 ===
T型のオペランドxに対して、アドレス演算子(Address operators)&xは、*T型のxへのポインターを生成します。
オペランドはアドレス可能でなければなりません。
すなわち、変数、ポインター・インダイレクト、スライス・インデックス操作、アドレス可能な構造体オペランドのフィールド・セレクタ、アドレス可能な配列の配列インデックス操作のいずれかでなければなりません<ref name="Address_operators">{{cite book
| url = https://golang.org/ref/spec#Address_operators
| title = The Go Programming Language Specification
| chapter = Address operators¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。
アドレス指定要件の例外として、xは（括弧で囲まれた）複合リテラルでもよい。xの評価がランタイム・パニックを引き起こす場合は、&xの評価も同様です。

xがnilの場合、*xを評価しようとするとランタイム・パニックが発生します。

;例:<syntaxhighlight lang=go>
&x
&a[f(2)]
&Point{2, 3}
*p
*pf(x)

var x *int = nil
*x   // ランタイム・パニックを起こす
&*x  // ランタイム・パニックを起こす
</syntaxhighlight>

=== 受信演算子 ===
チャンネル型のオペランド<code>ch</code>に対して、受信演算子(''Receive operator'')<code><-ch</code>の値は、チャンネル<code>ch</code>から受信した値となる<ref name="Receive_operator">{{cite book
| url = https://golang.org/ref/spec#Receive_operator
| title = The Go Programming Language Specification
| chapter = Receive operator¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。チャネルの方向は受信操作を許可しなければならず、受信操作のタイプはチャネルの要素タイプです。式は、値が利用可能になるまでブロックします。<code>nil</code>チャネルからの受信は永遠にブロックされます。閉じたチャネルでの受信操作は、常に即座に進めることができ、それまでに送信された値がすべて受信された後に、要素タイプのゼロ値が得られます。
;例:<syntaxhighlight lang=go>
 v1 := <-ch
 v2 := <-ch
 f(<-ch)
 <-strobe // クロックパルスまで待ち、受信した値を破棄する
</syntaxhighlight>
特殊な形式の代入や初期化で使われる受信式
;例:<syntaxhighlight lang=go>
 x, ok = <-ch
 x, ok := <-ch
 var x, ok = <-ch
 var x, ok T = <-ch
</syntaxhighlight>
は、通信が成功したかどうかを報告する型付けされていない真理値の結果を追加します。
<var>ok</var>の値は、受信した値がチャネルへの送信操作が成功して配信されたものであれば<code>true</code>、チャネルが閉じていて空であるために生成されたゼロの値であれば<code>false</code>である。

=== 変換演算子 ===
変換演算子(''Conversions'')は、式の型を、変換によって指定された型に変更します。変換は、ソースの中で文字通りに現れるかもしれませんし、式が現れる文脈によって暗示されるかもしれません<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>。

明示的な変換は、T(x)という形式の式で、Tは型であり、xはT型に変換できる式である。

;構文:<syntaxhighlight lang=ebnf>
Conversion = Type "(" Expression [ "," ] ")" ;
</syntaxhighlight>

型が演算子*や<-で始まる場合、あるいは型がキーワード'''func'''で始まり結果リストを持たない場合は、曖昧さを避けるために必要に応じて括弧を付けなければなりません。

;例:<syntaxhighlight lang=go>
*Point(p)       // *(Point(p))と同じです。
(*Point)(p)     // pは*Pointに変換される
<-chan int(c)   // 同じく <-(chan int(c))
(<-chan int)(c) // c は <chan int> に変換されます。
func()(x)       // 関数の署名 func() x
(func())(x)     // xはfunc()に変換される
(func() int)(x) // xはfunc() intに変換される
func() int(x)   // xはfunc()intに変換される(曖昧ではない)
</syntaxhighlight>

定数値xは、xがTの値で表現できる場合、T型に変換することができます。特殊なケースとして、整数の定数xは、非定数xの場合と同じ規則を使って、明示的に文字列型に変換することができます。

定数を変換すると、結果として型付きの定数が得られます。

;例:<syntaxhighlight lang=go>
uint(iota)              // uint型のiota値
float32(2.718281828)    // float32型の2.718281828
complex128(1)           // complex128型の1.0 + 0.0i
float32(0.49999999)     // float32型の0.5
float64(-1e-1000)       // float64型の0.0
string('x')             // string型の "x"
string(0x266c)          // "♬" 型の文字列
MyString("foo" + "bar") // MyString型の "foobar"
string([]byte{'a'})     // 定数ではありません：[]byte{'a'}は定数ではありません
(*int)(nil)             // 定数ではありません： nil は定数ではなく、*int は真偽値、数値、文字列のいずれの型でもありません
int(1.2)                // 違法: 1.2はintとして表現できない
string(65.0)            // 違法: 65.0 は整数型の定数ではない
</syntaxhighlight>

非定数値xは、これらのいずれかの場合にT型に変換することができます。

* <code>x</code> は <code>T</code> に代入可能
* structタグ（以下を参照）を無視して、<code>x</code>の型と<code>T</code>は同一の基礎型を持っている
* structタグ（以下を参照）を無視して、<code>x</code>の型と<code>T</code>は定義された型ではないポインタ型であり、それらのポインタの基本型は同一の基礎型を持っている
* <code>x</code>の型と<code>T</code>がともに整数型または浮動小数点型
* <code>x</code>の型と<code>T</code> が共に複素数型
* <code>x</code> は整数、またはバイトやルーンのスライスで、<code>T</code>が文字列型
* <code>x</code> は文字列で、<code>T</code> はバイトまたはルーンのスライス
* <code>x</code> はスライス、<code>T</code> は配列へのポインタであり、スライス型と配列型は同一の要素型

変換のために構造体タイプの同一性を比較する場合、構造体タグは無視されます。

;例:<syntaxhighlight lang=go>
type Person struct {
	Name    string
	Address *struct {
		Street string
		City   string
	}
}

var data *struct {
	Name    string `json:"name"`
	Address *struct {
		Street string `json:"street"`
		City   string `json:"city"`
	} `json:"address"`
}

var person = (*Person)(data) // タグを無視しても、基本的な型は同じです。
</syntaxhighlight>

特定の規則は、数値型間や文字列型との間の（非定数）変換に適用されます。これらの変換は、xの表現を変更する可能性があり、実行時のコストが発生します。他のすべての変換は、型を変えるだけで、xの表現を変えません。

ポインタと整数の間を変換する言語的なメカニズムはありません。unsafe パッケージは、制限された状況下でこの機能を実装しています。

==== 数値型間の変換 ====
数値型間の変換(''Conversions between numeric types'')

定数でない数値の変換には、以下のルールが適用されます。

# 整数型間の変換では、値が符号付き整数であれば、暗黙の無限精度に符号拡張され、そうでなければゼロ拡張されます。そして、結果の型のサイズに収まるように切り捨てられます。例えば、<code>v := uint16(0x10F0)</code>であれば、<code>uint32(int8(v)) == 0xFFFFFFF0</code>となります。この変換では、常に有効な値が得られ、オーバーフローの表示はありません。
# 浮動小数点数を整数に変換する場合、端数は捨てられます（0に向かって切り捨てられます）。
# 整数や浮動小数点数を浮動小数点型に、複素数を別の複素数型に変換する場合、結果の値は、変換先の型で指定された精度に丸められます。例えば、<code>float32</code>型の変数<code>x</code>の値は、IEEE754の32ビット数よりも高い精度で格納されている可能性がありますが、float32(x)は<code>x</code>の値を32ビット精度に丸めた結果を表します。同様に、<code>x + 0.1</code>は32ビット以上の精度を使ってもよいが、<code>float32(x + 0.1)</code>はそうではない。

浮動小数点または複素数の値を含むすべての非定数変換において、結果の型がその値を表現できない場合、変換は成功しますが、結果の値は実装に依存します。

==== 文字列型との間の変換 ====
文字列型との間の変換(''Conversions to and from a string type'')

# 符号付きまたは符号なしの整数値を文字列型に変換すると、その整数値の UTF-8 表現を含む文字列が得られます。有効なUnicodeコードポイントの範囲外の値は、<code>"\uFFFD"</code>に変換されます。<syntaxhighlight lang=go>
string('a')       // "a"
string(-1)        // "\ufffd" == "\xef\xbf\xbd"
string(0xf8)      // "\u00f8" == "ø" == "\xc3\xb8"
type MyString string 
MyString(0x65e5)  // "\u65e5" == "日" == "\xe6\x97\xa5"
</syntaxhighlight>
# スライスされたバイトを文字列に変換すると、スライスされたバイトが連続している文字列になります。<syntaxhighlight lang=go>
string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'})   // "hellø"
string([]byte{})                                     // ""
string([]byte(nil))                                  // ""

type MyBytes []byte
string(MyBytes{'h', 'e', 'l', 'l', '\xc3', '\xb8'})  // "hellø"
</syntaxhighlight>
# 文字列型の値をルーン型のスライスに変換すると、文字列の個々の Unicode コードポイントを含むスライスが得られます。<syntaxhighlight lang=go>
string([]rune{0x767d, 0x9d6c, 0x7fd4})   // "\u767d\u9d6c\u7fd4" == "白鵬翔"
string([]rune{})                         // ""
string([]rune(nil))                      // ""

type MyRunes []rune 
string(MyRunes{0x767d, 0x9d6c, 0x7fd4})  // "\u767d\u9d6c\u7fd4" == "白鵬翔"
</syntaxhighlight>
# 文字列型の値をバイト型のスライスに変換すると、文字列のバイトを連続した要素とするスライスが得られます。<syntaxhighlight lang=go>
[]byte("hellø")   // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
[]byte("")        // []byte{}

MyBytes("hellø")  // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
</syntaxhighlight>
# 文字列型の値をルーン型のスライスに変換すると、その文字列の個々のUnicodeコードポイントを含むスライスが得られます。<syntaxhighlight lang=go>
[]rune(MyString("白鵬翔"))  // []rune{0x767d, 0x9d6c, 0x7fd4}
[]rune("")                 // []rune{}

MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}
</syntaxhighlight>

==== スライスから配列ポインタへの変換 ====
スライスから配列ポインタへの変換(''Conversions from slice to array pointer'')

スライスを配列ポインタに変換すると、スライスの基礎となる配列へのポインタが得られます。スライスの長さが配列の長さよりも小さい場合、ランタイム・パニックが発生します。

<syntaxhighlight lang=go>
s := make([]byte, 2, 4)
s0 := (*[0]byte)(s)      // s0 != nil
s1 := (*[1]byte)(s[1:])  // &s1[0] == &s[1]
s2 := (*[2]byte)(s)      // &s2[0] == &s[0]
s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)

var t []string
t0 := (*[0]string)(t)    // t0 == nil
t1 := (*[1]string)(t)    // panics: len([1]string) > len(t)

u := make([]byte, 0) 
u0 := (*[0]byte)(u)       // u0 != nil
</syntaxhighlight>

== 定数式 ==
定数式(Constant expressions)は、定数のオペランドのみを含み、コンパイル時に評価されます<ref name="Constant_expressions">{{cite book
| url = https://golang.org/ref/spec#Constant_expressions
| title = The Go Programming Language Specification
| chapter = Constant expressions¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。

型付けされていない論理値、数値、文字列の各定数は、論理値、数値、文字列の各型のオペランドを使用することが可能な場所であれば、オペランドとして使用できます。

定数比較では、常に型付けされていない真偽値定数が得られます。定数シフト式の左オペランドが型付けされていない定数の場合、その結果は整数定数になりますが、そうでない場合は左オペランドと同じ型の定数になります。

型付けされていない定数に対するその他の操作は、同じ種類の型付けされていない定数、つまり、真偽値、整数、浮動小数点、複素数、または文字列定数になります。二項演算（シフトを除く）の型付けされていないオペランドが異なる種類の場合、結果はこのリストの後の方に出てくるオペランドの種類（整数、ルーン、浮動小数点、複素数）になります。例えば、型付けされていない整数定数を型付けされていない複素数定数で割ると、型付けされていない複素数定数になります。

;例:<syntaxhighlight lang=go>
const a = 2 + 3.0          // a == 5.0   (untyped floating-point constant)
const b = 15 / 4           // b == 3     (untyped integer constant)
const c = 15 / 4.0         // c == 3.75  (untyped floating-point constant)
const Θ float64 = 3/2      // Θ == 1.0   (type float64, 3/2 is integer division)
const Π float64 = 3/2.     // Π == 1.5   (type float64, 3/2. is float division)
const d = 1 << 3.0         // d == 8     (untyped integer constant)
const e = 1.0 << 3         // e == 8     (untyped integer constant)
const f = int32(1) << 33   // illegal    (constant 8589934592 overflows int32)
const g = float64(2) >> 1  // illegal    (float64(2) is a typed floating-point constant)
const h = "foo" > "bar"    // h == true  (untyped boolean constant)
const j = true             // j == true  (untyped boolean constant)
const k = 'w' + 1          // k == 'x'   (untyped rune constant)
const l = "hi"             // l == "hi"  (untyped string constant)
const m = string(k)        // m == "x"   (type string)
const Σ = 1 - 0.707i       //            (untyped complex constant)
const Δ = Σ + 2.0e-4       //            (untyped complex constant)
const Φ = iota*1i - 1/1i   //            (untyped complex constant)
</syntaxhighlight>

型付けされていない整数、ルーン、または浮動小数点の定数に組み込み関数complexを適用すると、型付けされていない複素数の定数が得られます。

;例:<syntaxhighlight lang=go>
const ic = complex(0, c)   // ic == 3.75i  (untyped complex constant)
const iΘ = complex(0, Θ)   // iΘ == 1i     (type complex128)
</syntaxhighlight>

定数式は常に正確に評価されますが、中間値や定数自体は、言語で事前に宣言された型がサポートするよりもはるかに大きな精度を必要とする場合があります。以下は合法的な宣言です。

;例:<syntaxhighlight lang=go>
const Huge = 1 << 100         // Huge == 1267650600228229401496703205376  (untyped integer constant) 
const Four int8 = Huge >> 98  // Four == 4                                (type int8)
</syntaxhighlight>

定数除算または剰余演算の除数は、ゼロであってはなりません。

;例:<syntaxhighlight lang=go>
3.14 / 0.0   // illegal: division by zero
</syntaxhighlight>

型付けされた定数の値は、常に定数の型の値で正確に表現できなければなりません。以下の定数表現は不正です。

;例:<syntaxhighlight lang=go>
uint(-1)     // -1 cannot be represented as a uint
int(3.14)    // 3.14 cannot be represented as an int
int64(Huge)  // 1267650600228229401496703205376 cannot be represented as an int64
Four * 300   // operand 300 cannot be represented as an int8 (type of Four) 
Four * 100   // product 400 cannot be represented as an int8 (type of Four)
</syntaxhighlight>

単項のビットごとの補数演算子^が使用するマスクは、非定数のルールに一致します。マスクは、符号なしの定数ではすべて1、符号付きおよび型付けされていない定数では-1になります。

;例:<syntaxhighlight lang=go>
^1         // untyped integer constant, equal to -2
uint8(^1)  // illegal: same as uint8(-2), -2 cannot be represented as a uint8
^uint8(1)  // typed uint8 constant, same as 0xFF ^ uint8(1) = uint8(0xFE)
int8(^1)   // same as int8(-2)
^int8(1)   // same as -1 ^ int8(1) = -2
</syntaxhighlight>

;実装上の制限:コンパイラーは、型付けされていない浮動小数点または複素数の定数式を計算する際に丸めを使用することがあります。これについては、「定数」のセクションの実装上の制限を参照してください。この丸め処理により、浮動小数点定数式は、無限精度で計算すると整数になる場合でも、整数のコンテキストでは無効になる場合があります（その逆も同様です）。

== 評価順序 ==
評価順序(''Order of evaluation'')

パッケージレベルでは、初期化依存性により、変数宣言の個々の初期化式の評価順序が決定されます。それ以外では、式、代入、または return 文のオペランドを評価する際に、すべての関数呼び出し、メソッド呼び出し、および通信操作が語彙的に左から右の順で評価されます<ref name="Order_of_evaluation">{{cite book
| url = https://golang.org/ref/spec#Order_of_evaluation
| title = The Go Programming Language Specification
| chapter = Order of evaluation¶
| date = Jul 26, 2021
| publisher = The Go website
}}</ref>。

例えば、（関数ローカルの）代入では
;例:<syntaxhighlight lang=go>
y[f()], ok = g(h(), i()+x[j()], <-c), k()
</syntaxhighlight>

関数の呼び出しと通信は、f()、h()、i()、j()、<-c、g()、k()の順に起こります。しかし、xの評価とインデックス付け、yの評価と、イベントの順序は指定されていません。

;例:<syntaxhighlight lang=go>
a := 1
f := func() int { a++; return a }
x := []int{a, f()}            // x may be [1, 2] or [2, 2]: evaluation order between a and f() is not specified
m := map[int]int{a: 1, a: 2}  // m may be {2: 1} or {2: 2}: evaluation order between the two map assignments is not specified 
n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order between the key and the value is not specified
</syntaxhighlight>

関数の呼び出しは、u()、sqr()、v()、f()、v()、g()の順に行われます。

1 つの式の中の浮動小数点演算は、演算子の連想性に従って評価されます。明示的な括弧は、デフォルトの連想性をオーバーライドして評価に影響を与えます。x + (y + z) という式では、y + z の加算が x の加算の前に行われます。

== 脚註 ==
<references />