Go言語で型を出力する方法を解説

package main
import (
	"fmt"
)
func main() {
	// 変数の定義
	var message string = "Go is fun"
	var number int = 42
	// fmt.Print: 改行なしで連結出力
	fmt.Print("Print: ", message, " - ", number)
	// 出力結果: Print: Go is fun - 42
	// 改行用の空行を挿入
	fmt.Println()
	// fmt.Println: 引数間にスペースを加えて出力、最後に改行が挿入される
	fmt.Println("Println:", message, "-", number)
	// 出力結果: Println: Go is fun - 42
	// fmt.Printf: フォーマット指定子を利用して出力
	fmt.Printf("Printf: %s - %d\n", message, number)
	// 出力結果: Printf: Go is fun - 42
}

Print: Go is fun - 42
Println: Go is fun - 42
Printf: Go is fun - 42

package main
import (
	"fmt"
)
func main() {
	// 各種変数の定義
	var number int = 100
	var text string = "サンプル"
	var flag bool = true
	// 各変数の型情報を出力
	fmt.Printf("numberの型: %T\n", number)
	fmt.Printf("textの型: %T\n", text)
	fmt.Printf("flagの型: %T\n", flag)
}

numberの型: int
textの型: string
flagの型: bool

package main
import (
	"fmt"
	"reflect"
)
func main() {
	// 変数定義
	var sample float64 = 3.14
	// reflect.TypeOfで型情報を取得
	typeInfo := reflect.TypeOf(sample)
	// 型情報を出力
	fmt.Println("sampleの型:", typeInfo)
}

sampleの型: float64

package main
import (
	"fmt"
	"reflect"
)
func main() {
	// 各種変数の定義
	numbers := []int{1, 2, 3}
	info := map[string]interface{}{
		"name":  "Alice",
		"age":   30,
		"valid": true,
	}
	// 型情報取得
	sliceType := reflect.TypeOf(numbers)
	mapType := reflect.TypeOf(info)
	// 型情報を出力
	fmt.Println("numbersの型:", sliceType)
	fmt.Println("infoの型:", mapType)
}

numbersの型: []int
infoの型: map[string]interface {}

package main
import (
	"fmt"
)
type Person struct { // ユーザ定義の構造体
	Name string  // 名前
	Age  int     // 年齢
}
func main() {
	// Person型のインスタンスを生成
	p := Person{Name: "Bob", Age: 25}
	// 構造体の型情報を出力
	fmt.Printf("pの型: %T\n", p)
}

pの型: main.Person

package main
import (
	"fmt"
	"reflect"
)
type Animal interface { // インターフェース定義
	Speak() string
}
type Dog struct { // Dog構造体, Animalインターフェースを実装
	Breed string
}
func (d Dog) Speak() string {
	return "Woof!"
}
func main() {
	// インターフェース型の変数へDogのインスタンスを代入
	var pet Animal = Dog{Breed: "Bulldog"}
	// 型情報を出力
	fmt.Printf("petの型: %T\n", pet)
	// reflectを利用しても型情報が取得可能
	fmt.Println("reflectでの型:", reflect.TypeOf(pet))
}

petの型: main.Dog
reflectでの型: main.Dog

package main
import (
	"fmt"
)
type MyInt = int // int型のエイリアス
func main() {
	var value MyInt = 2021
	// エイリアスを用いた型情報表示
	fmt.Printf("valueの型: %T\n", value)
}

valueの型: int

package main
import (
	"fmt"
	"reflect"
)
func printType(value interface{}) {
	// 引数valueの型を取得して出力
	fmt.Printf("変数の型は: %s\n", reflect.TypeOf(value))
}
func main() {
	// 複数の型の変数
	var a int = 10
	var b string = "Hello"
	var c float64 = 0.99
	printType(a)
	printType(b)
	printType(c)
}

変数の型は: int
変数の型は: string
変数の型は: float64

package main
import (
	"fmt"
	"log"
	"reflect"
)
func logType(value interface{}) {
	// ログに型情報を出力
	log.Printf("ログ出力 - 変数の型: %s", reflect.TypeOf(value))
}
func main() {
	// ログ出力のサンプル変数
	var data map[string]interface{} = map[string]interface{}{
		"id":   123,
		"name": "Sample",
	}
	logType(data)
}

2023/10/05 12:00:00 ログ出力 - 変数の型: map[string]interface {}

package main
import (
	"fmt"
	"reflect"
)
type Address struct {
	City  string
	State string
}
type User struct {
	Name    string
	Age     int
	Address Address // ネストされた構造体
}
func main() {
	user := User{
		Name: "Charlie",
		Age:  28,
		Address: Address{
			City:  "Tokyo",
			State: "Tokyo-to",
		},
	}
	// ユーザの型情報を出力
	fmt.Printf("Userの型: %T\n", user)
	// Addressフィールドの型情報も確認
	fmt.Printf("Addressの型: %T\n", user.Address)
	// reflectパッケージを利用して詳しい型情報を取得
	fmt.Println("reflectによるUserの型:", reflect.TypeOf(user))
}

Userの型: main.User
Addressの型: main.Address
reflectによるUserの型: main.User

package main
import (
	"fmt"
	"reflect"
)
// typeCacheは型情報を保持するマップ
var typeCache = make(map[interface{}]reflect.Type)
// getTypeは与えられた値の型情報をキャッシュから取得する関数
func getType(value interface{}) reflect.Type {
	// 既にキャッシュに存在する場合はそれを返す
	if t, ok := typeCache[value]; ok {
		return t
	}
	// 存在しない場合は新たに取得し、キャッシュに追加
	t := reflect.TypeOf(value)
	typeCache[value] = t
	return t
}
func main() {
	var sample int = 555
	// getType関数を利用して型情報を出力
	typ := getType(sample)
	fmt.Printf("sampleの型: %T (%s)\n", sample, typ)
}

sampleの型: int (int)

package main
import (
	"fmt"
)
func main() {
	var value int = 10
	// 誤った書式指定子の場合の例
	// fmt.Printf("valueの型: %s\n", value) // %sは文字列用であり、int型には入らない
	// 正しい書式指定子を用いる
	fmt.Printf("valueの型: %T\n", value)
}

valueの型: int

package main
import (
	"fmt"
)
type Data struct {
	Name  string
	Count int
}
func main() {
	d := Data{Name: "Test", Count: 5}
	// 基本的な出力
	fmt.Printf("%%vを利用: %v\n", d)
	// 詳細な出力(フィールド名を含む)
	fmt.Printf("%%+vを利用: %+v\n", d)
}

%vを利用: {Test 5}
%+vを利用: {Name:Test Count:5}