Golang इंटरफेस की परिभाषा और अमल

1 इंटरफेस का परिचय

1.1 इंटरफेस क्या है

Go भाषा में, एक इंटरफेस एक प्रकार का, अर्थात एक अमूर्त प्रकार है। इंटरफेस विशेष विवरण को छिपाती है और केवल उपयोगकर्ता को ऑब्ज

4.2 इंटरफेस के अनुप्रयोग स्थितियाँ

इंटरफेस गो भाषा में व्यापक रूप से प्रयोग किए जाते हैं। यहां कुछ प्रमुख अनुप्रयोग स्थितियाँ हैं:

• मानक पुस्तकालय में इंटरफेस: उदाहरण के लिए, io.Reader और io.Writer इंटरफेस को फाइल प्रसंस्करण और नेटवर्क प्रोग्रामिंग के लिए व्यापक रूप से प्रयोग किया जाता है।
• क्रमबद्धीकरण: sort.Interface इंटरफेस में Len(), Less(i, j int) bool, और Swap(i, j int) मेथड को अंकित करने से किसी भी अनुकूल स्लाइस को क्रमबद्ध करने की अनुमति होती है।
• HTTP Handlers: http.Handler इंटरफेस में ServeHTTP(ResponseWriter, *Request) मेथड को अंकित करने से कस्टम HTTP हैंडलर बनाने की संभावना होती है।

यहां इंटरफेस का उपयोग करने का एक उदाहरण है क्रमबद्धीकरण के लिए:

package main

import (
    "fmt"
    "sort"
)

type AgeSlice []int

func (a AgeSlice) Len() int           { return len(a) }
func (a AgeSlice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a AgeSlice) Less(i, j int) bool { return a[i] < a[j] }

func main() {
    ages := AgeSlice{45, 26, 74, 23, 46, 12, 39}
    sort.Sort(ages)
    fmt.Println(ages) // आउटपुट: [12 23 26 39 45 46 74]
}

इस उदाहरण में, sort.Interface के तीन मेथडों को अंकन करके, हम AgeSlice स्लाइस को क्रमबद्ध कर सकते हैं, जो अवस्थापित टाइप की व्यावहारिकता को बढ़ाने की क्षमता को दर्शाता है।

5 इंटरफेस की उन्नत विशेषताएँ

5.1 खाली इंटरफेस और उसके अनुप्रयोग

गो भाषा में, खाली इंटरफेस एक विशेष इंटरफेस प्रकार है जिसमें कोई भी मेथड शामिल नहीं होता। इसलिए, लगभग किसी भी प्रकार की मान्यता को एक खाली इंटरफेस के रूप में देखा जा सकता है। खाली इंटरफेस को interface{} के रूप में प्रस्तुत किया जाता है और गो में एक अत्यंत लचीला प्रकार के रूप में कई महत्वपूर्ण भूमिकाएँ निभाता है।

// एक खाली इंटरफेस को परिभाषित करें
var any interface{}

गतिशील प्रकार हैंडलिंग:

खाली इंटरफेस में किसी भी प्रकार की मान्यता को संग्रहीत किया जा सकता है, इसलिए यह अनिश्चित प्रकारों को संभालने के लिए बहुत उपयोगी है। उदाहरण के लिए, जब आप एक फ़ंक्शन बनाते हैं जो विभिन्न प्रकार के पैरामीटर स्वीकार करता है, तो खाली इंटरफेस को पैरामीटर प्रकार के रूप में प्रयोग किया जा सकता है ताकि किसी भी प्रकार के डेटा को स्वीकार किया जा सके।

func PrintAnything(v interface{}) {
    fmt.Println(v)
}

func main() {
    PrintAnything(123)
    PrintAnything("hello")
    PrintAnything(struct{ name string }{name: "Gopher"})
}

ऊपर के उदाहरण में, फ़ंक्शन PrintAnything खाली इंटरफेस प्रकार के पैरामीटर v लेता है और इसे प्रिंट करता है। PrintAnything में एक पूर्णांक, स्ट्रिंग, या स्ट्रक्चर को पारित किया जा सकता है।

5.2 इंटरफेस एम्बेडिंग

इंटरफेस एम्बेडिंग से एक इंटरफेस में दूसरे इंटरफेस के सभी मेथड्स शामिल होने का मतलब है, और संभावित रूप से कुछ नए मेथड्स भी जोड़े जा सकते हैं। यह इंटरफेस परिभाषा में अन्य इंटरफेस को एम्बेड करके हासिल की जाती है।

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

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

// ReadWriter इंटरफेस रीडर इंटरफेस और राइटर इंटरफेस को एम्बेड करता है
type ReadWriter interface {
    Reader
    Writer
}

इंटरफेस एम्बेडिंग का उपयोग करके, हम एक और गुणवत्तापूर्ण और पारस्परिक इंटरफेस संरचना निर्मित कर सकते हैं। इस उदाहरण में, ReadWriter इंटरफेस रीडर और राइटर इंटरफेस के मेथड्स को एकीकृत करता है, पढ़ने और लिखने की क्षमताओं को मिश्रण करते हुए।

5.3 इंटरफेस प्रकार दावा

प्रकार दावा एक आपरेशन है जो इंटरफेस प्रकार मान्यता की जांच और परिवर्तन करता है। जब हमें इंटरफेस प्रकार मान्यता से किसी विशिष्ट प्रकार की मान्यता को निकालने की आवश्यकता होती है, तो प्रकार दावा बहुत उपयोगी होता है।

दावा की मूल संयंत्र:

value, ok := interfaceValue.(Type)

अगर दावा सफल होता है, तो value संदर्भ प्रकार Type का मान होगा, और ok सच होगा; अगर दावा विफल होता है, तो value टाइप Type का शून्य मान होगा, और ok झूठा होगा।

var i interface{} = "hello"

// प्रकार दावा
s, ok := i.(string)
if ok {
    fmt.Println(s) // आउटपुट: hello
}

// वास्तविक प्रकार का दावा
f, ok := i.(float64)
if !ok {
    fmt.Println("दावा विफल हुआ!") // आउटपुट: दावा विफल हुआ!
}

अनुप्रयोग स्थितियाँ:

प्रकार दावा सामान्यत: खाली इंटरफेस interface{} में मान्यता के प्रकार की निर्धारण और परिवर्तन के लिए प्रयोग किया जाता है, या कई इंटरफेस को अमल करने के मामले में, किसी विशिष्ट इंटरफेस को अमल करने वाले टाइप को निकालने के लिए प्रयोग किया जाता है।

5.4 इंटरफेस और पॉलीमॉर्फिज्म

पॉलीमॉर्फिज्म ऑब्जेक्ट-ओरिएन्टेड प्रोग्रामिंग में एक महत्वपूर्ण अवधारणा है, जो विभिन्न डेटा प्रकारों को एक समूहीत तरीके से प्रसंस्कृत करने की अनुमति देती है, केवल इंटरफेस के माध्यम से, विशिष्ट प्रकारों को लेकर नहीं। गो भाषा में, इंटरफेस पॉलीमॉर्फिज्म को प्राप्त करने की कुंजी है।

इंटरफेस के माध्यम से पॉलीमॉर्फिज्म को कार्यान्वित करना

type Shape interface {
    Area() float64
}

type Rectangle struct {
    Width, Height float64
}

type Circle struct {
    Radius float64
}

// आयत इंटरफेस को कार्यान्वित करता है
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// वृत्त इंटरफेस को कार्यान्वित करता है
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

// विभिन्न आकारों का क्षेत्रफल गणना करें
func CalculateArea(s Shape) float64 {
    return s.Area()
}

func main() {
    r := Rectangle{Width: 3, Height: 4}
    c := Circle{Radius: 5}
    
    fmt.Println(CalculateArea(r)) // आउटपुट: आयत का क्षेत्रफल
    fmt.Println(CalculateArea(c)) // आउटपुट: वृत्त का क्षेत्रफल
}

इस उदाहरण में, Shape इंटरफेस विभिन्न आकारों के लिए Area विधि को परिभाषित करती है। Rectangle और Circle दृढ़ प्रकार इस इंटरफेस को कार्यान्वित करते हैं, जिसका मतलब है कि इन प्रकारों के पास क्षेत्रफल निकालने की क्षमता है। फ़ंक्शन CalculateArea एक Shape इंटरफेस के पैरामीटर को लेता है और किसी भी आकार का क्षेत्रफल गणना कर सकता है जो Shape इंटरफेस को कार्यान्वित करता है।

इस प्रकार, हम आसानी से नए प्रकार के आकार जोड़ सकते हैं बिना CalculateArea फ़ंक्शन के अमलीकरण को संशोधित करने की आवश्यकता के बिना। यह पॉलीमॉर्फिज्म को कोड में लाने वाली लचीलापन और विस्तारशीलता है।