बाइट्स को स्ट्रीम में बदलें: Go में []byte से io.Reader

परिचय: आपको बाइट्स को स्ट्रीम में क्यों बदलने की ज़रूरत हो सकती है?

एक स्थिति की कल्पना करें: आपने Go में एक शानदार सेवा लिखी है जो बाहरी API से डेटा प्राप्त करती है। जवाब बाइट्स ([]byte) के रूप में आता है। सब कुछ ठीक है, लेकिन समस्या यह है कि आपके पाइपलाइन में अगला फंक्शन byte slice नहीं, बल्कि io.Reader इंटरफ़ेस चाहता है। अब क्या करें? घबराएं? खुद से कोड लिखें? नहीं! बस bytes.NewReader को याद रखें।

यह सवाल Stack Overflow पर सबसे लोकप्रिय में से एक है (हज़ारों व्यूज़!)। और यह सही भी है। Go में io.Reader की अवधारणा डेटा स्ट्रीम के साथ काम करने की नींव है: फ़ाइलें, नेटवर्क कनेक्शन, HTTP रिस्पॉन्स, और निश्चित रूप से मेमोरी में सिर्फ बाइट्स। यदि आप एक शुरुआती Go डेवलपर हैं, तो देर-सबेर आप इस दीवार से टकराएंगे। आइए जानें कि इसे खूबसूरती और कुशलता से कैसे हल किया जाए।

इस लेख में हम सिर्फ सूखा आदेश नहीं देंगे " bytes.NewReader का उपयोग करें"। हम समझेंगे कि यह कैसे काम करता है, इसके विकल्प क्या हैं, और वास्तविक जीवन के उदाहरण दिखाएंगे। चलिए शुरू करते हैं!

सिद्धांत: io.Reader क्या है और इसे कैसे उपयोग करें?

कन्वर्ट करने से पहले, आइए याद करें कि io.Reader क्या है। यह Go की स्टैंडर्ड लाइब्रेरी में परिभाषित एक इंटरफ़ेस है:

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

यह बहुत सरल है। कोई भी स्ट्रक्चर जिसमें Read(p []byte) (int, error) मेथड है, वह स्वचालित रूप से io.Reader इंटरफ़ेस को संतुष्ट करता है। यह आपको किसी भी स्रोत से डेटा पढ़ने के लिए यूनिवर्सल कोड लिखने की अनुमति देता है: फ़ाइल, सॉकेट, स्ट्रिंग, या byte slice।

यह क्यों अच्छा है? क्योंकि आप एक फंक्शन लिख सकते हैं जो JSON, XML पार्स करता है या सिर्फ डेटा कॉपी करता है, बिना यह चिंता किए कि डेटा कहाँ से आया। आपको बस io.Reader चाहिए। यह स्ट्रीम का एब्स्ट्रैक्शन है।

लेकिन क्या होगा यदि आपके पास पहले से मेमोरी में डेटा है (जैसे []byte)? आपको एक ऐसी ऑब्जेक्ट चाहिए जो स्ट्रीम होने का "दिखावा" करे, लेकिन आपके स्लाइस से पढ़े। यहाँ bytes.NewReader काम आता है।

मुख्य तरीका: bytes.NewReader

यह सबसे सरल और सही तरीका है। फंक्शन bytes.NewReader []byte लेता है और bytes.Reader स्ट्रक्चर का पॉइंटर लौटाता है, जो io.Reader (साथ ही io.ReadSeeker, io.WriterTo और अन्य उपयोगी इंटरफ़ेस) को इम्प्लीमेंट करता है।

उदाहरण 1: बुनियादी उपयोग

package main\n\nimport (\n    "bytes"\n    "fmt"\n    "io"\n    "log"\n)\n\nfunc main() {\n    // हमारा मूल byte slice\n    data := []byte("नमस्ते, दुनिया! ये बाइट्स हैं।")\n\n    // byte slice से Reader बनाएं\n    reader := bytes.NewReader(data)\n\n    // reader से डेटा को बफर में पढ़ें\n    buf := make([]byte, 10) // 10 बाइट पढ़ें\n    for {\n        n, err := reader.Read(buf)\n        if err != nil {\n            if err == io.EOF {\n                break // पढ़ना समाप्त\n            }\n            log.Fatal(err)\n        }\n        fmt.Printf("%d बाइट पढ़े: %s\\n", n, buf[:n])\n    }\n    // Output:\n    // 10 बाइट पढ़े: नमस्ते, दु\n    // 10 बाइट पढ़े: निया! ये \n    // 6 बाइट पढ़े: बाइट्स हैं।\n}

ध्यान दें: bytes.Reader एक वास्तविक स्ट्रीम की तरह व्यवहार करता है। जब डेटा खत्म हो जाता है, तो यह io.EOF लौटाता है। पूरी तरह से सही।

उदाहरण 2: io.Copy के साथ उपयोग

सबसे आम परिदृश्य है बाइट्स को कहीं और कॉपी करना (फ़ाइल में, HTTP रिस्पॉन्स में)। इसके लिए io.Copy सबसे उपयुक्त है:

package main\n\nimport (\n    "bytes"\n    "fmt"\n    "io"\n    "os"\n)\n\nfunc main() {\n    data := []byte("इस डेटा को फ़ाइल में सेव करें।")\n    reader := bytes.NewReader(data)\n\n    // फ़ाइल बनाएं\n    file, err := os.Create("output.txt")\n    if err != nil {\n        panic(err)\n    }\n    defer file.Close()\n\n    // reader से फ़ाइल में कॉपी करें\n