型・リテラル

Go言語の型一覧について解説

2025-02-19更新日: 2025-02-19

この記事では、Go言語の型一覧をシンプルにまとめています。

基本型から複合型、関数やインターフェースなど、主要な型の特徴を分かりやすく紹介します。

すでに開発環境が整っている方は、記事を読みながらすぐに実践できる内容となっていますので、ぜひご参考ください。

目次から探す

基本型
複合型
関数とインターフェース
- 関数型
- インターフェース型
並行処理とカスタム型
- チャネル型
- カスタム型
まとめ

基本型

数値型

整数型

整数型は符号あり・符号なしの整数を扱います。

整数型の変数宣言や計算のサンプルを以下に示します。

package main
import "fmt"
func main() {
	// int型変数の宣言と初期化
	var a int = 10
	// uint型変数の宣言と初期化(符号なし)
	var b uint = 20
	// 足し算の結果を表示
	fmt.Println("整数の和:", a+int(b))
}

整数の和: 30

浮動小数点数型と複素数型

浮動小数点数型は実数、複素数型は複素数を表現するのに使います。

複素数は $a + b i$ の形で表せます。

package main
import "fmt"
func main() {
	// float型変数の宣言と初期化
	var x float64 = 3.1415
	// 複素数型変数の宣言と初期化
	var c complex128 = 2 + 3i
	// 値を表示
	fmt.Println("浮動小数点数:", x)
	fmt.Println("複素数:", c)
}

浮動小数点数: 3.1415
複素数: (2+3i)

文字列型

文字列型はテキストデータを扱います。

文字列の結合や長さの取得などが可能です。

package main
import (
	"fmt"
	"strings"
)
func main() {
	// 文字列型変数の宣言と初期化
	var greeting string = "Hello"
	var target string = "Go"
	// 文字列の結合
	combined := greeting + ", " + target + "!"
	// 大文字化して表示
	fmt.Println("結合後の文字列:", strings.ToUpper(combined))
}

結合後の文字列: HELLO, GO!

ブール型

ブール型は論理値(true/false)を扱います。

条件分岐や論理演算に用います。

package main
import "fmt"
func main() {
	// ブール型変数の宣言と初期化
	var isAvailable bool = true
	var isComplete bool = false
	// 論理演算
	result := isAvailable && !isComplete
	// 結果の表示
	fmt.Println("条件の結果:", result)
}

条件の結果: true

複合型

配列

配列は固定長で同じ型の複数の要素を持つコレクションです。

package main
import "fmt"
func main() {
	// 配列の宣言と初期化
	var numbers [3]int = [3]int{1, 2, 3}
	// 配列の中身を表示
	fmt.Println("配列の要素:", numbers)
}

配列の要素: [1 2 3]

スライス

スライスは可変長で柔軟な操作が可能な配列のようなものです。

package main
import "fmt"
func main() {
	// スライスの作成と初期化
	numbers := []int{10, 20, 30, 40}
	// 要素の追加
	numbers = append(numbers, 50)
	// スライスの中身を表示
	fmt.Println("スライスの要素:", numbers)
}

スライスの要素: [10 20 30 40 50]

マップ

マップはキーと値のペアを格納する連想配列です。

package main
import "fmt"
func main() {
	// マップの宣言と初期化
	colors := map[string]string{
		"red":   "#ff0000",
		"green": "#00ff00",
		"blue":  "#0000ff",
	}
	// マップの内容を表示
	for key, value := range colors {
		fmt.Println(key, "=>", value)
	}
}

red => #ff0000
green => #00ff00
blue => #0000ff

構造体

構造体は複数のフィールドを持つデータ型です。

関連する情報をまとめて扱うことができます。

package main
import "fmt"
// Personという名前の構造体を定義
type Person struct {
	Name string
	Age  int
}
func main() {
	// 構造体のインスタンス作成
	person := Person{
		Name: "Alice",
		Age:  30,
	}
	// フィールドの値を表示
	fmt.Printf("名前: %s, 年齢: %d\n", person.Name, person.Age)
}

名前: Alice, 年齢: 30

ポインタ型

ポインタは変数のメモリアドレスを保持します。

変数の値を直接操作するのに便利です。

package main
import "fmt"
func main() {
	// int型変数の宣言と初期化
	var num int = 100
	// numのアドレスをポインタ変数ptrに代入
	ptr := &num
	// ポインタを使って変数の値を変更
	*ptr = 200
	// 値とアドレスを表示
	fmt.Println("numの値:", num)
	fmt.Println("ptrの指す値:", *ptr)
}

numの値: 200
ptrの指す値: 200

関数とインターフェース

関数型

関数も第一級オブジェクトとして扱えるため、変数への代入や引数で渡すことができます。

関数リテラル

関数リテラルは名前のない匿名関数を定義する方法です。

package main
import "fmt"
func main() {
	// 匿名関数を定義して変数addに代入
	add := func(a int, b int) int {
		// 2つの整数の和を返す
		return a + b
	}
	// 関数リテラルを呼び出し
	result := add(5, 7)
	fmt.Println("和:", result)
}

和: 12

クロージャ

クロージャは、外側の関数の変数を捕捉する関数リテラルです。

状態を持たせることが可能です。

package main
import "fmt"
func main() {
	// counterはクロージャによって状態を保持する変数
	counter := func() func() int {
		count := 0
		// 無名関数がcountを捕捉して返す
		return func() int {
			count++ // countをインクリメント
			return count
		}
	}()
	// クロージャを複数回呼び出して状態を確認
	fmt.Println("カウンター:", counter())
	fmt.Println("カウンター:", counter())
	fmt.Println("カウンター:", counter())
}

カウンター: 1
カウンター: 2
カウンター: 3

インターフェース型

インターフェース型は、メソッドのシグニチャ(型)を定義し、異なる型に共通の振る舞いを持たせるために用いられます。

package main
import "fmt"
// Speakerインターフェースを定義
type Speaker interface {
	Speak() string
}
// Dog型を定義し、Speakerインターフェースを実装する
type Dog struct{}
func (d Dog) Speak() string {
	return "Bow-wow" // 犬の鳴き声
}
// Cat型を定義し、Speakerインターフェースを実装する
type Cat struct{}
func (c Cat) Speak() string {
	return "Meow" // 猫の鳴き声
}
func main() {
	// Speaker型のスライスにDogとCatを格納
	animals := []Speaker{Dog{}, Cat{}}
	// 各要素のSpeakメソッドを呼び出して表示
	for _, animal := range animals {
		fmt.Println(animal.Speak())
	}
}

Bow-wow
Meow

並行処理とカスタム型

チャネル型

チャネル型はゴルーチン間での情報のやりとりに使います。

これにより並行処理が容易になります。

package main
import (
	"fmt"
	"time"
)
func main() {
	// int型のチャネルを作成
	ch := make(chan int)
	// ゴルーチンで1秒後に値を送信
	go func() {
		time.Sleep(1000 * time.Millisecond)
		ch <- 42 // チャネルに値を送信
	}()
	// チャネルから値を受信して表示
	value := <-ch
	fmt.Println("受信した値:", value)
}

受信した値: 42

カスタム型

Goでは既存の型から新たなカスタム型を定義できます。

ここでは型定義と型エイリアスの例を示します。

型定義

型定義を使うと、新しい型として振る舞うため、元の型と区別されます。

package main
import "fmt"
// Celsiusはfloat64を基にした新しい型
type Celsius float64
func main() {
	var temperature Celsius = 36.5
	fmt.Printf("体温: %.1f°C\n", temperature)
}

体温: 36.5°C

型エイリアス

型エイリアスは既存の型に別名を設定しただけで、同一の型として扱われます。

package main
import "fmt"
// CelsiusAliasはfloat64の型エイリアス
type CelsiusAlias = float64
func main() {
	var temp CelsiusAlias = 36.5
	fmt.Printf("体温(エイリアス): %.1f°C\n", temp)
}