Go言語のinterface引数の使い方を解説

package main
import (
	"fmt"
)
// PrintValue は interface 引数を受け取り、そのまま出力する関数です。
func PrintValue(value interface{}) {
	fmt.Println("値:", value)
}
func main() {
	// int 型の値を渡す
	PrintValue(123)
	// string 型の値も渡せる
	PrintValue("Hello, Go!")
}

値: 123
値: Hello, Go!

package main
import (
	"fmt"
)
// ProcessValue は渡された値の型に応じて処理を分岐します。
func ProcessValue(value interface{}) {
	switch v := value.(type) {
	case int:
		fmt.Println("整数:", v)
	case string:
		fmt.Println("文字列:", v)
	default:
		fmt.Println("その他の型:", v)
	}
}
func main() {
	ProcessValue(456)
	ProcessValue("Sample")
	ProcessValue(3.14)
}

整数: 456
文字列: Sample
その他の型: 3.14

package main
import (
	"fmt"
)
// CheckType は interface 引数の型が int かどうかを検証します。
func CheckType(value interface{}) {
	// 型アサーションを用いて int 型へ変換を試みる
	if v, ok := value.(int); ok {
		fmt.Println("整数として検証:", v)
	} else {
		fmt.Println("整数ではないです")
	}
}
func main() {
	CheckType(789)
	CheckType("Test")
}

整数として検証: 789
整数ではないです

package main
import (
	"errors"
	"fmt"
)
// ProcessNumber は interface 引数が int 型であることを要求し、そうでない場合はエラーを返します。
func ProcessNumber(value interface{}) error {
	num, ok := value.(int)
	if !ok {
		return errors.New("型エラー: int 型ではありません")
	}
	fmt.Println("処理した数値:", num)
	return nil
}
func main() {
	if err := ProcessNumber("NotAnInt"); err != nil {
		fmt.Println("エラー:", err)
	}
}

エラー: 型エラー: int 型ではありません

package main
import (
	"fmt"
)
// Greeter は Greet メソッドを持つインターフェースです。
type Greeter interface {
	Greet() string
}
// RealGreeter は実際の処理を行う実装です。
type RealGreeter struct{}
func (r RealGreeter) Greet() string {
	return "こんにちは"
}
// SayHello は Greeter インターフェースを利用して挨拶を出力します。
func SayHello(g Greeter) {
	fmt.Println(g.Greet())
}
// MockGreeter はテスト用のモック実装です。
type MockGreeter struct {
	message string
}
func (m MockGreeter) Greet() string {
	return m.message
}
func main() {
	// モック実装を用いてテストケースを構築
	mockGreeter := MockGreeter{message: "テスト用の挨拶"}
	SayHello(mockGreeter)
}

テスト用の挨拶

package main
import (
	"fmt"
)
// ValidateInput は渡された値の型に応じた文字列を返します。
func ValidateInput(value interface{}) string {
	switch v := value.(type) {
	case int:
		return fmt.Sprintf("整数: %d", v)
	case string:
		return fmt.Sprintf("文字列: %s", v)
	default:
		return "不明な型"
	}
}
func main() {
	fmt.Println(ValidateInput(10))
	fmt.Println(ValidateInput("Go"))
	fmt.Println(ValidateInput(3.14))
}

整数: 10
文字列: Go
不明な型

package main
import (
	"fmt"
)
// DebugType は渡された値が string 型かどうかを検証し、結果を出力します。
func DebugType(value interface{}) {
	if v, ok := value.(string); ok {
		fmt.Println("文字列として検証:", v)
	} else {
		fmt.Printf("文字列ではない型: %T\n", value)
	}
}
func main() {
	DebugType("デバッグ")
	DebugType(100)
}

文字列として検証: デバッグ
文字列ではない型: int

package main
import (
	"fmt"
	"time"
)
// ConvertAndProcess は渡された値を int 型に変換し、計算処理を実施する関数です。
func ConvertAndProcess(value interface{}) {
	start := time.Now()
	if v, ok := value.(int); ok {
		// 単純な処理を繰り返す
		for i := 0; i < 1000000; i++ {
			_ = v * i
		}
		fmt.Println("整数処理完了:", v)
	} else {
		fmt.Println("変換失敗")
	}
	duration := time.Since(start)
	fmt.Println("処理時間:", duration)
}
func main() {
	ConvertAndProcess(100)
}

整数処理完了: 100
処理時間: 10ms  // ※実行環境によって異なります

package main
import (
	"fmt"
)
// ProcessConcrete は具体的な int 型の値を処理します。
func ProcessConcrete(value int) {
	fmt.Println("具体的な処理:", value)
}
// ProcessConcreteInterface は interface 引数を受け取り int 型に変換して処理します。
func ProcessConcreteInterface(value interface{}) {
	if v, ok := value.(int); ok {
		fmt.Println("interface を用いた処理:", v)
	}
}
func main() {
	// 具体的な型を利用した処理(オーバーヘッドが少ない)
	ProcessConcrete(200)
	// interface 引数を利用した処理(型変換が発生)
	ProcessConcreteInterface(200)
}

具体的な処理: 200
interface を用いた処理: 200