गो में प्रतिबिंब में एक गहरा गोता

गो प्रोग्रामिंग भाषा अपनी अभिव्यक्ति के लिए व्यापक रूप से जानी जाती है। यह एक दृढ़ता से टाइप की गई भाषा है लेकिन फिर भी अनुप्रयोगों को रनटाइम पर चर, फ़ंक्शन और प्रकारों सहित वस्तुओं को गतिशील रूप से हेरफेर करने और निरीक्षण करने की क्षमता देती है।

परावर्तन वह तंत्र है जिसका उपयोग गो इस क्षमता को पूरा करने के लिए करता है। तो फिर, प्रतिबिंब क्या है, और आप अपने गो अनुप्रयोगों में प्रतिबिंब कैसे लागू कर सकते हैं?

प्रतिबिंब क्या है?

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

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

गो में विभिन्न पैकेज शामिल हैं एन्कोडिंग

जो आपको सक्षम बनाता है JSON के साथ काम करें, और एफएमटी, अपने कर्तव्यों को पूरा करने के लिए हुड के नीचे प्रतिबिंब पर बहुत अधिक भरोसा करते हैं।

गो में रिफ्लेक्ट पैकेज को समझना

गोलांग सीखना अपने शब्दार्थ और कुशल सॉफ्टवेयर के विकास को सुविधाजनक बनाने वाले पैकेजों और विधियों की मजबूत लाइब्रेरी के कारण चुनौतीपूर्ण हो सकता है।

प्रतिबिंबित होना पैकेज इन कई पैकेजों में से एक है। इसमें गो अनुप्रयोगों में प्रतिबिंब को लागू करने के लिए आवश्यक सभी विधियां शामिल हैं।

के साथ आरंभ करने के लिए प्रतिबिंबित होना पैकेज, आप इसे बस इस तरह आयात कर सकते हैं:

import"reflect"

पैकेज दो प्रमुख प्रकारों को परिभाषित करता है जो गो में प्रतिबिंब की नींव रखते हैं: प्रतिबिंबित होना। प्रकार और प्रतिबिंबित होना। कीमत.

ए प्रकार बस एक गो प्रकार है. प्रतिबिंबित होना। प्रकार एक इंटरफ़ेस है जिसमें विभिन्न प्रकारों की पहचान करने और उनके घटकों की जांच करने के लिए विभिन्न तरीके शामिल हैं।

गो में किसी भी वस्तु के प्रकार की जाँच करने का कार्य, प्रतिबिंबित होना। के प्रकार, किसी भी मूल्य को स्वीकार करता है (ए इंटरफेस{}) इसके एकमात्र तर्क के रूप में और एक रिटर्न देता है प्रतिबिंबित होना। प्रकार मान जो वस्तु के गतिशील प्रकार का प्रतिनिधित्व करता है।

नीचे दिया गया कोड इसके उपयोग को दर्शाता है प्रतिबिंबित होना। के प्रकार:

x := "3.142"
y := 3.142
z := 3
typeOfX := reflect.TypeOf(x)
typeOfY := reflect.TypeOf(y)
typeOfZ := reflect.TypeOf(z)
fmt.Println(typeOfX, typeOfY, typeOfZ) // string float64 int

में दूसरा प्रकार प्रतिबिंबित होना पैकेट, प्रतिबिंबित होना। कीमत किसी भी प्रकार का मान रख सकता है। प्रतिबिंबित होना। का मूल्य फ़ंक्शन किसी को भी स्वीकार करता है इंटरफेस{} और इंटरफ़ेस का गतिशील मान लौटाता है।

यहां एक उदाहरण दिया गया है कि कैसे उपयोग करें प्रतिबिंबित होना। का मूल्य उपरोक्त मानों का निरीक्षण करने के लिए:

valueOfX := reflect.ValueOf(x)
valueOfY := reflect.ValueOf(y)
valueOfZ := reflect.ValueOf(z)
fmt.Println(valueOfX, valueOfY, valueOfZ) // 3.142 3.142 3

मानों के प्रकार और प्रकारों का निरीक्षण करने के लिए, आप इसका उपयोग कर सकते हैं दयालु और प्रकार विधि इस प्रकार:

typeOfX2 := valueOfX.Type()
kindOfX := valueOfX.Kind()
fmt.Println(typeOfX2, kindOfX) // string string

हालाँकि दोनों फ़ंक्शन कॉल का परिणाम समान है, वे भिन्न हैं। typeOfX2 मूलतः वही चीज़ है typeOfX क्योंकि वे दोनों गतिशील हैं प्रतिबिंबित होना। प्रकार मूल्य, लेकिन तरह का एक्स एक स्थिरांक है जिसका मान विशिष्ट प्रकार का होता है एक्स, डोरी.

यही कारण है कि इसके प्रकार सीमित संख्या में हैं जैसे कि int यहाँ, डोरी, तैरना, सरणी, आदि, लेकिन अनंत संख्या में प्रकार क्योंकि कई उपयोगकर्ता-परिभाषित प्रकार हो सकते हैं।

एक इंटरफेस{} और ए प्रतिबिंबित होना। कीमत लगभग समान तरीके से काम करते हैं, वे किसी भी प्रकार के मान रख सकते हैं।

उनके बीच का अंतर यह है कि वे कितने खाली हैं इंटरफेस{} यह कभी भी अपने मूल्य के मूल संचालन और तरीकों को उजागर नहीं करता है। इसलिए अधिकांश बार आपको मूल्य के गतिशील प्रकार को जानने और उस तक पहुंचने के लिए प्रकार के दावे का उपयोग करने की आवश्यकता होती है (अर्थात मैं.(स्ट्रिंग), एक्स.(int), आदि) इससे पहले कि आप इसके साथ ऑपरेशन कर सकें।

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

गो कार्यक्रमों में प्रतिबिंब लागू करना

प्रतिबिंब बहुत व्यापक है और किसी भी समय किसी कार्यक्रम में इसका उपयोग किया जा सकता है। नीचे कुछ व्यावहारिक उदाहरण दिए गए हैं जो कार्यक्रमों में प्रतिबिंब के उपयोग को प्रदर्शित करते हैं:

• गहरी समानता की जाँच करें: द प्रतिबिंबित होना पैकेज प्रदान करता है डीपइक्वल समानता के लिए दो वस्तुओं के मूल्यों की गहराई से जाँच करने का कार्य। उदाहरण के लिए, दो संरचनाएँ गहराई से समान होती हैं यदि उनके सभी संबंधित फ़ील्ड के प्रकार और मान समान हों। यहाँ एक उदाहरण कोड है:

   // deep equality of two arrays
   arr1 := [...]int{1, 2, 3}
   arr2 := [...]int{1, 2, 3}
   fmt.Println(reflect.DeepEqual(arr1, arr2)) // true
  

• स्लाइस और सरणियाँ कॉपी करें: आप एक स्लाइस या ऐरे की सामग्री को दूसरे में कॉपी करने के लिए गो रिफ्लेक्शन एपीआई का भी उपयोग कर सकते हैं। ऐसे:

   slice1 := []int{1, 2, 3}
   slice2 := []int{4, 5, 6}
   reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2))
   fmt.Println(slice1) // [4 5 6]
  

• सामान्य कार्यों को परिभाषित करना: टाइपस्क्रिप्ट जैसी भाषाएँ एक सामान्य प्रकार प्रदान करें, कोई, जिसका उपयोग आप किसी भी प्रकार के वेरिएबल को रखने के लिए कर सकते हैं। हालाँकि गो इनबिल्ट जेनेरिक प्रकार के साथ नहीं आता है, आप जेनेरिक फ़ंक्शंस को परिभाषित करने के लिए प्रतिबिंब का उपयोग कर सकते हैं। उदाहरण के लिए:

   // print the type of any value
   funcprintType(x reflect.Value) {
   fmt.Println("Value type:", x.Type())
   }
  

• संरचना टैग तक पहुँचना: टैग का उपयोग गो स्ट्रक्चर फ़ील्ड में मेटाडेटा जोड़ने के लिए किया जाता है, और कई लाइब्रेरी प्रत्येक फ़ील्ड के व्यवहार को निर्धारित करने और हेरफेर करने के लिए उनका उपयोग करती हैं। आप केवल प्रतिबिंब के साथ संरचना टैग तक पहुंच सकते हैं। निम्नलिखित नमूना कोड इसे प्रदर्शित करता है:

   type User struct {
   Name string`json:"name" required:"true"`
   }
   user := User{"John"}
   field, ok := reflect.TypeOf(user).Elem().FieldByName("Name")
   if !ok {
   fmt.Println("Field not found")
   }
   // print all tags, and value of "required"
   fmt.Println(field.Tag, field.Tag.Get("required"))
   // json:"name" required:"true" true
  

• इंटरफेस पर चिंतन: यह जांचना भी संभव है कि कोई मान इंटरफ़ेस लागू करता है या नहीं। यह तब उपयोगी हो सकता है जब आपको अपने आवेदन की आवश्यकताओं और लक्ष्यों के आधार पर सत्यापन की कुछ अतिरिक्त परत निष्पादित करने की आवश्यकता हो। नीचे दिया गया कोड दर्शाता है कि कैसे प्रतिबिंब आपको इंटरफ़ेस का निरीक्षण करने और उनके गुणों को निर्धारित करने में मदद करता है:

   var i interface{} = 3.142
   typeOfI := reflect.TypeOf(i)
   stringerInterfaceType := reflect.TypeOf(new(fmt.Stringer))
   // check if i implements the stringer interface
   impl := typeOfI.Implements(stringerInterfaceType.Elem())
   fmt.Println(impl) // false
  

उपरोक्त उदाहरण कुछ ऐसे तरीके हैं जिनसे आप अपने वास्तविक दुनिया के गो कार्यक्रमों में प्रतिबिंब का उपयोग कर सकते हैं। प्रतिबिंबित होना पैकेज बहुत मजबूत है और आप आधिकारिक तौर पर इसकी क्षमताओं के बारे में अधिक जान सकते हैं जाओ प्रतिबिंबित करो दस्तावेज़ीकरण.

परावर्तन और अनुशंसित अभ्यासों का उपयोग कब करें

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

प्रतिबिंब के बारे में ध्यान देने योग्य कुछ बातें यहां दी गई हैं:

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

आवश्यकता पड़ने पर परावर्तन का प्रयोग करें

रिफ्लेक्शन सी# और जावास्क्रिप्ट सहित कई भाषाओं में उपलब्ध है, और गो एपीआई को उत्कृष्ट रूप से लागू करने में अच्छा काम करता है। गो में प्रतिबिंब का एक प्रमुख लाभ यह है कि जब आप लाइब्रेरी की क्षमता का उपयोग करते हैं तो आप कम कोड के साथ समस्याओं को हल कर सकते हैं।

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