キーワード

Go言語のconstの基本と使い方について解説

2025-04-15更新日: 2025-04-15

Go言語のconstについて説明します。

Goでは定数を活用することでプログラム内の変更されない値を管理できます。

例えば、複数の定数をグループ化するなど、コードの可読性や保守性が向上する工夫が可能です。

今回はconstの基本的な使い方と注意点について簡潔に解説します。

目次から探す

Go言語におけるconstの基礎
- constの定義と基本構文
- constと変数の違い
constのグループ化
- ブロック構文による定数のまとめ方
- グループ化のメリット
iotaと定数の活用
- iotaの基本動作
- iotaを利用した定数の自動生成
型指定と省略によるconst宣言
- 型指定したconstの宣言方法
- 型推論によるconstの活用方法
まとめ

Go言語におけるconstの基礎

constの定義と基本構文

Go言語では、定数はconstキーワードを用いて宣言します。

定数はメモリに保持される値が固定されるため、プログラム中で変更することができません。

以下は、基本的な定義方法を示すサンプルコードです。

package main
import "fmt"
func main() {
	// 定数の定義
	const Pi = 3.14
	// 定数の使用例
	fmt.Println("定数 Pi の値:", Pi)
}

定数 Pi の値: 3.14

constと変数の違い

定数は宣言時に固定の値と決定され、再代入ができない点が変数と異なります。

変数はvarキーワードを用いて宣言し、プログラムの途中で値を変更できます。

以下のコードはその違いを示しています。

package main
import "fmt"
func main() {
	// 変数の宣言と初期化
	var varValue = 10
	// 定数の宣言
	const constValue = 20
	// 初期状態の出力
	fmt.Println("初期変数の値:", varValue)
	fmt.Println("定数の値:", constValue)
	// 変数は再代入できる
	varValue = 15
	fmt.Println("再代入後の変数の値:", varValue)
}

初期変数の値: 10
定数の値: 20
再代入後の変数の値: 15

constのグループ化

ブロック構文による定数のまとめ方

複数の定数をまとめる場合、ブロック構文を使うとコードが見やすくなります。

括弧内に一連の定数を記述することで、関連する定数を一まとめにできます。

次のサンプルコードをご覧ください。

package main
import "fmt"
func main() {
	// 複数の定数をグループ化して宣言
	const (
		StatusOK       = 200
		StatusNotFound = 404
	)
	fmt.Println("StatusOK:", StatusOK)
	fmt.Println("StatusNotFound:", StatusNotFound)
}

StatusOK: 200
StatusNotFound: 404

グループ化のメリット

定数をグループ化することには以下のメリットがあります。

コード全体の見通しが良くなり、管理が容易になります。
関連する定数をまとめることで、メンテナンス性が向上します。
一箇所で定数の一覧を確認できるため、誤った値の使用を防止できます。

iotaと定数の活用

iotaの基本動作

iotaは、定数の連番を簡単に作成できる仕組みです。

各行ごとに自動的に値がインクリメントされ、初回は0から始まります。

以下のサンプルコードは基本的な使い方を示します。

package main
import "fmt"
func main() {
	// iotaを使って定数に連番を割り当てる
	const (
		A = iota // 0から始まる
		B        // 1になる
		C        // 2になる
	)
	fmt.Println("A:", A)
	fmt.Println("B:", B)
	fmt.Println("C:", C)
}

A: 0
B: 1
C: 2

iotaを利用した定数の自動生成

iotaは、よく使われるビットフラグや列挙型の定数を自動生成する際に便利です。

例えば、ビットシフト演算子と組み合わせると、各定数に対して指数的な値を割り当てることができます。

以下のコード例をご参照ください。

package main
import "fmt"
func main() {
	// iotaとビットシフトを使って定数を自動生成
	const (
		FlagNone  = 1 << iota // 1 << 0 == 1
		FlagRead              // 1 << 1 == 2
		FlagWrite             // 1 << 2 == 4
	)
	fmt.Println("FlagNone:", FlagNone)
	fmt.Println("FlagRead:", FlagRead)
	fmt.Println("FlagWrite:", FlagWrite)
}

FlagNone: 1
FlagRead: 2
FlagWrite: 4

実例によるiotaの利用

実例では、曜日の列挙型を作成する場合などにiotaが重宝されます。

以下は、曜日を自動生成するサンプルコードです。

package main
import "fmt"
func main() {
	const (
		Sunday = iota    // 0
		Monday          // 1
		Tuesday         // 2
		Wednesday       // 3
		Thursday        // 4
		Friday          // 5
		Saturday        // 6
	)
	// 曜日の一部を出力
	fmt.Println("Monday:", Monday)
	fmt.Println("Tuesday:", Tuesday)
}

Monday: 1
Tuesday: 2

iota使用時の注意点

iotaは各定数グループ内でのみ有効であり、別のグループでは再度0からカウントが始まります。

この点に注意する必要があります。

下記のサンプルはその挙動を示しています。

package main
import "fmt"
func main() {
	const (
		X = iota // 0
		Y        // 1
	)
	// 別ブロックではiotaは0から再開
	const (
		Z = iota // 0
	)
	fmt.Println("X:", X, "Y:", Y, "Z:", Z)
}

X: 0 Y: 1 Z: 0

型指定と省略によるconst宣言

型指定したconstの宣言方法

定数は、明示的に型を指定して宣言することも可能です。

型を指定することで、定数の型と振る舞いが明確になります。

以下のサンプルコードでは、文字列型の定数を宣言しています。

package main
import "fmt"
func main() {
	// 型指定を行って文字列型の定数を宣言
	const Message string = "定数は変更不可"
	fmt.Println(Message)
}

定数は変更不可

型推論によるconstの活用方法

Go言語では、定数の宣言時に型を明示しなくても、コンパイラが自動的に型を推論します。

型推論を用いることで、コードがすっきりと簡潔になります。

以下の例をご覧ください。

package main
import "fmt"
func main() {
	// 型推論により定数の型が自動的に決定される
	const Number = 100
	// fmt.Printfを使用して数値をフォーマットして出力
	fmt.Printf("Number: %d", Number)
}