English 中文 العربية 日本語 Português

Go: Goのメソッドとインターフェース：値型／ポインタ型のレシーバー、暗黙の実装、型アサーション、および

最終更新：2026-08-26

メソッドとはレシーバーを受け取る関数のことであり、インターフェースとはメソッドのシグネチャの集合である。Goは、クラス継承の複雑さを伴わずに、簡潔な構文でオブジェクト指向の「振る舞いによる抽象化」を実現している。

Goにはクラスはありませんが、メソッドは存在します。また、implementsというキーワードはありませんが、ダックタイピングに基づくインターフェースがあります。このレッスンでは、Goにおけるオブジェクト指向プログラミングのすべての基本概念を習得し、インターフェースを使用して切り替え可能なマルチ決済ゲートウェイシステムを構築する方法を学びます。

1. 学習内容

2. あるEコマース決済エンジニアの実話

(1) 課題：switch文がハードコーディングされており、新しい決済ゲートウェイを追加するにはコアコードの修正が必要となる。

チャーリーは、あるECプラットフォームのバックエンドエンジニアです。彼は決済モジュールの保守を担当しています：

「現在、Stripeに対応していますが、PayPalも追加したいと考えています。しかし、決済コードにはif gateway == "stripe"が至る所に含まれているため、PayPalを追加するにはファイル全体を書き直す必要があります。」

彼は前任者が書いたコードを開いた：

GO 
// Bad code: Hard-coded payment logic
func charge(amount float64, gateway string) error {
    switch gateway {
    case "stripe":
        // Stripe HTTP API calls...
        return stripeCharge(amount)
    case "paypal":
        // Adding PayPal means I have to add another case here.
        return nil
    default:
        return fmt.Errorf("unknown gateway: %s", gateway)
    }
}

決済ゲートウェイが追加されるたびに、charge関数を修正しなければならない。これはオープン・クローズドの原則（拡張にはオープン、修正にはクローズド）に反している。

(2) Goの解決策：暗黙的なインターフェースの実装

GO 
// payment.go
package main

import "fmt"

// Define the Payment Interface
type PaymentGateway interface {
    Charge(amount float64) error
    Refund(transactionID string) error
}

// Stripe Implementation (No need to write "implements"!)
type Stripe struct {
    apiKey string
}

func (s Stripe) Charge(amount float64) error {
    fmt.Printf("Stripe: charged $%.2f\n", amount)
    return nil
}

func (s Stripe) Refund(txID string) error {
    fmt.Printf("Stripe: refunded %s\n", txID)
    return nil
}

// PayPal Implementation
type PayPal struct {
    email string
}

func (p PayPal) Charge(amount float64) error {
    fmt.Printf("PayPal: charged $%.2f\n", amount)
    return nil
}

func (p PayPal) Refund(txID string) error {
    fmt.Printf("PayPal: refunded %s\n", txID)
    return nil
}

// Consumer Code: Depends only on the interface, not on the concrete impl
func processPayment(gw PaymentGateway, amount float64) error {
    return gw.Charge(amount)
}

func main() {
    stripe := Stripe{apiKey: "sk_test_xxx"}
    paypal := PayPal{email: "merchant@example.com"}

    // The same processPayment function can accept different concrete types.
    processPayment(stripe, 99.99)
    processPayment(paypal, 49.99)
}

出力：

TEXT 📖 参照専用 
Stripe: charged $99.99
PayPal: charged $49.99

(3) メリット：開閉の原則

方法 新しいゲートウェイを追加 コアコードを修正 リスク
スイッチのハードコーディング charge 関数の修正 ✅ 必須 🔴 高
インターフェースの抽象化 インターフェースを実装するための新しい構造体を作成する ❌ 不要 🟢 低
💡 ヒント： Goのインターフェースは暗黙的に実装されます。つまり、構造体（struct）がインターフェースで定義されたすべてのメソッドを持っている限り、その構造体は「自動的に」そのインターフェースを実装することになります。これはJavaのimplementsよりも柔軟性が高く、サードパーティのパッケージに含まれる型であっても、外部パッケージで定義されたインターフェースを実装することが可能です。

3. メソッドの定義

(1) メソッド = レシーバーを持つ関数

GO 
package main

import "fmt"

type Rectangle struct {
    Width  float64
    Height float64
}

// Method: The receiver (r Rectangle) is placed between the func keyword and the function name
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    fmt.Printf("Area: %.2f\n", rect.Area())  // Area: 50.00
}

(2) 値受け取りとポインタ受け取り

GO 
package main

import "fmt"

type Counter struct {
    Value int
}

// Value receiver: operates on a copy; does not affect the original object
func (c Counter) IncrementValue() Counter {
    c.Value++
    return c
}

// Pointer receiver: directly modifies the original object
func (c *Counter) IncrementPointer() {
    c.Value++
}

func main() {
    c := Counter{Value: 10}

    // Value receiver must use the return value
    c = c.IncrementValue()
    fmt.Printf("After value receiver: %d\n", c.Value)

    // Pointer receiver modifies directly
    c.IncrementPointer()
    fmt.Printf("After pointer receiver: %d\n", c.Value)
}

出力：

TEXT 📖 参照専用 
After value receiver: 11
After pointer receiver: 12

▶ サンプル：値型とポインタ型の受信者の選択

GO 
package main

import "fmt"

type User struct {
    Name string
    Age  int
}

// Value receiver: suitable for small objects and read-only operations
func (u User) Info() string {
    return fmt.Sprintf("%s (%d)", u.Name, u.Age)
}

// Pointer receiver: suitable for large objects and modification operations
func (u *User) SetName(name string) {
    u.Name = name
}

type LargeData struct {
    data [1000]int
}

// Large structures must use pointer receivers (to avoid copying 1000 ints)
func (l *LargeData) Process() int {
    sum := 0
    for _, v := range l.data {
        sum += v
    }
    return sum
}

func main() {
    u := User{Name: "Alice", Age: 28}
    u.SetName("Alice Smith")
    fmt.Println(u.Info())

    ld := LargeData{}
    for i := 0; i < 1000; i++ {
        ld.data[i] = i
    }
    fmt.Printf("Sum: %d\n", ld.Process())
}
▶ 試してみよう

出力：

TEXT 📖 参照専用 
Alice Smith (28)
Sum: 499500

(4) 値型レシーバーとポインタ型レシーバーの選び方のガイド

シナリオ 受信機の種類 理由
このメソッドはレシーバーを変更しません 値とポインタの両方が使用可能です 値レシーバーの方が安全です（副作用がありません）
このメソッドはレシーバーを変更する必要がある ポインタ 値レシーバーはコピーを変更する
大きな構造体（100バイト超） ポインタ 大きなオブジェクトのコピーは避ける
受信側は map/slice/func である 値（参照型） すでに参照である
型はプリミティブ型である 値（ポインタは不要） サイズが小さく、コピーにかかるオーバーヘッドが少ない

4. インターフェース：暗黙の実装（ダックタイピング）

(1) インターフェースの定義

GO 
// Define an interface: a set of method signatures
type Stringer interface {
    String() string
}

▶ サンプル：暗黙の実装

GO 
package main

import "fmt"

// 1. Define an interface
type Speaker interface {
    Speak() string
}

// 2. Define two structs, both of which implement the Speak method
type Dog struct{ Name string }

func (d Dog) Speak() string {
    return fmt.Sprintf("%s says: Woof!", d.Name)
}

type Cat struct{ Name string }

func (c Cat) Speak() string {
    return fmt.Sprintf("%s says: Meow!", c.Name)
}

// 3. Consumer function: accepts an interface
func greet(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}

    // Both Dog and Cat implicitly implement Speaker; the implements keyword is not required.
    greet(dog)
    greet(cat)
}
▶ 試してみよう

出力：

TEXT 📖 参照専用 
Buddy says: Woof!
Whiskers says: Meow!

(3) インターフェースの値：動的型 + 動的値

GO 
package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }

func (d Dog) Speak() string {
    return fmt.Sprintf("%s says: Woof!", d.Name)
}

func main() {
    var s Speaker          // interface variable, defaults to nil
    fmt.Printf("nil: %T, %v\n", s, s)

    s = Dog{Name: "Buddy"} // interface stores dynamic type and dynamic value
    fmt.Printf("type=%T, value=%v\n", s, s)
}

出力：

TEXT 📖 参照専用 
nil: <nil>, <nil>
type=main.Dog, value={Buddy}

5. 空のインターフェース interface{} と型アサーション

(1) 空のインターフェース：任意の型

GO 
package main

import "fmt"

type Dog struct {
    Name string
}

// An empty interface can store any type
func describe(v interface{}) {
    fmt.Printf("type=%T, value=%v\n", v, v)
}

func main() {
    describe(42)
    describe("hello")
    describe(3.14)
    describe(Dog{Name: "Buddy"})
}

出力：

TEXT 📖 参照専用 
type=int, value=42
type=string, value=hello
type=float64, value=3.14
type=main.Dog, value={Buddy}

▶ サンプル：型アサーション（コンマ区切り構文）

GO 
package main

import "fmt"

func printValue(v interface{}) {
    // Type assertion: extract underlying value
    if s, ok := v.(string); ok {
        fmt.Printf("String: %s (len=%d)\n", s, len(s))
        return
    }
    if n, ok := v.(int); ok {
        fmt.Printf("Int: %d (double=%d)\n", n, n*2)
        return
    }
    fmt.Printf("Unknown type: %T = %v\n", v, v)
}

func main() {
    printValue("hello")
    printValue(42)
    printValue(3.14)
}
▶ 試してみよう

出力：

TEXT 📖 参照専用 
String: hello (len=5)
Int: 42 (double=84)
Unknown type: float64 = 3.14

(3) タイプ切り替え

GO 
package main

import "fmt"

func inspect(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Printf("string: %q (len=%d)\n", val, len(val))
    case int:
        fmt.Printf("int: %d\n", val)
    case float64:
        fmt.Printf("float64: %.2f\n", val)
    case bool:
        fmt.Printf("bool: %v\n", val)
    default:
        fmt.Printf("unknown: %T\n", val)
    }
}

func main() {
    inspect("hello")
    inspect(42)
    inspect(3.14)
    inspect(true)
    inspect([]int{1, 2, 3})
}

出力：

TEXT 📖 参照専用 
string: "hello" (len=5)
int: 42
float64: 3.14
bool: true
unknown: []int

(4) 型アサーションと型スイッチの比較

シナリオ 推奨事項
特定の型であるかどうかを確認する 型のアサーション v.(T)
複数のタイプを選択 タイプ切り替え v.(type)
確認する（値は不要） _, ok := v.(T)

6. インターフェースの合成

(1) 既存のインターフェースを埋め込んで新しいインターフェースを作成する

GO 
package main

import "fmt"

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// Combine Reader and Writer to form a new interface
type ReadWriter interface {
    Reader
    Writer
}

// Implementation
type File struct{}

func (f File) Read(p []byte) (n int, err error) {
    return len(p), nil
}

func (f File) Write(p []byte) (n int, err error) {
    return len(p), nil
}

func main() {
    var rw ReadWriter = File{}
    buf := make([]byte, 10)
    rw.Read(buf)
    rw.Write(buf)
    fmt.Println("ReadWriter composite interface works as expected")
}

▶ サンプル：インターフェース合成の実践的な応用

GO 
package main

import "fmt"

type Logger interface {
    Log(message string)
}

type Notifier interface {
    Notify(message string)
}

// Composition
type LoggerNotifier interface {
    Logger
    Notifier
}

type ConsoleService struct{}

func (c ConsoleService) Log(message string) {
    fmt.Printf("[LOG] %s\n", message)
}

func (c ConsoleService) Notify(message string) {
    fmt.Printf("[NOTIFY] %s\n", message)
}

func main() {
    var svc LoggerNotifier = ConsoleService{}
    svc.Log("System startup")
    svc.Notify("User Alice logged in")
}
▶ 試してみよう

出力：

TEXT 📖 参照専用 
[LOG] System startup
[NOTIFY] User Alice logged in

(3) インターフェース合成メソッドのクイックリファレンス

組み合わせ 構文 説明
単一インターフェースの埋め込み type A interface { B } AにはBのすべてのメソッドが含まれている
複数のインターフェースの埋め込み type A interface { B; C } AにはBとCのすべてのメソッドが含まれている
埋め込み + 新しいメソッド type A interface { B; C; Do() } A にはメソッド B、C、および Do が含まれている

7. io.Reader / io.Writer 標準インターフェース

(1) 標準ライブラリにおける最も重要な2つのインターフェース

GO 
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

▶ サンプル：Readerのさまざまな実装方法

GO 
package main

import (
    "fmt"
    "io"
    "strings"
)

func printReader(r io.Reader) {
    buf := make([]byte, 8)
    for {
        n, err := r.Read(buf)
        if err == io.EOF {
            break
        }
        fmt.Printf("read: %q\n", buf[:n])
    }
}

func main() {
    // strings.Reader implements io.Reader
    fmt.Println("=== strings.Reader ===")
    printReader(strings.NewReader("hello world"))

    // You can also use bytes.Reader, os.File, etc.
}
▶ 試してみよう

出力：

TEXT 📖 参照専用 
=== strings.Reader ===
read: "hello wo"
read: "rld"

(3) io.Reader ＋ io.Writer の組み合わせ（標準ライブラリのチェーン）

GO 
package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    // Implementing a copy using io.Reader and io.Writer
    reader := strings.NewReader("hello Go interfaces")
    writer := &strings.Builder{}

    // io.Copy accepts any Reader and Writer
    n, _ := io.Copy(writer, reader)
    fmt.Printf("copied %d bytes: %q\n", n, writer.String())
}

出力：

TEXT 📖 参照専用 
copied 19 bytes: "hello Go interfaces"

(4) io.Reader を実装する標準型のリスト

タイプ パッケージ 実装
strings.Reader 文字列 リーダー
bytes.Reader バイト リーダー
os.File OS 読み取り・書き込み
bytes.Buffer バイト 読み取り・書き込み
net.Conn ネット 読み取り・書き込み
gzip.Reader 圧縮/gzip リーダー

8. 完全な例：複数の決済ゲートウェイの抽象化

このレッスンで学んだ重要な概念をすべて結びつけて、完全な決済システムを構築してみましょう：

GO 
// payment_system.go
package main

import (
    "fmt"
    "time"
)

// ---------- Interface Definition ----------

type PaymentGateway interface {
    Charge(amount float64) (string, error)     // Returns transaction ID
    Refund(transactionID string) error
    Name() string
}

// Logging Interface (Composition Example)
type TransactionLogger interface {
    Log(transactionID, gateway string, amount float64, success bool)
}

// ---------- Stripe Implementation ----------

type Stripe struct {
    apiKey string
}

func (s Stripe) Charge(amount float64) (string, error) {
    txID := fmt.Sprintf("STRIPE-%s", s.txID())
    fmt.Printf("[Stripe] charging $%.2f -> %s\n", amount, txID)
    return txID, nil
}

func (s Stripe) Refund(txID string) error {
    fmt.Printf("[Stripe] refunding %s\n", txID)
    return nil
}

func (s Stripe) Name() string {
    return "Stripe"
}

func (Stripe) txID() string {
    return fmt.Sprintf("%d", time.Now().UnixNano())
}

// ---------- PayPal Implementation ----------

type PayPal struct {
    email string
}

func (p PayPal) Charge(amount float64) (string, error) {
    txID := fmt.Sprintf("PP-%s", p.txID())
    fmt.Printf("[PayPal] charging $%.2f -> %s\n", amount, txID)
    return txID, nil
}

func (p PayPal) Refund(txID string) error {
    fmt.Printf("[PayPal] refunding %s\n", txID)
    return nil
}

func (p PayPal) Name() string {
    return "PayPal"
}

func (PayPal) txID() string {
    return fmt.Sprintf("%d", time.Now().UnixNano())
}

// ---------- Alipay Implementation ----------

type Alipay struct {
    appID string
}

func (a Alipay) Charge(amount float64) (string, error) {
    txID := fmt.Sprintf("ALI-%s", a.txID())
    fmt.Printf("[Alipay] charging $%.2f -> %s\n", amount, txID)
    return txID, nil
}

func (a Alipay) Refund(txID string) error {
    fmt.Printf("[Alipay] refunding %s\n", txID)
    return nil
}

func (a Alipay) Name() string {
    return "Alipay"
}

func (Alipay) txID() string {
    return fmt.Sprintf("%d", time.Now().UnixNano())
}

// ---------- Log Implementation (Empty Interface + Type Assertion Example) ----------

type ConsoleLogger struct{}

func (c ConsoleLogger) Log(transactionID, gateway string, amount float64, success bool) {
    status := "SUCCESS"
    if !success {
        status = "FAILED"
    }
    fmt.Printf("[%s] %s | %s | $%.2f | %s\n",
        status, transactionID, gateway, amount, time.Now().Format(time.RFC3339))
}

// ---------- Payment Service ----------

type PaymentService struct {
    gateway PaymentGateway
    logger  TransactionLogger
}

func NewPaymentService(gw PaymentGateway, logger TransactionLogger) *PaymentService {
    return &PaymentService{gateway: gw, logger: logger}
}

func (s *PaymentService) Charge(amount float64) error {
    txID, err := s.gateway.Charge(amount)
    if err != nil {
        s.logger.Log("", s.gateway.Name(), amount, false)
        return err
    }
    s.logger.Log(txID, s.gateway.Name(), amount, true)
    return nil
}

func (s *PaymentService) SwitchGateway(gw PaymentGateway) {
    fmt.Printf("\nSwitch payment gateway: %s -> %s\n", s.gateway.Name(), gw.Name())
    s.gateway = gw
}

// ---------- main ----------

func main() {
    logger := ConsoleLogger{}
    stripe := Stripe{apiKey: "sk_test_xxx"}
    paypal := PayPal{email: "merchant@example.com"}
    alipay := Alipay{appID: "2025xxxx"}

    // Start with Stripe
    service := NewPaymentService(stripe, logger)
    service.Charge(99.99)
    service.Charge(49.99)

    // Switch to PayPal at runtime (flexibility provided by the interface)
    service.SwitchGateway(paypal)
    service.Charge(199.99)

    // Switch to Alipay
    service.SwitchGateway(alipay)
    service.Charge(299.99)
}

期待される出力：

TEXT 📖 参照専用 
[Stripe] charging $99.99 -> STRIPE-1741500000000
[SUCCESS] STRIPE-1741500000000 | Stripe | $99.99 | 2026-07-08T10:00:00Z
[Stripe] charging $49.99 -> STRIPE-1741500000001
[SUCCESS] STRIPE-1741500000001 | Stripe | $49.99 | 2026-07-08T10:00:00Z

Switch payment gateway: Stripe -> PayPal
[PayPal] charging $199.99 -> PP-1741500000002
[SUCCESS] PP-1741500000002 | PayPal | $199.99 | 2026-07-08T10:00:00Z

Switch payment gateway: PayPal -> Alipay
[Alipay] charging $299.99 -> ALI-1741500000003
[SUCCESS] ALI-1741500000003 | Alipay | $299.99 | 2026-07-08T10:00:00Z
100% 
classDiagram
    class PaymentGateway {
        <<interface>>
        +Charge(amount float64) (string, error)
        +Refund(transactionID string) error
        +Name() string
    }
    class Stripe {
        -apiKey string
        +Charge(amount float64) (string, error)
        +Refund(transactionID string) error
        +Name() string
    }
    class PayPal {
        -email string
        +Charge(amount float64) (string, error)
        +Refund(transactionID string) error
        +Name() string
    }
    class Alipay {
        -appID string
        +Charge(amount float64) (string, error)
        +Refund(transactionID string) error
        +Name() string
    }
    class PaymentService {
        -gateway PaymentGateway
        -logger TransactionLogger
        +Charge(amount float64) error
        +SwitchGateway(gw PaymentGateway)
    }
    PaymentGateway <|.. Stripe : implicit impl
    PaymentGateway <|.. PayPal : implicit impl
    PaymentGateway <|.. Alipay : implicit impl
    PaymentService o--> PaymentGateway : depends on interface (Strategy Pattern)
🔥 よくある間違い： PaymentService 内の gateway フィールドは、具体的な型ではなくインターフェース型です。インターフェース変数には、そのインターフェースを実装する任意の値を格納できます。これが、Go における ストラテジーパターン の実装の基礎となっています。

❓ よくある質問

Q 値型とポインタ型の受信者タイプはどのように選べばよいですか？
A 3つのルールがあります：(1) 受信者を変更する必要がある場合 → ポインタ型；(2) 大きな構造体（100バイト以上）の場合 → ポインタ型；(3) それ以外の場合は、値型の受信者を優先します。ある型でポインタ型の受信者を使用する場合は、すべてのメソッドで同じ規約に従うことを推奨します。
Q 暗黙的なインターフェースの実装をどのように理解すればよいですか？
A 構造体（struct）がインターフェースで定義されたすべてのメソッドのシグネチャを持っている限り、implements キーワードを指定しなくても、そのインターフェースを自動的に実装します。つまり、(1) サードパーティのパッケージの型も、あなたが定義したインターフェースを実装できること、(2) 1つの型が、まったく無関係な複数のインターフェースを実装できるということです。
Q 空のインターフェース interface{} の目的は何ですか？
A あらゆる型の値を受け入れます。一般的な使用例：(1) fmt.Println(a ...interface{})；(2) マップに異なる型の値を格納する場合：map[string]interface{}；(3) データのデシリアライズ（JSONをinterface{}にパースする場合）。
Q 型アサーションが失敗した場合はどうすればよいですか？
A カンマ付き構文 v, ok := x.(T) を使用してください。この場合、ok が false であってもパニックは発生しません。カンマ付き構文を使用しない場合、アサーションの失敗によりパニックが発生します。つまり、x が文字列でない場合、v := x.(string) でパニックが発生します。
Q インターフェースの合成とネストされた構造体の違いは何ですか？
A (1) インターフェースの合成 → メソッドのシグネチャを組み合わせる（挙動の再利用）；(2) ネストされた構造体 → フィールドとメソッドを組み合わせる（データの再利用）。インターフェースの合成は「挙動の抽象化」に該当し、ネストされた構造体は「データの集約」に該当します。
Q インターフェースの値は値型ですか、それとも参照型ですか？
A インターフェースの値は参照型です。インターフェース変数は内部的に（型、値）のペアを格納しており、値が代入される際には、基となるデータそのものではなく、このペアがコピーされます。そのため、インターフェースの値をパラメータとして渡す処理は非常に軽量です（ポインタが2つだけ）。
Q io.ReaderのReadメソッドは、いつEOFを返すのですか？
A すべてのデータの読み取りが完了すると、Readは(0, io.EOF)を返します。なお、EOFはエラーではなく正常な終了を示すため、読み込みが完了したかどうかを確認するためにerr != nilを使用することはできません。err == io.EOFを使用する必要があります。
Q 型は複数のインターフェースを同時に実装できますか？
A はい。型が複数のインターフェースのすべてのメソッドを持っている限り、それらすべてを暗黙的に実装します。これは、Goのインターフェース設計の大きな利点の一つでもあります。つまり、継承階層なしに柔軟な構成が可能になるということです。

📖 まとめ

📝 練習問題

  1. 基本問題（難易度 ⭐）：Shape インターフェース (Area() float64) を定義し、2つの構造体—Circle（半径）と Rectangle（幅と高さ）—を実装して、それぞれの面積を計算し、出力してください。

  2. 上級問題（難易度 ⭐⭐）：Cache インターフェース (Get(key string) (interface{}, bool) / Set(key string, value interface{})) を実装し、map[string]interface{} およびメモリ制限版（最大 10 キー）を用いて、2 つの異なる戦略を実装してください。ポインタ型のリシーバーを使用する必要があります。

  3. チャレンジ問題（難易度 ⭐⭐⭐）：プラグイン可能なストレージバックエンドを実装する：Store インターフェースを定義し（Save(key string, data []byte) error / Load(key string) ([]byte, error) / Delete(key string) error)を定義し、MemoryStore（マップストレージ）およびFileStore（os.WriteFile / os.ReadFile を使用したファイルストレージ）を実装し、最後に BackupService を使用して 2 種類のストレージ間のデータを同期させてください。

Web-Tutorial.com

Web-Tutorial 技術チーム

複数の開発者によって共同維持されているプログラミングチュートリアルプラットフォーム。各チュートリアルは専門分野の開発者が執筆・レビューしています。正確で信頼性の高いコンテンツを目指しています — 問題を見つけた場合はお知らせください。

100%