GoとPHPのインターフェイスの違い

GoとPHPのインターフェイスの違い 2025/02/19 Go Connect #5 しまぶ@shimabox 

自己紹介 { "NAME": "しまぶ", "SNS": "@shimabox", "TAMASHII": "沖縄", "COMPANY": "カオナビ",
"SKILL": [ "PHP", "<small>Go</small>" ] } whoami.json

自己紹介 📖 共著で本を書きました 📖

自己紹介 📖 共著で本を書きました 📖 ひとり8冊買ってくれ！

自己紹介 📖 共著で本を書きました 📖 心はPHPer、身体はGopher。

1. GoとPHPのインターフェイス 2. Goのインターフェイスを少し深ぼる 3. サンプルを交えてさらに深ぼる 4. まとめアジェンダ

1. GoとPHPのインターフェイス 2. Goのインターフェイスを少し深ぼる 3. サンプルを交えてさらに深ぼる 4. まとめ GoとPHPのインターフェイス

GoとPHPのインターフェイスまず、PHPのインターフェイス interface LoggerInterface { public function log(string $message): void;
} class FileLogger implements LoggerInterface { public function log(string $message): void { echo 'Logging to ﬁle: ' . $message; } } function logMessage(LoggerInterface $logger) { $logger->log('Hello, PHP!'); } logMessage(new FileLogger());

} class FileLogger implements LoggerInterface { public function log(string $message): void { echo 'Logging to ﬁle: ' . $message; } } function logMessage(LoggerInterface $logger) { $logger->log('Hello, PHP!'); } logMessage(new FileLogger()); インターフェイスの定義

} class FileLogger implements LoggerInterface { public function log(string $message): void { echo 'Logging to ﬁle: ' . $message; } } function logMessage(LoggerInterface $logger) { $logger->log('Hello, PHP!'); } logMessage(new FileLogger()); インターフェイスの実装

} class FileLogger implements LoggerInterface { public function log(string $message): void { echo 'Logging to ﬁle: ' . $message; } } function logMessage(LoggerInterface $logger) { $logger->log('Hello, PHP!'); } logMessage(new FileLogger()); インターフェイスに依存

} class FileLogger implements LoggerInterface { public function log(string $message): void { echo 'Logging to ﬁle: ' . $message; } } function logMessage(LoggerInterface $logger) { $logger->log('Hello, PHP!'); } logMessage(new FileLogger()); Love注入

} class FileLogger implements LoggerInterface { public function log(string $message): void { echo 'Logging to ﬁle: ' . $message; } } function logMessage(LoggerInterface $logger) { $logger->log('Hello, PHP!'); } logMessage(new FileLogger()); Love注入 (LoggerInterfaceを実装しているものであれば注入できる)

GoとPHPのインターフェイスまず、PHPのインターフェイス明示的な実装 • `implements` で明示的にインターフェイスを実装 • どのクラスがどのインターフェイスを実装しているかが明確

GoとPHPのインターフェイスつづいて、Goのインターフェイス type LoggerInterface interface { Log(message string) } type
FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) }

FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) } インターフェイスの定義

FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) } FileLogger 構造体

FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) } FileLoggerはインターフェイスを満たしている

FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) } インターフェイスに依存

FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) } Love注入

FileLogger struct{} func (f FileLogger) Log(message string) { fmt.Println("Logging to ﬁle:", message) } func logMessage(logger LoggerInterface) { logger.Log("Hello, Go!") } func main() { logMessage(FileLogger{}) } Love注入 (LoggerInterfaceを満たしているものであれば注入できる)

GoとPHPのインターフェイスつづいて、Goのインターフェイス暗黙的な実装 • 構造体(型)がインターフェイスで宣言されたメソッドを持っていれば、インターフェイスを「暗黙的に」実装しているとみなされる • インターフェイスで宣言されたメソッドを持っている

GoとPHPのインターフェイスつづいて、Goのインターフェイス暗黙的な実装 • 構造体(型)がインターフェイスで宣言されたメソッドを持っていれば、インターフェイスを「暗黙的に」実装しているとみなされる • インターフェイスで宣言されたメソッドを持っている ↓
インターフェイスを満たす

GoとPHPのインターフェイスつづいて、Goのインターフェイス暗黙的な実装 • 構造体がインターフェイスに必要なメソッドを持っていれば、インターフェイスを「暗黙的に」実装しているとみなされる • インターフェイスに必要なメソッドを持っている ↓
インターフェイスを満たすインターフェイスを満たすとは？？？

2. Goのインターフェイスを少し深ぼる 1. GoとPHPのインターフェイス 2. Goのインターフェイスを少し深ぼる 3. サンプルを交えてさらに深ぼる 4. まとめ

2. Goのインターフェイスを少し深ぼる Goのインターフェイスはダックタイピング • Goでは明示的に`implements`を宣言しなくても、必要なメソッドを持っていればインターフェイスを実装しているとみなされる

2. Goのインターフェイスを少し深ぼる Goのインターフェイスはダックタイピング • Goでは明示的に`implements`を宣言しなくても、必要なメソッドを持っていればインターフェイスを実装しているとみなされる • 「もしそれ(型)が特定のメソッドを持っていて、その動作が期待通りなら、それはインターフェイスを実装してい
るとみなされる」

るとみなされる」 • 「アヒルのように歩き、アヒルのように鳴くものは、アヒルだろう」

るとみなされる」 • 「アヒルのように歩き、アヒルのように鳴くものは、アヒルだろう」→ ダックタイピング

2. Goのインターフェイスを少し深ぼる Goのインターフェイスはダックタイピング型そのものがインターフェイスを実装していることを明示しなくても良い設計を採用している • Go言語プログラミングエッセンス ◦ https://www.amazon.co.jp/dp/4297134195
◦ P47, P68 あたり

2. Goのインターフェイスを少し深ぼるインターフェイスを満たすとは？？？ • インターフェイスには、実装すべきメソッドのシグネチャ(名前、引数、戻り値)が定義されている • 構造体(型)がそのインターフェイスに定義されたすべてのメソッドを持っている場合、暗黙的にそのインターフェイスを満たしていると見なされる

2. Goのインターフェイスを少し深ぼるインターフェイスを満たすとは？？？ • インターフェイスには、実装すべきメソッドのシグネチャ(名前、引数、戻り値)が定義されている • 構造体(型)がそのインターフェイスに定義されたすべてのメソッドを持っている場合、暗黙的にそのインターフェイスを満たしていると見なされる
• インターフェイスを満たすとは、インターフェイスに定義されたすべてのメソッドを提供することを意味する ◦ そのままやな

3. サンプルを交えてさらに深ぼる 1. GoとPHPのインターフェイス 2. Goのインターフェイスを少し深ぼる 3. サンプルを交えてさらに深ぼる 4. まとめ

3. サンプルを交えてさらに深ぼる構造体がインターフェイスを満たす // Speakerインターフェイスを定義 type Speaker interface { Speak()
} // Person構造体を定義 type Person struct{} // PersonにSpeakメソッドを追加 func (p Person) Speak() { fmt.Println("Hello, I am a person.") } func introduce(s Speaker) { s.Speak() } func main() { p := Person{} // Person構造体はSpeakメソッドがあるので、Speakerインターフェイスを満たす introduce(p) } • 構造体がインターフェイスを満たす ◦ Person構造体はSpeakerインターフェイスのSpeakメソッドを実装しているため、暗黙的(自動的)に Speakerインターフェイスを満たす • インターフェイス型への代入 ◦ introduce関数はSpeaker型の引数を受け取るため、Speakerインターフェイスを満たすPerson構造体を引数として渡せる

3. サンプルを交えてさらに深ぼるカスタム型がインターフェイスを満たす // FormatterInterface インターフェイス type FormatterInterface interface {
Format() string } // カスタム型 CustomString を定義 type CustomString string // ❌型エイリアス（型は変わらないのでメソッドを定義できない） // type CustomString = string // Format メソッドを定義（FormatterInterface を満たす） func (s CustomString) Format() string { return strings.ToUpper(string(s)) } func main() { var str FormatterInterface = CustomString("hello, world") fmt.Println(str.Format()) // 出力: HELLO, WORLD } • カスタム型がインターフェイスを満たす ◦ Goは基本型(string, int, bool など) や、複合型(slice, map, chan, function など)に対して型を別で定義できる ▪ カスタム型 ▪ type CustomString string • ※型エイリアスとは違うよ • type CustomString = string ◦ 基本型や複合型を基にしたカスタム型を作成し、そのカスタム型にメソッドを追加することでインターフェースを満たすことができる

3. サンプルを交えてさらに深ぼる利点：振る舞いを切り替えられる type Speaker interface { Speak() } //
Dog構造体 type Dog struct{} func (d Dog) Speak() { fmt.Println("I am a dog.") } // Robot構造体 type Robot struct{} func (r Robot) Speak() { fmt.Println("I am a robot.") } func introduce(s Speaker) { s.Speak() } func main() { // Dog, Robot はSpeakerインターフェイスを満たす d := Dog{} r := Robot{} // 振る舞いを切り替えられる introduce(d) // "I am a dog." introduce(r) // "I am a robot." }

3. サンプルを交えてさらに深ぼる PHPだとこんな感じ？ // Speaker インターフェイス interface Speaker { public
function speak(): void; } // Dog クラス class Dog implements Speaker { public function speak(): void { echo "I am a dog." . PHP_EOL; } } // Robot クラス class Robot implements Speaker { public function speak(): void { echo "I am a robot." . PHP_EOL; } } function introduce(Speaker $speaker): void { $speaker->speak(); } // メイン処理 $dog = new Dog(); $robot = new Robot(); introduce($dog); // 出力: I am a dog. introduce($robot); // 出力: I am a robot.

3. サンプルを交えてさらに深ぼる埋め込み // Reader インターフェイス type Reader interface {
Read() string } // Writer インターフェイス type Writer interface { Write(data string) } // ReaderとWriterを埋め込んでReadWriterインターフェイスを定義 type ReadWriter interface { Reader Writer } // FileHandler 構造体（ReaderとWriterを実装） type FileHandler struct { content string } func (f *FileHandler) Read() string { return f.content } func (f *FileHandler) Write(data string) { f.content = data } func handleReadWrite(rw ReadWriter) { // データを書き込む rw.Write("Hello, Go!") // データを読み込む fmt.Println("Read data:", rw.Read()) } func main() { ﬁle := &FileHandler{} // FileHandlerをReadWriterとして使用 handleReadWrite(ﬁle) // "Read data: Hello, Go!" }

3. サンプルを交えてさらに深ぼる PHPだとこんな感じ？ // Reader インターフェイス interface Reader { public
function read(): string; } // Writer インターフェイス interface Writer { public function write(string $data): void; } // ReadWriter インターフェイスは Reader と Writer を継承 interface ReadWriter extends Reader, Writer {} // FileHandler クラス（ReadWriter インターフェイスを実装） class FileHandler implements ReadWriter { private string $content = ''; // Reader インターフェイスの実装 public function read(): string { return $this->content; } // Writer インターフェイスの実装 public function write(string $data): void { $this->content = $data; } } // ReadWriter インターフェイスを引数に取る関数 function handleReadWrite(ReadWriter $rw): void { // データを書き込む $rw->write("Hello, PHP!"); // データを読み込む echo "Read data: " . $rw->read() . PHP_EOL; } // メイン処理 $ﬁle = new FileHandler(); // FileHandlerをReadWriterとして使用 handleReadWrite($ﬁle); // "Read data: Hello, PHP!"

3. サンプルを交えてさらに深ぼる PHPだとこんな感じ？ // Reader インターフェイス interface Reader { public
function read(): string; } // Writer インターフェイス interface Writer { public function write(string $data): void; } // ReadWriter インターフェイスは Reader と Writer を継承 interface ReadWriter extends Reader, Writer {} // FileHandler クラス（ReadWriter インターフェイスを実装） class FileHandler implements ReadWriter { private string $content = ''; // Reader インターフェイスの実装 public function read(): string { return $this->content; } // Writer インターフェイスの実装 public function write(string $data): void { $this->content = $data; } } // ReadWriter インターフェイスを引数に取る関数 function handleReadWrite(ReadWriter $rw): void { // データを書き込む $rw->write("Hello, PHP!"); // データを読み込む echo "Read data: " . $rw->read() . PHP_EOL; } // メイン処理 $ﬁle = new FileHandler(); // FileHandlerをReadWriterとして使用 handleReadWrite($ﬁle); // "Read data: Hello, PHP!" • PHPではextendsを用いてインターフェイスを継承し、新たなインターフェイスを作成 • Goの埋め込みは「継承」というより「コンポジション（合成）、委譲」に近い ◦ そもそもGoに継承はない

3. サンプルを交えてさらに深ぼる空インターフェイス interface{} (any) func printAnything(v interface{}) { fmt.Println(v)
} func main() { printAnything(42) // 整数を出力 printAnything("Hello") // 文字列を出力 printAnything(3.14) // 浮動小数点を出力 printAnything(true) // ブール値を出力 } func main() { data := map[string]interface{}{ "name": "Alice", "age": 25, "active": true, "scores": []int{85, 90, 78}, } // 値を動的に処理 for key, value := range data { fmt.Printf("Key: %s, Type: %T, Value: %v\n", key, value, value) } } Key: name, Type: string, Value: Alice Key: age, Type: int, Value: 25 Key: active, Type: bool, Value: true Key: scores, Type: []int, Value: [85 90 78] • メソッドを一切持たないインターフェイス • すべての型が暗黙的にこの空インターフェイスを実装しているとみなされる

3. サンプルを交えてさらに深ぼる空インターフェイス interface{} (any) func printAnything(v interface{}) { fmt.Println(v)
} func main() { printAnything(42) // 整数を出力 printAnything("Hello") // 文字列を出力 printAnything(3.14) // 浮動小数点を出力 printAnything(true) // ブール値を出力 } func main() { data := map[string]interface{}{ "name": "Alice", "age": 25, "active": true, "scores": []int{85, 90, 78}, } // 値を動的に処理 for key, value := range data { fmt.Printf("Key: %s, Type: %T, Value: %v\n", key, value, value) } } Key: name, Type: string, Value: Alice Key: age, Type: int, Value: 25 Key: active, Type: bool, Value: true Key: scores, Type: []int, Value: [85 90 78] PHPだと mixed だな？ object|resource|array|string|ﬂoat|int|bool|null

3. サンプルを交えてさらに深ぼる空インターフェイス型スイッチ func process(value interface{}) { switch v
:= value.(type) { case int: fmt.Printf("Integer: %d\n", v) case string: fmt.Printf("String: %s\n", v) case bool: fmt.Printf("Boolean: %t\n", v) default: fmt.Printf("Unknown type: %T\n", v) } } func main() { process(42) // 出力: Integer: 42 process("Go Lang") // 出力: String: Go Lang process(true) // 出力: Boolean: true process(3.14) // 出力: Unknown type: ﬂoat64 } // 構文 switch v := value.(type) { case T1: // value が T1 型の場合の処理 case T2: // value が T2 型の場合の処理 default: // どの型にも一致しない場合の処理 } // value が実際に保持する具体的な型を判定する // 型スイッチ外では使用できない

3. サンプルを交えてさらに深ぼる空インターフェイス型アサーション func handle(value interface{}) { if v,
ok := value.(int); ok { fmt.Printf("Double the integer: %d\n", v*2) } else if v, ok := value.(string); ok { fmt.Printf("Uppercase the string: %s\n", strings.ToUpper(v)) } else { fmt.Printf("Unhandled type: %T\n", value) } } func main() { handle(10) // 出力: Double the integer: 20 handle("hello") // 出力: Uppercase the string: HELLO handle(3.14) // 出力: Unhandled type: ﬂoat64 } // 構文 t := i.(T) // インターフェース型の値を特定の型 T に変換（アサート）する // i が T を保持していない場合、panic を引き起こす t, ok := i.(T) // インターフェースの値が特定の型を保持しているかどうかをテストするために、型アサーションは2 つの値(基になる値とアサーションが成功したかどうかを報告するブール値)を返すことができる // i が T を保持していれば、 t は基になる値になり、 ok は真(true)になる

3. サンプルを交えてさらに深ぼる空インターフェイスを使う際の注意点 • 型安全性が低下 ◦ 空インターフェイスを多用すると、Goの静的型付けの利点を失う • 具体的な型を使える場合は使う
◦ 本当に型を柔軟にする必要がある場合のみ空インターフェイスを使い、可能であれば具体的な型や小さなインターフェイスを設計する方が望ましい ◦ それはそう

3. サンプルを交えてさらに深ぼる空インターフェイスを使う際の注意点 • 型安全性が低下 ◦ 空インターフェイスを多用すると、Goの静的型付けの利点を失う • 具体的な型を使える場合は使う
◦ 本当に型を柔軟にする必要がある場合のみ空のインターフェイスを使い、可能であれば具体的な型や小さなインターフェイスを設計する方が望ましい ◦ それはそう避けよう空インターフェイスあまりメリットはない

3. サンプルを交えてさらに深ぼるインターフェイスをさくっと満たせる // TwoMethodsインターフェイスの定義（2つのメソッドが含まれている） type TwoMethods interface { MethodOne()
MethodTwo() } // MethodOneのみを持つ（TwoMethodsインターフェイスには適合しない） type PartialOne struct{} func (p PartialOne) MethodOne() {} // MethodOneとMethodTwoを持つ（TwoMethodsインターフェイスに適合） type PartialTwo struct{} func (p PartialTwo) MethodOne() {} func (p PartialTwo) MethodTwo() {} // 3つのメソッドを持つが、TwoMethodsの2つを満たしている type ExtraMethods struct{} func (e ExtraMethods) MethodOne() {} func (e ExtraMethods) MethodTwo() {} func (e ExtraMethods) MethodThree() {} // TwoMethodsインターフェイスを受け取る関数 func useTwoMethods(t TwoMethods) { t.MethodOne() t.MethodTwo() } func main() { partialOne := PartialOne{} partialTwo := PartialTwo{} extraMethods := ExtraMethods{} // エラー: PartialOneはTwoMethodsを満たしていない // useTwoMethods(partialOne) partialOne.MethodOne() useTwoMethods(partialTwo) // 正常に動作する useTwoMethods(extraMethods) // 正常に動作する }

MethodTwo() } // MethodOneのみを持つ（TwoMethodsインターフェイスには適合しない） type PartialOne struct{} func (p PartialOne) MethodOne() {} // MethodOneとMethodTwoを持つ（TwoMethodsインターフェイスに適合） type PartialTwo struct{} func (p PartialTwo) MethodOne() {} func (p PartialTwo) MethodTwo() {} // 3つのメソッドを持つが、TwoMethodsの2つを満たしている type ExtraMethods struct{} func (e ExtraMethods) MethodOne() {} func (e ExtraMethods) MethodTwo() {} func (e ExtraMethods) MethodThree() {} // TwoMethodsインターフェイスを受け取る関数 func useTwoMethods(t TwoMethods) { t.MethodOne() t.MethodTwo() } func main() { partialOne := PartialOne{} partialTwo := PartialTwo{} extraMethods := ExtraMethods{} // エラー: PartialOneはTwoMethodsを満たしていない // useTwoMethods(partialOne) partialOne.MethodOne() useTwoMethods(partialTwo) // 正常に動作する useTwoMethods(extraMethods) // 正常に動作する } MethodTwo() を実装するだけ

MethodTwo() } // MethodOneのみを持つ（TwoMethodsインターフェイスには適合しない） type PartialOne struct{} func (p PartialOne) MethodOne() {} // MethodOneとMethodTwoを持つ（TwoMethodsインターフェイスに適合） type PartialTwo struct{} func (p PartialTwo) MethodOne() {} func (p PartialTwo) MethodTwo() {} // 3つのメソッドを持つが、TwoMethodsの2つを満たしている type ExtraMethods struct{} func (e ExtraMethods) MethodOne() {} func (e ExtraMethods) MethodTwo() {} func (e ExtraMethods) MethodThree() {} // TwoMethodsインターフェイスを受け取る関数 func useTwoMethods(t TwoMethods) { t.MethodOne() t.MethodTwo() } func main() { partialOne := PartialOne{} partialTwo := PartialTwo{} extraMethods := ExtraMethods{} // エラー: PartialOneはTwoMethodsを満たしていない // useTwoMethods(partialOne) partialOne.MethodOne() useTwoMethods(partialTwo) // 正常に動作する useTwoMethods(extraMethods) // 正常に動作する } さくっとインターフェイスを満たせる

3. サンプルを交えてさらに深ぼる PHPだとこんな感じ？ // TwoMethodsインターフェイスの定義（2つのメソッドを含む） interface TwoMethods { public function
methodOne(): void; public function methodTwo(): void; } // methodOneのみを持つ //（TwoMethodsインターフェイスを実装しない, できない） class PartialOne { public function methodOne(): void {} } // methodOneとmethodTwoを持つ（TwoMethodsインターフェイスを実装） class PartialTwo implements TwoMethods { public function methodOne(): void {} public function methodTwo(): void {} } // 3つのメソッドを持つが、TwoMethodsの2つを実装している class ExtraMethods implements TwoMethods { public function methodOne(): void {} public function methodTwo(): void {} public function methodThree(): void {} } // TwoMethodsインターフェイスを受け取る関数 function useTwoMethods(TwoMethods $t): void { $t->methodOne(); $t->methodTwo(); } // メイン処理 function main(): void { $partialOne = new PartialOne(); $partialTwo = new PartialTwo(); $extraMethods = new ExtraMethods(); $partialOne->methodOne(); // エラー: PartialOneはTwoMethodsを実装していない // useTwoMethods($partialOne); useTwoMethods($partialTwo); // 正常に動作する useTwoMethods($extraMethods); // 正常に動作する } main();

methodOne(): void; public function methodTwo(): void; } // methodOneのみを持つ //（TwoMethodsインターフェイスを実装しない, できない） class PartialOne { public function methodOne(): void {} } // methodOneとmethodTwoを持つ（TwoMethodsインターフェイスを実装） class PartialTwo implements TwoMethods { public function methodOne(): void {} public function methodTwo(): void {} } // 3つのメソッドを持つが、TwoMethodsの2つを実装している class ExtraMethods implements TwoMethods { public function methodOne(): void {} public function methodTwo(): void {} public function methodThree(): void {} } // TwoMethodsインターフェイスを受け取る関数 function useTwoMethods(TwoMethods $t): void { $t->methodOne(); $t->methodTwo(); } // メイン処理 function main(): void { $partialOne = new PartialOne(); $partialTwo = new PartialTwo(); $extraMethods = new ExtraMethods(); $partialOne->methodOne(); // エラー: PartialOneはTwoMethodsを実装していない // useTwoMethods($partialOne); useTwoMethods($partialTwo); // 正常に動作する useTwoMethods($extraMethods); // 正常に動作する } main(); methodTwo()を実装して TwoMethodsをimplements する必要がある

methodOne(): void; public function methodTwo(): void; } // methodOneのみを持つ //（TwoMethodsインターフェイスを実装しない, できない） class PartialOne { public function methodOne(): void {} } // methodOneとmethodTwoを持つ（TwoMethodsインターフェイスを実装） class PartialTwo implements TwoMethods { public function methodOne(): void {} public function methodTwo(): void {} } // 3つのメソッドを持つが、TwoMethodsの2つを実装している class ExtraMethods implements TwoMethods { public function methodOne(): void {} public function methodTwo(): void {} public function methodThree(): void {} } // TwoMethodsインターフェイスを受け取る関数 function useTwoMethods(TwoMethods $t): void { $t->methodOne(); $t->methodTwo(); } // メイン処理 function main(): void { $partialOne = new PartialOne(); $partialTwo = new PartialTwo(); $extraMethods = new ExtraMethods(); $partialOne->methodOne(); // エラー: PartialOneはTwoMethodsを実装していない // useTwoMethods($partialOne); useTwoMethods($partialTwo); // 正常に動作する useTwoMethods($extraMethods); // 正常に動作する } main(); TwoMethods を implements して methodTwo() を実装する必要があるなんとなくダルいな？個人の見解

3. サンプルを交えてさらに深ぼるいったんまとめ • Go ◦ ダックタイピングによる暗黙的なインターフェイス実装 ▪ さくっと満たせる ◦
柔軟性？ • PHP ◦ implements を用いた明示的なインターフェイス実装 ▪ 若干めんどい ◦ 明確性？

3. サンプルを交えてさらに深ぼるインターフェイスをさくっと満たせるが、、 // TwoMethodsインターフェイスの定義（2つのメソッドが含まれている） type TwoMethods interface { MethodOne()
MethodTwo() } // MethodOneのみを持つ（TwoMethodsインターフェイスには適合しない） type PartialOne struct{} func (p PartialOne) MethodOne() {} // MethodOneとMethodTwoを持つ（TwoMethodsインターフェイスに適合） type PartialTwo struct{} func (p PartialTwo) MethodOne() {} func (p PartialTwo) MethodTwo() {} // 3つのメソッドを持つが、TwoMethodsの2つを満たしている type ExtraMethods struct{} func (e ExtraMethods) MethodOne() {} func (e ExtraMethods) MethodTwo() {} func (e ExtraMethods) MethodThree() {} // TwoMethodsインターフェイスを受け取る関数 func useTwoMethods(t TwoMethods) { t.MethodOne() t.MethodTwo() } func main() { partialOne := PartialOne{} partialTwo := PartialTwo{} extraMethods := ExtraMethods{} // エラー: PartialOneはTwoMethodsを満たしていない // useTwoMethods(partialOne) partialOne.MethodOne() useTwoMethods(partialTwo) // 正常に動作する useTwoMethods(extraMethods) // 正常に動作する } ここだけを見たときにインターフェイスを満たしているのかどうかわかりづらい明示されていない

3. サンプルを交えてさらに深ぼる例えばこういうの user/ ├── domain/ │ └── user.go #
ユーザードメイン ├── usecase/ │ └── user_usecase.go # ユースケース ├── infra/ │ └── mysql_user_repo.go # MySQLのリポジトリ実装 └── main.go # エントリーポイント

3. サンプルを交えてさらに深ぼる Domain層(user/domain/user.go) package domain type User struct { ID
int Name string } // ユーザーデータ操作のインターフェイスを定義 type UserRepositoryInterface interface { GetUserByID(id int) (*User, error) SaveUser(user *User) error }

3. サンプルを交えてさらに深ぼる UseCase層(user/usecase/user_usecase.go) package usecase import "user/domain" // ユーザー関連のビジネスロジックを管理 type
UserUseCase struct { repo domain.UserRepositoryInterface } // 新しいUserUseCaseインスタンスを作成 func NewUserUseCase(repo domain.UserRepositoryInterface) *UserUseCase { return &UserUseCase{repo: repo} } // 指定されたIDのユーザーを取得 func (u *UserUseCase) GetUser(id int) (*domain.User, error) { return u.repo.GetUserByID(id) }

3. サンプルを交えてさらに深ぼるインフラ層(user/infra/mysql_user_repo.go) package infra import ( "fmt" "user/domain" )
// MySQL用のUserRepositoryInterfaceを満たす type MySQLUserRepository struct{} // GetUserByIDはMySQLからユーザーをIDで取得 func (m MySQLUserRepository) GetUserByID(id int) (*domain.User, error) { fmt.Println("MySQLデータベースからユーザーを取得します") return &domain.User{ID: id, Name: "MySQL User"}, nil } // SaveUserはMySQLにユーザーを保存 func (m MySQLUserRepository) SaveUser(user *domain.User) error { fmt.Println("MySQLデータベースにユーザーを保存します") return nil }

3. サンプルを交えてさらに深ぼるエントリーポイント(user/main.go) package main import ( "fmt" "user/infra" "user/usecase"
) func main() { // MySQLリポジトリのインスタンスを作成 mysqlRepo := infra.MySQLUserRepository{} // リポジトリをUseCaseに注入 uc := usecase.NewUserUseCase(&mysqlRepo) // ユーザー情報を取得 user, err := uc.GetUser(1) if err != nil { fmt.Println("ユーザー取得中にエラーが発生しました:", err) return } fmt.Printf("ユーザー情報: ID=%d, 名前=%s\n", user.ID, user.Name) }

3. サンプルを交えてさらに深ぼるエントリーポイント(user/main.go) package main import ( "fmt" "user/infra" "user/usecase"
) func main() { // MySQLリポジトリのインスタンスを作成 mysqlRepo := infra.MySQLUserRepository{} // リポジトリをUseCaseに注入 uc := usecase.NewUserUseCase(&mysqlRepo) // ユーザー情報を取得 user, err := uc.GetUser(1) if err != nil { fmt.Println("ユーザー取得中にエラーが発生しました:", err) return } fmt.Printf("ユーザー情報: ID=%d, 名前=%s\n", user.ID, user.Name) } LoveUserRepositoryIn terface を注入している

// MySQL用のUserRepositoryInterfaceを満たす type MySQLUserRepository struct{} // GetUserByIDはMySQLからユーザーをIDで取得 func (m MySQLUserRepository) GetUserByID(id int) (*domain.User, error) { fmt.Println("MySQLデータベースからユーザーを取得します") return &domain.User{ID: id, Name: "MySQL User"}, nil } // SaveUserはMySQLにユーザーを保存 func (m MySQLUserRepository) SaveUser(user *domain.User) error { fmt.Println("MySQLデータベースにユーザーを保存します") return nil } こいつだけを見たときに UserRepositoryInterf ace を満たしているのかどうかわかりづらい暗黙的に満たされるから

// MySQL用のUserRepositoryInterfaceを満たす type MySQLUserRepository struct{} // UserRepositoryInterfaceの実装を明示的にチェック var _ domain.UserRepositoryInterface = (*MySQLUserRepository)(nil) // GetUserByIDはMySQLからユーザーをIDで取得 func (m MySQLUserRepository) GetUserByID(id int) (*domain.User, error) { fmt.Println("MySQLデータベースからユーザーを取得します") return &domain.User{ID: id, Name: "MySQL User"}, nil } // SaveUserはMySQLにユーザーを保存 // 〜こういうチェックもできるがコンパイル時に MySQLUserRepository が UserRepositoryInterface を実装しているかをチェックする

// UserRepository実装 type MySQLUserRepository struct{} // UserRepositoryInterfaceの実装を明示的にチェック var _ domain.UserRepositoryInterface = (*MySQLUserRepository)(nil) // GetUserByIDはMySQLからユーザーをIDで取得 func (m MySQLUserRepository) GetUserByID(id int) (*domain.User, error) { fmt.Println("MySQLデータベースからユーザーを取得します") return &domain.User{ID: id, Name: "MySQL User"}, nil } // SaveUserはMySQLにユーザーを保存 // 〜こういうチェックもできるが慣れが必要な気がします個人の見解

3. サンプルを交えてさらに深ぼるちなみにPHPだとこうかな？ <?php namespace Infra; use Domain\User; use Domain\UserRepositoryInterface;
class MySQLUserRepository implements UserRepositoryInterface { public function getUserByID(int $id): ?User { echo "MySQLデータベースからユーザーを取得します\n"; return new User($id, "MySQL User"); } public function saveUser(User $user): void { echo "MySQLデータベースにユーザーを保存します\n"; } }

3. サンプルを交えてさらに深ぼるちなみにPHPだとこうかな？ <?php namespace Infra; use Domain\User; use Domain\UserRepositoryInterface;
class MySQLUserRepository implements UserRepositoryInterface { public function getUserByID(int $id): ?User { echo "MySQLデータベースからユーザーを取得します\n"; return new User($id, "MySQL User"); } public function saveUser(User $user): void { echo "MySQLデータベースにユーザーを保存します\n"; } } 明示的だね

4. まとめ 1. GoとPHPのインターフェイス 2. Goのインターフェイスを少し深ぼる 3. サンプルを交えてさらに深ぼる 4. まとめ

まとめ 4. まとめ Go PHP 実装方法ダックタイピングによる暗黙的なインターフェイス実装
implements による明示的なインターフェイス実装メリット柔軟性が高い、さくっと満たせる明確で分かりやすいデメリットどこでインターフェイスを実装しているかが分かりづらい若干めんどい

implements による明示的なインターフェイス実装メリット柔軟性が高い、さくっと満たせる明確で分かりやすいデメリットどこでインターフェイスを実装しているかが分かりづらい若干めんどい implements 明示が不要 ↔ 明示が必要慣れが必要

implements による明示的なインターフェイス実装メリット柔軟性が高い、さくっと満たせる明確で分かりやすいデメリットどこでインターフェイスを実装しているかが分かりづらい若干めんどい https://note.com/ici_mici/n/n4603a3ecd958 「慣れだよ」は最低の助言｜ナカミチ

implements を用いた明示的なインターフェイス実装メリット柔軟性が高い、さくっと満たせる明確で分かりやすいデメリットどこでインターフェイスを実装しているかが分かりづらい若干めんどい https://note.com/ici_mici/n/n4603a3ecd958 「慣れだよ」は最低の助言｜ナカミチ 😇

4. まとめご清聴ありがとうございました

GoとPHPのインターフェイスの違い

GoとPHPのインターフェイスの違い

More Decks by shimabox

Other Decks in Programming

Featured

Transcript