एम्बेडेड इंटरफ़ेस

Question

मैं अभी भी जाने के लिए काफी नया हूं और मैं आश्चर्यचकित इंटरफ़ेस के उप प्रकार का उपयोग करने में सक्षम नहीं हूं।

func test(sl bufio.ReadWriter){ 
    // cannot use sl(type bufio.ReadWriter) as type bufio.Reader in function argument 
    readStuff(sl) 
    [...] 
    writeStuff(sl) // same kind of error 
} 

func readStuff(sl bufio.Reader){ 
    [...] 
} 

हर इंटरफेस के रूप में एक ही स्मृति लेआउट है और ReadWriter एक रीडर और एक लेखक, मैं इस कोड काम करने के लिए उम्मीद कर रहा था है: यहाँ समझाने के लिए मैं क्या मतलब है एक छोटा सा उदाहरण है। मैं के साथ इंटरफ़ेस प्रकार बदलने की कोशिश की थी:

readStuff(sl.(buffio.Reader)) 

लेकिन यह या तो काम नहीं करता। तो मेरे पास दो प्रश्न हैं:

• यह क्यों काम नहीं करता है?
• उस समस्या के बारे में क्या जाना है?

Answer 1

वे अलग-अलग प्रकार हैं। हालांकि, bufio.ReadWriter में bufio.Reader प्रकार और bufio.Writer दोनों के लिए एक संरचना है जो इसकी संरचना के तत्वों के रूप में है। तो सही एक को पार करना काफी आसान होना चाहिए। इसे आज़माएं:

func test(sl bufio.ReadWriter){ 
    readStuff(sl.Reader) 
    [...] 
    writeStuff(sl.Writer) 
} 

// Changed this bufio.Reader to a pointer receiver 
func readStuff(sl *bufio.Reader) { 
    [...] 
} 

Answer 2

bufio.ReadWriter एक ठोस प्रकार है, इंटरफ़ेस नहीं। हालांकि, यह एक इंटरफ़ेस (io.ReadWriter) को संतुष्ट करता है, इसलिए इसे उपयुक्त इंटरफ़ेस प्रकार के चर/फ़ंक्शन तर्क को असाइन किया जा सकता है।

package main 

import (
     "bufio" 
     "bytes" 
     "fmt" 
     "io" 
     "log" 
) 

func readStuff(r io.Reader) { 
     b := make([]byte, 10) 
     n, err := r.Read(b) 
     if err != nil && err != io.EOF { 
       log.Fatal(err) 
     } 
     fmt.Printf("readStuff: %q\n", b[:n]) 
} 

func writeStuff(w io.Writer) { 
     b := []byte("written") 
     n, err := w.Write(b) 
     if n != len(b) { 
       log.Fatal("Short write") 
     } 

     if err != nil { 
       log.Fatal(err) 
     } 
} 

func test(rw io.ReadWriter) { 
    readStuff(rw) 
    writeStuff(rw) 
} 

func main() { 
     r := io.Reader(bytes.NewBufferString("source")) 
     var uw bytes.Buffer 
     w := io.Writer(&uw) 
     rw := bufio.NewReadWriter(bufio.NewReader(r), bufio.NewWriter(w)) 
     test(rw) 
     rw.Flush() 
     fmt.Printf("The underlying bytes.Buffer writer contains %q\n", uw.Bytes()) 
} 

(इसके अलावा here)

---

आउटपुट::

readStuff: "source" 
The underlying bytes.Buffer writer contains "written" 

इस तरह तो यह जिस तरह से आप प्रत्याशित हो सकता है (अपने कोड वास्तव में किसी भी इंटरफेस का उपयोग नहीं करता) काम करता है test किसी भी io.ReadWriter का उपभोग नहीं कर सकता, न केवल एक विशिष्ट। "दर्शन" के बारे में आपके प्रश्न की ओर इशारा कौन सा संकेत है।