Interfaces in Golang

What are Interfaces in Go?

Interfaces Go में एक प्रकार की type हैं जो एक या अधिक method signatures को define करती हैं। Go में interfaces का उपयोग polymorphism को implement करने के लिए किया जाता है। Interface किसी भी type से satisfied हो सकता है, यदि वह type interface में defined सभी methods को implement करता है। Interfaces Go में एक प्रकार की contract की तरह होती हैं, जो specify करती हैं कि किसी type को किन methods को implement करना चाहिए।

Basic Syntax for Declaring an Interface

Go में interface को declare करने के लिए type keyword और interface keyword का उपयोग किया जाता है। Interface के अंदर method signatures को define किया जाता है।

Example: Declaring a Simple Interface

package main

import "fmt"

// Declaring an interface named 'Speaker'
type Speaker interface {
    Speak() string
}

// Declaring a struct named 'Person'
type Person struct {
    Name string
}

// Implementing the Speak method for the Person struct
func (p Person) Speak() string {
    return "Hello, my name is " + p.Name
}

func main() {
    var s Speaker
    p := Person{Name: "Alice"}
    
    // Assigning the Person struct to the Speaker interface
    s = p
    
    // Calling the Speak method via the interface
    fmt.Println(s.Speak())
}

Explanation:

• type Speaker interface { Speak() string }: यह interface एक method Speak को define करता है, जिसे string return करना चाहिए।
• type Person struct { ... }: यह Person नाम का struct declare करता है।
• func (p Person) Speak() string { ... }: यह method Person struct के लिए Speak method को implement करता है।
• s = p: यहां Person struct को Speaker interface के variable s में assign किया जा रहा है, क्योंकि Person struct Speak method को implement करता है।
• Output: "Hello, my name is Alice"।

1. Multiple Methods in an Interface

Interfaces में एक से अधिक methods हो सकते हैं। एक type को interface से match करने के लिए सभी methods को implement करना होता है।

Example: Interface with Multiple Methods

package main

import "fmt"

// Declaring an interface named 'Animal'
type Animal interface {
    Speak() string
    Move() string
}

// Declaring a struct named 'Dog'
type Dog struct {
    Name string
}

// Implementing both methods for the Dog struct
func (d Dog) Speak() string {
    return "Woof!"
}

func (d Dog) Move() string {
    return "Running"
}

func main() {
    var a Animal
    d := Dog{Name: "Buddy"}
    
    // Assigning the Dog struct to the Animal interface
    a = d
    
    // Calling methods via the interface
    fmt.Println(d.Name, "says", a.Speak(), "and is", a.Move())
}

Explanation:

• type Animal interface { Speak() string; Move() string }: यह interface दो methods को define करता है: Speak और Move।
• func (d Dog) Speak() string { ... } और func (d Dog) Move() string { ... }: ये दोनों methods Dog struct के लिए implement किए गए हैं।
• Output: "Buddy says Woof! and is Running"।

2. Implementing Multiple Interfaces

Go में एक type एक से अधिक interfaces को implement कर सकता है। यदि type सभी required methods को implement करता है, तो वह सभी associated interfaces से satisfy होगा।

Example: Implementing Multiple Interfaces

package main

import "fmt"

// Declaring the 'Speaker' interface
type Speaker interface {
    Speak() string
}

// Declaring the 'Mover' interface
type Mover interface {
    Move() string
}

// Declaring a struct named 'Robot'
type Robot struct {
    Model string
}

// Implementing the Speak method for the Robot struct
func (r Robot) Speak() string {
    return "Beep Boop"
}

// Implementing the Move method for the Robot struct
func (r Robot) Move() string {
    return "Rolling"
}

func main() {
    var sp Speaker
    var mv Mover
    r := Robot{Model: "T-800"}
    
    // Assigning the Robot struct to both Speaker and Mover interfaces
    sp = r
    mv = r
    
    // Calling methods via the interfaces
    fmt.Println(r.Model, "says", sp.Speak(), "and is", mv.Move())
}

Explanation:

• type Speaker interface { Speak() string } और type Mover interface { Move() string }: ये दो अलग-अलग interfaces हैं।
• func (r Robot) Speak() string { ... } और func (r Robot) Move() string { ... }: Robot struct दोनों interfaces को implement करता है।
• Output: "T-800 says Beep Boop and is Rolling"।

3. Empty Interface (interface{})

Go में empty interface (interface{}) एक special interface है, जो किसी भी type को hold कर सकता है। इसे Go में सबसे generic type माना जाता है।

Example: Using Empty Interface

package main

import "fmt"

func describe(i interface{}) {
    fmt.Printf("Type: %T, Value: %v\n", i, i)
}

func main() {
    describe(42)
    describe("Hello, Go!")
    describe(true)
}

Explanation:

• interface{}: यह empty interface है, जो किसी भी type की value को hold कर सकता है।
• describe(i interface{}): यह function किसी भी type की value को accept कर सकता है और उसकी type और value को print करता है।
• Output: "Type: int, Value: 42", "Type: string, Value: Hello, Go!", और "Type: bool, Value: true"।

4. Type Assertions

Type assertions का उपयोग करके आप यह check कर सकते हैं कि क्या interface किसी specific type की value hold कर रहा है या नहीं। यह interface values को उनकी original type में convert करने के लिए उपयोगी होता है।

Example: Type Assertions

package main

import "fmt"

func main() {
    var i interface{} = "Hello, Go!"
    
    // Type assertion
    s, ok := i.(string)
    if ok {
        fmt.Println("String value:", s)
    } else {
        fmt.Println("Not a string")
    }

    // Failing type assertion
    n, ok := i.(int)
    if ok {
        fmt.Println("Integer value:", n)
    } else {
        fmt.Println("Not an integer")
    }
}

Explanation:

• s, ok := i.(string): यह type assertion check करता है कि क्या i में string value है। अगर type assertion सफल होता है, तो ok true होगा और s में value store हो जाएगी।
• Output: "String value: Hello, Go!" और "Not an integer"।

5. Type Switch

Type switch का उपयोग multiple type assertions को एक साथ handle करने के लिए किया जाता है। यह switch statement की तरह काम करता है, लेकिन यह type पर switch करता है।

Example: Type Switch

package main

import "fmt"

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Println("Integer value:", v)
    case string:
        fmt.Println("String value:", v)
    case bool:
        fmt.Println("Boolean value:", v)
    default:
        fmt.Println("Unknown type")
    }
}

func main() {
    describe(42)
    describe("Hello, Go!")
    describe(true)
    describe(3.14)
}

Explanation:

• switch v := i.(type): यह type switch है, जो i की type को check करता है और उसके आधार पर case को execute करता है।
• Output: "Integer value: 42", "String value: Hello, Go!", "Boolean value: true", और "Unknown type"।

6. Interfaces and Nil

अगर आप interface variable को nil से assign करते हैं और फिर उसकी method को call करते हैं, तो Go runtime पर panic हो सकता है। इसलिए आपको यह ensure करना चाहिए कि interface variable nil नहीं है, अगर आप उसकी method को call करने वाले हैं।

Example: Interface and Nil

package main

import "fmt"

// Declaring an interface named 'Describer'
type Describer interface {
    Describe()
}

// Declaring a struct named 'Person'
type Person struct {
    Name string
    Age  int
}

// Implementing the Describe method for the Person struct
func (p *Person) Describe() {
    if p == nil {
        fmt.Println("No person to describe")
        return
    }
    fmt.Printf("Name: %s, Age: %d\n", p.Name, p.Age)
}

func main() {
    var d Describer

    var p *Person
    d = p
    
    // Calling the Describe method
    d.Describe()
}

Explanation:

• var p *Person: यह nil pointer है।
• d = p: यह nil pointer को interface variable d में assign करता है।
• d.Describe(): यहां Describe method को call किया जाता है, लेकिन method के अंदर nil check होने के कारण panic नहीं होता।
• Output: "No person to describe"।

Summary

• Interfaces: Go में polymorphism को implement करने के लिए उपयोग किए जाते हैं। वे एक या अधिक method signatures को define करते हैं।
• Multiple Methods: एक interface में multiple methods हो सकती हैं, और एक type को interface से satisfy करने के लिए सभी methods को implement करना होता है।
• Empty Interface: Empty interface (interface{}) Go में किसी भी type की value को hold कर सकता है।
• Type Assertions: Interfaces में stored values की original type को retrieve करने के लिए type assertions का उपयोग किया जाता है।
• Type Switch: Type assertions को handle करने के लिए type switch का उपयोग किया जाता है।
• Interfaces and Nil: Interface variables को nil से assign करने पर method calls से panic हो सकता है, इसलिए nil checks आवश्यक हैं।

Interfaces Go में flexibility और polymorphism को achieve करने के लिए powerful tool हैं। इन्हें समझना और effectively use करना Go programming में महत्वपूर्ण है। अगर आपको interfaces के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!