🫡

GolangでUnion型を実現！型の柔軟性を最大限に活かす3つの方法

2025/01/27に公開

 はじめにGolang（以下Go）は、シンプルで高速なプログラミングを実現するために設計された言語です。しかし、Goには他の言語で一般的なUnion型のサポートがありません。そのため、複合型を扱いたい場合、Goの特徴を活かした方法で工夫する必要があります。
この記事では、Union型的なことをGoで実現するための方法を詳しく解説します。初学者の方でも理解しやすいように、コード例や実用的なシナリオを交えながら説明します。

 Union型とは？Union型は、1つの変数が複数の型のうちどれか1つを持つことを許容する型です。例えば、TypeScriptやPythonでは以下のように書くことで、Union型を利用できます：
// TypeScriptの例
type MyUnion = string | number;
# Pythonの例（タイプヒントを利用）
from typing import Union
MyUnion = Union[str, int]
これにより、1つの変数が文字列や数値など、異なる型を安全に扱えるようになります。
Union型を利用することで、柔軟性と型安全性を両立させることが可能になります。一方で、Goではこのような機能が標準で提供されていないため、代替手段を理解しておくことが重要です。

 GoにおけるUnion型的な実現方法GoにはUnion型そのものはありませんが、以下のような工夫で似たようなことを実現できます。

 interface{}を使用するGoのinterface{}型は、任意の型を扱える特別な型です。Union型の代替として利用する場合があります。
package main

import (
	"fmt"
)

func printValue(value interface{}) {
	switch v := value.(type) {
	case string:
		fmt.Println("string:", v)
	case int:
		fmt.Println("int:", v)
	default:
		fmt.Println("unknown type")
	}
}

func main() {
	printValue("Hello")
	printValue(42)
	printValue(3.14) // unknown type
}
メリット
簡単に複数の型を扱える。
柔軟性が高い。
デメリット
型安全性が保証されない。
型アサーションや型スイッチが必要。
interface{}を使うとコードが簡潔になりますが、複雑なロジックではデバッグが難しくなる可能性があります。そのため、使いどころを見極めることが大切です。

 構造体で型を明示的に管理するより型安全な方法として、構造体を使用して複数の型をラップする方法があります。
package main

import (
	"fmt"
)

type MyUnion struct {
	StringValue *string
	IntValue    *int
}

func printValue(value MyUnion) {
	if value.StringValue != nil {
		fmt.Println("string:", *value.StringValue)
	} else if value.IntValue != nil {
		fmt.Println("int:", *value.IntValue)
	} else {
		fmt.Println("no value")
	}
}

func main() {
	str := "Hello"
	num := 42

	value1 := MyUnion{StringValue: &str}
	value2 := MyUnion{IntValue: &num}

	printValue(value1)
	printValue(value2)
}

メリット
型安全性が向上。
明確な設計が可能。
デメリット
実装がやや冗長になる。
新しい型を追加する際の変更コスト。
この方法は、特に大規模なプロジェクトで有用です。型の明示的な管理により、コードの可読性と保守性が向上します。
ジェネリクス（Go 1.18以降）を活用する
Go 1.18以降では、ジェネリクスが導入され、より型安全に複数の型を扱えるようになりました。
package main

import (
	"fmt"
)

type MyUnion[T any] struct {
	Value T
}

func printValue[T any](value MyUnion[T]) {
	fmt.Printf("value: %v\n", value.Value)
}

func main() {
	strValue := MyUnion[string]{Value: "Hello"}
	intValue := MyUnion[int]{Value: 42}

	printValue(strValue)
	printValue(intValue)
}
メリット
型安全性が高い。
汎用性がある。
デメリット
ジェネリクスの文法に慣れる必要がある。
ジェネリクスは柔軟で強力な機能ですが、使いすぎるとコードが複雑になる可能性もあります。適切なユースケースを見極めることが重要です。

 実用例：APIレスポンスの処理複合型の実現方法を理解したところで、実用例を見てみましょう。ここでは、APIレスポンスのデータ型が異なる可能性がある場合の処理を例にします。
package main

import (
	"encoding/json"
	"fmt"
)

type APIResponse struct {
	Data interface{} `json:"data"`
}

func main() {
	// JSONレスポンス
	jsonStr1 := `{"data": "Hello, World!"}`
	jsonStr2 := `{"data": 12345}`

	// レスポンス1をデコード
	var res1 APIResponse
	json.Unmarshal([]byte(jsonStr1), &res1)
	fmt.Printf("Response1: %+v\n", res1)

	// レスポンス2をデコード
	var res2 APIResponse
	json.Unmarshal([]byte(jsonStr2), &res2)
	fmt.Printf("Response2: %+v\n", res2)

	// 型アサーション
	if strData, ok := res1.Data.(string); ok {
		fmt.Println("String data:", strData)
	} else {
		fmt.Println("Data is not a string")
	}
}

 まとめGoではUnion型そのものはサポートされていませんが、interface{}、構造体、ジェネリクスなどを活用することで、Union型的な機能を実現できます。それぞれの方法にはメリットとデメリットがあり、用途に応じて選択することが重要です。
この記事が、Goで複合型を扱う際の指針となれば幸いです！

 参考文献Go公式ドキュメント
Effective Go
Go 1.18リリースノート

はじめに

Union型とは？

GoにおけるUnion型的な実現方法

interface{}を使用する

構造体で型を明示的に管理する

実用例：APIレスポンスの処理

まとめ

参考文献

Discussion