interface の応用構文

基本の定義と満たし方を押さえたところで、実務でよく登場する応用パターンを順に見ていきます。ポインタレシーバとの関係、既存 interface を合成する書き方、あらゆる型を受け取る空インタフェース、そこから元の型に戻す型アサーションと型スイッチまで、それぞれ「どんな場面で不便で、どう解決できるか」の流れで扱います。

1. ポインタレシーバと interface の関係

フィールドを変更するメソッドは、Goポインタ で扱ったように ポインタレシーバ で定義するのが基本です。その型を interface に代入したい場合、値のまま代入しようとするとコンパイルエラーになり、悩みどころになります。この場合は &value の形でポインタを渡すことで解決できます。次のコードで実際の書き方と、なぜ値では満たされないのかを見ていきます。

package main

import "fmt"

type Greeter interface {
    Greet() string
}

type EnglishGreeter struct{}

// ポインタレシーバでメソッドを定義
func (e *EnglishGreeter) Greet() string {
    return "Hello"
}

func main() {
    // OK: ポインタは Greeter を満たす
    var g Greeter = &EnglishGreeter{}
    fmt.Println(g.Greet())

    // NG: 値は Greeter を満たさない(コメントアウトを外すとコンパイルエラー)
    // var g2 Greeter = EnglishGreeter{}
}

以下のような実行結果が表示されます。

Hello

&EnglishGreeter{} は Greeter を満たすため代入できました。値の EnglishGreeter{} はコメントアウトを外すとコンパイルエラーになります。

コードを解説します。

func (e *EnglishGreeter) Greet() string {
    return "Hello"
}

Greet メソッドを ポインタレシーバ で定義しています。この場合、Greet を持つのは *EnglishGreeter であって、EnglishGreeter(値そのもの)は持ちません。

var g Greeter = &EnglishGreeter{}

Greeter インタフェースに &EnglishGreeter{} を代入しています。*EnglishGreeter は Greet() を持つので、Greeter を満たします。

interface を受け取る関数を呼ぶときは、この点を意識して &value の形でポインタを渡すのが基本です。逆に「値でも呼び出せるようにしたい」場合は、全メソッドを値レシーバで統一する設計にします。

2. interface の合成(埋め込み)

「読み書きの両方ができる型」だけを引数で受け取りたい、といった場面があります。個別に新しい interface を宣言してもよいですが、既存の Reader と Writer があるなら、それらをまとめた新しい interface を作った方が定義の重複が減ります。Goでは、別のインタフェース名を interface の定義の中に書き入れる 埋め込み で合成できます。書き方は以下のとおりです。

type 合成インタフェース名 interface {
    別のインタフェース1
    別のインタフェース2
    // 追加のメソッドも並べられる
}

次のコードは、Reader インタフェースと Writer インタフェースを合成した ReadWriter を定義する例です。

package main

import "fmt"

type Reader interface {
    Read() string
}

type Writer interface {
    Write(s string)
}

type ReadWriter interface {
    Reader
    Writer
}

type Buffer struct {
    data string
}

func (b *Buffer) Read() string   { return b.data }
func (b *Buffer) Write(s string) { b.data = s }

func use(rw ReadWriter) {
    rw.Write("Hello")
    fmt.Println(rw.Read())
}

func main() {
    b := &Buffer{}
    use(b)
}

以下のような実行結果が表示されます。

Hello

Buffer は Read と Write の両方を持つため ReadWriter を満たし、use 関数に渡して両方のメソッドを呼び出せました。

コードを解説します。

type ReadWriter interface {
    Reader
    Writer
}

ReadWriter インタフェースの定義の中に、Reader と Writer の名前をそのまま書き入れています。これで「Reader と Writer の両方を満たす型」を要求できます。合成後のインタフェースは、Read() と Write(string) の両方を持つ型(今回の *Buffer など)が満たします。

標準ライブラリの io.ReadWriter もこの形で io.Reader と io.Writer を合成しており、現場でもよく使われるパターンです。

3. 空インタフェース

デバッグ用のログ関数や汎用ユーティリティで、「型を問わずどんな値でも受け取りたい」場面があります。個別に int・string・bool などを書き分けると、そのたびに関数を増やす必要が出てきて大変です。この場合、メソッドを1つも持たない interface{} を使うと、あらゆる型を1つの引数で受け取れます。書き方は以下のとおりです。

func 関数名(引数名 interface{}) {
    // 引数の中身を処理する
}

次のコードは、interface{} 型の引数を受け取り、渡された値と型を表示する describe 関数の例です。

package main

import "fmt"

func describe(v interface{}) {
    fmt.Printf("値: %v, 型: %T\n", v, v)
}

func main() {
    describe(42)
    describe("hello")
    describe(true)
}

以下のような実行結果が表示されます。

値: 42, 型: int
値: hello, 型: string
値: true, 型: bool

int・string・bool のいずれを渡しても同じ関数で受け取れ、%T により実際の型が出力されました。

コードを解説します。

func describe(v interface{}) {

引数の型を interface{}(空のインタフェース)にしているので、どんな型の値でも受け取れます。「型を問わない引数」を作りたいときに使います。

Go 1.18 以降では、interface{} の別名として any が使えます。

func describe(v any) {
    fmt.Printf("値: %v, 型: %T\n", v, v)
}

意味は同じですが、可読性が上がるため any の使用が推奨されます。

💡 ポイント
fmt.Printf の書式指定子は、%v が「渡された値そのもの」、%T が「値の型」(Goポインタ で扱ったもの)を表示します。以降の例で登場する %q は「ダブルクォートで囲んだ文字列」、%t は「真偽値」を表示するときに使います。

4. 型アサーション

空インタフェースで受け取れば「あらゆる型」を扱えますが、そのままでは元の型として使えず、int なら計算、string なら結合、といった型固有の操作ができません。ここで 型アサーション を使うと、interface{} から元の具体型に取り出して、その型固有の操作ができるようになります。書き方は以下のとおりです。第2戻り値の ok を受けると、失敗時に panic せずに判定できます。

v, ok := x.(取り出したい型)   // 成功時 ok=true, v が指定した型の値

次のコードは、interface{} で受けた値を int として取り出そうと試みる例です。

package main

import "fmt"

func main() {
    var x interface{} = 42

    n, ok := x.(int)
    fmt.Println(n, ok)

    s, ok := x.(string)
    fmt.Println(s, ok)
}

以下のような実行結果が表示されます。

42 true
 false

int としての取り出しは成功して 42 と true が、string としての取り出しは失敗して空文字列と false が返りました。

コードを解説します。

n, ok := x.(int)

x に入っている値を int として取り出そうと試みます。成功すれば n に値、ok に true が入ります。失敗した場合は n にゼロ値、ok に false が入ります。

s, ok := x.(string)

同じ x を今度は string として取り出そうとしています。中身が int なので失敗し、s は空文字列(string のゼロ値)、ok は false になります。

ok を受けない書き方(n := x.(int))もありますが、その場合は失敗時に panic が発生するため、通常は v, ok := ... の形で判定しながら使います。

5. 型スイッチ

型アサーションは1つの型を取り出すのに便利ですが、判定したい型が増えるたびに if v, ok := x.(int); ok { ... } else if v, ok := x.(string); ok { ... } と書き連ねる形になり、冗長になります。この場合は 型スイッチ で書くと、1つの switch で複数の型を分岐でき、ずっと読みやすくなります。書き方は以下のとおりです。switch に x.(type) を書き、各 case に判定したい型を並べます。

switch v := x.(type) {
case 型1:
    // v は型1として使える
case 型2:
    // v は型2として使える
default:
    // それ以外の型
}

次のコードは、interface{} で受けた値を int・string・bool のいずれかで分岐して表示する例です。

package main

import "fmt"

func describe(x interface{}) {
    switch v := x.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %q\n", v)
    case bool:
        fmt.Printf("bool: %t\n", v)
    default:
        fmt.Printf("その他: %v\n", v)
    }
}

func main() {
    describe(42)
    describe("hello")
    describe(true)
    describe(3.14)
}

以下のような実行結果が表示されます。

int: 42
string: "hello"
bool: true
その他: 3.14

int・string・bool はそれぞれ対応する case にマッチし、float64 の 3.14 はどれにもマッチせず default に流れました。

コードを解説します。

switch v := x.(type) {
case int:
    fmt.Printf("int: %d\n", v)

x.(type) は型スイッチ専用の書き方で、通常のコードでは使えません。マッチした case の中では、v はその型の値として扱われます。ここでは int の case に入るため、v は int として %d で表示できます。

default:
    fmt.Printf("その他: %v\n", v)

どの case にもマッチしなかった場合は default が実行されます。v はその時点では interface{} のままなので、任意の型を受け付ける %v で表示するのが安全です。