Go言語入門：言語仕様 -Vol.28-

よっしー

こんにちは。よっしーです(^^)

本日は、Go言語の言語仕様について解説しています。

背景
Basic interfaces(基本的なインターフェース)
解説
1. 基本的なインターフェースとは?
1. 基本的なインターフェースの定義
1. シンプルなインターフェース
2. 複数のメソッドを持つインターフェース
2. メソッド名の制約
1. メソッド名は一意でなければならない
2. メソッド名は空白であってはならない
3. 複数の型による実装
1. 基本例
2. 複数のインターフェースの実装
4. 空のインターフェース
1. interface{}の使用
2. any型(Go 1.18+)
5. 実用例
まとめ: 基本的なインターフェースで覚えておくべきこと
おわりに

背景

Go言語を学び始めて、公式の「The Go Programming Language Specification(言語仕様書)」を開いてみたものの、「英語で書かれていて読むのが大変…」「専門用語ばかりで何を言っているのかわからない…」と感じたことはありませんか? 実は、多くのGo初心者が同じ壁にぶつかっています。

言語仕様書は、Go言語の「正式な取扱説明書」のような存在です。プログラミング言語がどのように動くのか、どんなルールで書くべきなのかが詳しく書かれていますが、その分、初めて読む人には難しく感じられるのも事実です。

そこでこの記事では、言語仕様書の導入部分を丁寧な日本語訳とともに、初心者の方でも理解しやすい補足説明を加えてお届けします。「強く型付けされている」「ガベージコレクション」「並行プログラミング」といった専門用語も、具体例を交えながらわかりやすく解説していきます。

言語仕様書は難しそうに見えますが、一つひとつの概念を丁寧に読み解いていけば、必ず理解できます。一緒に、Go言語の基礎をしっかり学んでいきましょう!

The Go Programming Language Specification - The Go Programming Language

Basic interfaces(基本的なインターフェース)

最も基本的な形式では、インターフェースは(空の可能性がある)メソッドのリストを指定します。そのようなインターフェースによって定義される型集合は、それらのメソッドすべてを実装する型の集合であり、対応するメソッドセットはインターフェースによって指定されたメソッドで正確に構成されます。型集合がメソッドのリストによって完全に定義できるインターフェースは、基本的なインターフェースと呼ばれます。

// シンプルなFileインターフェース
interface {
	Read([]byte) (int, error)
	Write([]byte) (int, error)
	Close() error
}

明示的に指定された各メソッドの名前は、一意で空白であってはなりません。

interface {
	String() string
	String() string  // 不正: Stringが一意でない
	_(x int)         // 不正: メソッドは空白でない名前を持つ必要がある
}

複数の型が1つのインターフェースを実装する場合があります。たとえば、2つの型S1とS2が次のメソッドセットを持つ場合:

func (p T) Read(p []byte) (n int, err error)
func (p T) Write(p []byte) (n int, err error)
func (p T) Close() error

(TはS1またはS2のいずれかを表す)、S1とS2が他にどのようなメソッドを持っているか、または共有しているかに関係なく、FileインターフェースはS1とS2の両方によって実装されます。

インターフェースの型集合のメンバーであるすべての型は、そのインターフェースを実装します。任意の型は、複数の異なるインターフェースを実装する場合があります。たとえば、すべての型は空のインターフェースを実装します。これは、すべての(非インターフェース)型の集合を表します:

interface{}

便宜上、事前宣言された型anyは空のインターフェースのエイリアスです。[Go 1.18]

同様に、次のインターフェース仕様を考えてみます。これは型宣言内に現れ、Lockerと呼ばれるインターフェースを定義します:

type Locker interface {
	Lock()
	Unlock()
}

S1とS2が次も実装する場合:

func (p T) Lock() { … }
func (p T) Unlock() { … }

それらはLockerインターフェースとFileインターフェースの両方を実装します。

解説

基本的なインターフェースとは?

基本的なインターフェースは、メソッドのリストだけで定義されるシンプルなインターフェースです。「これらのメソッドを持っていれば、このインターフェースを実装している」という明確な条件です。

たとえ話: 基本的なインターフェースは「資格要件リスト」のようなものです。「料理ができる」「接客ができる」「会計ができる」という3つのスキルがあれば、レストランスタッフとして働ける、という具合です。

1. 基本的なインターフェースの定義

シンプルなインターフェース

package main

import "fmt"

// 基本的なインターフェース: メソッドのリストだけ
type Writer interface {
    Write([]byte) (int, error)
}

type Console struct{}

func (c Console) Write(data []byte) (int, error) {
    fmt.Print(string(data))
    return len(data), nil
}

func main() {
    var w Writer = Console{}
    w.Write([]byte("Hello, World!\n"))
}

複数のメソッドを持つインターフェース

package main

import "fmt"

// 3つのメソッドを持つインターフェース
type File interface {
    Read([]byte) (int, error)
    Write([]byte) (int, error)
    Close() error
}

type MyFile struct {
    content string
    closed  bool
}

func (f *MyFile) Read(p []byte) (int, error) {
    if f.closed {
        return 0, fmt.Errorf("ファイルが閉じられています")
    }
    n := copy(p, f.content)
    return n, nil
}

func (f *MyFile) Write(p []byte) (int, error) {
    if f.closed {
        return 0, fmt.Errorf("ファイルが閉じられています")
    }
    f.content = string(p)
    return len(p), nil
}

func (f *MyFile) Close() error {
    f.closed = true
    return nil
}

func main() {
    var file File = &MyFile{}
    
    file.Write([]byte("Hello"))
    
    buf := make([]byte, 100)
    n, _ := file.Read(buf)
    fmt.Println(string(buf[:n])) // Hello
    
    file.Close()
}

2. メソッド名の制約

メソッド名は一意でなければならない

package main

// ❌ エラー: 同じ名前のメソッドが2つある
// type BadInterface interface {
//     String() string
//     String() string  // 不正!
// }

// ✅ 正しい: メソッド名が一意
type GoodInterface interface {
    String() string
    GoString() string
}

メソッド名は空白であってはならない

package main

// ❌ エラー: 空白識別子は使えない
// type BadInterface interface {
//     _(x int)  // 不正!
// }

// ✅ 正しい: 適切な名前を付ける
type GoodInterface interface {
    Process(x int)
}

3. 複数の型による実装

同じインターフェースを、異なる複数の型が実装できます。

基本例

package main

import "fmt"

type Speaker interface {
    Speak() string
}

// Dog型がSpeakerを実装
type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "ワンワン"
}

// Cat型もSpeakerを実装
type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return "ニャー"
}

// Robot型もSpeakerを実装
type Robot struct {
    ID int
}

func (r Robot) Speak() string {
    return "ピピピ"
}

func makeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "ポチ"}
    cat := Cat{Name: "タマ"}
    robot := Robot{ID: 1}
    
    makeSound(dog)   // ワンワン
    makeSound(cat)   // ニャー
    makeSound(robot) // ピピピ
}

複数のインターフェースの実装

1つの型が複数のインターフェースを実装できます。

package main

import "fmt"

// 2つの異なるインターフェース
type Reader interface {
    Read() string
}

type Writer interface {
    Write(string)
}

// File型が両方のインターフェースを実装
type File struct {
    content string
}

func (f *File) Read() string {
    return f.content
}

func (f *File) Write(data string) {
    f.content = data
}

func main() {
    file := &File{}
    
    // Writerとして使う
    var w Writer = file
    w.Write("Hello, World!")
    
    // Readerとして使う
    var r Reader = file
    fmt.Println(r.Read()) // Hello, World!
}

4. 空のインターフェース

すべての型は空のインターフェースを実装します。

interface{}の使用

package main

import "fmt"

// すべての型を受け入れる
func printValue(v interface{}) {
    fmt.Printf("値: %v, 型: %T\n", v, v)
}

func main() {
    printValue(42)
    printValue("Hello")
    printValue(3.14)
    printValue([]int{1, 2, 3})
    printValue(struct{ Name string }{"太郎"})
    
    // 値: 42, 型: int
    // 値: Hello, 型: string
    // 値: 3.14, 型: float64
    // 値: [1 2 3], 型: []int
    // 値: {太郎}, 型: struct { Name string }
}

any型(Go 1.18+)

package main

import "fmt"

// anyはinterface{}のエイリアス
func printAnything(v any) {
    fmt.Printf("値: %v\n", v)
}

func main() {
    printAnything(42)
    printAnything("Hello")
    printAnything(true)
}

5. 実用例

例1: 図形の面積計算

package main

import "fmt"

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14159 * c.Radius
}

func printShapeInfo(s Shape) {
    fmt.Printf("面積: %.2f\n", s.Area())
    fmt.Printf("周囲: %.2f\n", s.Perimeter())
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    circle := Circle{Radius: 7}
    
    fmt.Println("長方形:")
    printShapeInfo(rect)
    
    fmt.Println("\n円:")
    printShapeInfo(circle)
}

例2: データベースインターフェース

package main

import "fmt"

type Database interface {
    Connect() error
    Disconnect() error
    Query(sql string) ([]map[string]interface{}, error)
}

type MySQL struct {
    Host string
    connected bool
}

func (m *MySQL) Connect() error {
    m.connected = true
    fmt.Println("MySQLに接続しました")
    return nil
}

func (m *MySQL) Disconnect() error {
    m.connected = false
    fmt.Println("MySQLから切断しました")
    return nil
}

func (m *MySQL) Query(sql string) ([]map[string]interface{}, error) {
    fmt.Println("MySQLクエリ:", sql)
    return nil, nil
}

type PostgreSQL struct {
    Host string
    connected bool
}

func (p *PostgreSQL) Connect() error {
    p.connected = true
    fmt.Println("PostgreSQLに接続しました")
    return nil
}

func (p *PostgreSQL) Disconnect() error {
    p.connected = false
    fmt.Println("PostgreSQLから切断しました")
    return nil
}

func (p *PostgreSQL) Query(sql string) ([]map[string]interface{}, error) {
    fmt.Println("PostgreSQLクエリ:", sql)
    return nil, nil
}

func executeQuery(db Database, sql string) {
    db.Connect()
    db.Query(sql)
    db.Disconnect()
}

func main() {
    mysql := &MySQL{Host: "localhost"}
    postgres := &PostgreSQL{Host: "localhost"}
    
    executeQuery(mysql, "SELECT * FROM users")
    fmt.Println()
    executeQuery(postgres, "SELECT * FROM users")
}

例3: Lockerパターン

package main

import (
    "fmt"
    "time"
)

type Locker interface {
    Lock()
    Unlock()
}

type Resource struct {
    name   string
    locked bool
}

func (r *Resource) Lock() {
    fmt.Printf("%s: ロック取得\n", r.name)
    r.locked = true
}

func (r *Resource) Unlock() {
    fmt.Printf("%s: ロック解放\n", r.name)
    r.locked = false
}

// Lockerインターフェースを使った安全な処理
func safeProcess(l Locker, work func()) {
    l.Lock()
    defer l.Unlock()
    
    work()
}

func main() {
    resource := &Resource{name: "データベース"}
    
    safeProcess(resource, func() {
        fmt.Println("処理中...")
        time.Sleep(100 * time.Millisecond)
        fmt.Println("処理完了")
    })
}

例4: ファイルとLockerの両方を実装

package main

import "fmt"

// Fileインターフェース
type File interface {
    Read([]byte) (int, error)
    Write([]byte) (int, error)
    Close() error
}

// Lockerインターフェース
type Locker interface {
    Lock()
    Unlock()
}

// SecureFileは両方のインターフェースを実装
type SecureFile struct {
    content string
    locked  bool
    closed  bool
}

// Fileインターフェースの実装
func (f *SecureFile) Read(p []byte) (int, error) {
    if f.closed {
        return 0, fmt.Errorf("ファイルが閉じられています")
    }
    if !f.locked {
        return 0, fmt.Errorf("ロックされていません")
    }
    n := copy(p, f.content)
    return n, nil
}

func (f *SecureFile) Write(p []byte) (int, error) {
    if f.closed {
        return 0, fmt.Errorf("ファイルが閉じられています")
    }
    if !f.locked {
        return 0, fmt.Errorf("ロックされていません")
    }
    f.content = string(p)
    return len(p), nil
}

func (f *SecureFile) Close() error {
    f.closed = true
    return nil
}

// Lockerインターフェースの実装
func (f *SecureFile) Lock() {
    f.locked = true
}

func (f *SecureFile) Unlock() {
    f.locked = false
}

func main() {
    file := &SecureFile{}
    
    // Lockerとして使う
    var locker Locker = file
    locker.Lock()
    
    // Fileとして使う
    var fileInterface File = file
    fileInterface.Write([]byte("セキュアなデータ"))
    
    buf := make([]byte, 100)
    n, _ := fileInterface.Read(buf)
    fmt.Println(string(buf[:n]))
    
    locker.Unlock()
}

まとめ: 基本的なインターフェースで覚えておくべきこと

基本的なインターフェースの特徴

メソッドのリストで定義: 必要なメソッドを列挙するだけ
暗黙的な実装: 明示的な宣言不要
複数の型が実装可能: 異なる型が同じインターフェースを実装できる
複数のインターフェースを実装可能: 1つの型が複数のインターフェースを実装できる

メソッド名のルール

// ✅ 正しい
type ValidInterface interface {
    Read() string
    Write(string)
    Close() error
}

// ❌ 間違い
type InvalidInterface interface {
    String() string
    String() string  // 重複!
    _(x int)         // 空白識別子!
}

空のインターフェース

// interface{} または any
var v interface{} = 42
var a any = "Hello"

// どんな型でも受け入れる
func printAny(v any) {
    fmt.Println(v)
}

実用的なアドバイス

package main

import "fmt"

// 1. 小さく、焦点を絞ったインターフェースを定義
type Reader interface {
    Read() string
}

type Writer interface {
    Write(string)
}

// 2. 必要に応じて組み合わせる
type ReadWriter interface {
    Reader
    Writer
}

// 3. 1つの型で複数のインターフェースを実装
type File struct {
    content string
}

func (f *File) Read() string {
    return f.content
}

func (f *File) Write(data string) {
    f.content = data
}

func main() {
    file := &File{}
    
    // Readerとして使う
    var r Reader = file
    
    // Writerとして使う
    var w Writer = file
    w.Write("データ")
    
    // ReadWriterとして使う
    var rw ReadWriter = file
    
    fmt.Println(r, w, rw)
}

インターフェース設計のベストプラクティス

小さく保つ: 1〜3個のメソッドが理想的
意図を明確に: インターフェース名で目的を表現
単一責任: 1つのインターフェースは1つの責務
受け入れ側で定義: 使う側がインターフェースを定義する

基本的なインターフェースは、Goの柔軟性と拡張性の基盤です。シンプルで明確なインターフェースを設計することで、保守性の高いコードが書けます!

おわりに

本日は、Go言語の言語仕様について解説しました。

よっしー

何か質問や相談があれば、コメントをお願いします。また、エンジニア案件の相談にも随時対応していますので、お気軽にお問い合わせください。

それでは、また明日お会いしましょう(^^)