गो में चिंतन के नियम

नमस्कार, हेब्र! मैं आपके लिए भाषा के निर्माता से लेख "कानून के प्रतिबिंब" का अनुवाद प्रस्तुत करता हूं।

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

प्रकार और इंटरफेस

चूँकि प्रतिबिंब एक प्रकार की प्रणाली पर आधारित है, आइए गो में हमारे प्रकारों के ज्ञान को ताज़ा करें।
गो स्टेटिकली टाइप्ड है। प्रत्येक चर का संकलन समय पर एक और केवल एक स्थिर प्रकार होता है: int, float32, *MyType, []byte ... यदि हम घोषणा करते हैं:

 type MyInt int var i int var j MyInt 

तो i टाइप int और j टाइप MyInt । चर i और j अलग-अलग स्थिर प्रकार हैं और, हालांकि उनके पास एक ही मूल प्रकार है, वे रूपांतरण के बिना एक दूसरे को नहीं सौंपे जा सकते हैं।

महत्वपूर्ण प्रकार की श्रेणियों में से एक इंटरफेस है, जो तरीकों के निश्चित सेट हैं। जब तक यह मान इंटरफ़ेस के तरीकों को लागू करता है, तब तक कोई भी इंटरफ़ेस किसी भी विशिष्ट (गैर-इंटरफ़ेस) मान को संग्रहीत कर सकता है। उदाहरणों की एक प्रसिद्ध जोड़ी io.Reader और io.Writer है , पाठक और लेखक io से टाइप करते हैं:

 // Reader -  ,    Read(). type Reader interface { Read(p []byte) (n int, err error) } // Writer -  ,    Write(). type Writer interface { Write(p []byte) (n int, err error) } 

यह कहा जाता है कि कोई भी प्रकार जो इस हस्ताक्षर के साथ Read() या Write() विधि को लागू io.Writer क्रमशः io.Reader या io.Writer लागू io.Reader है। इसका मतलब है कि प्रकार io.Reader एक चर में किसी भी प्रकार का मूल्य हो सकता है पढ़ें ():

 var r io.Reader r = os.Stdin r = bufio.NewReader(r) r = new(bytes.Buffer) 

यह समझना महत्वपूर्ण है कि r को io.Reader लागू करने वाले किसी भी मूल्य को सौंपा जा सकता है। गो io.Reader टाइप्ड है, और स्टैटिक टाइप r io.Reader ।

इंटरफ़ेस प्रकार का एक अत्यंत महत्वपूर्ण उदाहरण खाली इंटरफ़ेस है:

 interface{} 

यह ∅ विधियों का एक खाली सेट है और इसे किसी भी मूल्य द्वारा लागू किया जाता है।
कुछ लोग कहते हैं कि गो इंटरफेस गतिशील रूप से टाइप किए गए चर हैं, लेकिन यह एक गिरावट है। वे सांख्यिकीय रूप से टाइप किए गए हैं: एक इंटरफ़ेस प्रकार के साथ एक चर में हमेशा एक ही स्थिर प्रकार होता है, और यद्यपि रन समय पर इंटरफ़ेस चर में संग्रहीत मान प्रकार बदल सकता है, यह मान हमेशा इंटरफ़ेस को संतुष्ट करेगा। (कोई undefined , NaN या अन्य चीजें जो प्रोग्राम लॉजिक को तोड़ती हैं।)

इसे समझना होगा - प्रतिबिंब और इंटरफेस निकटता से संबंधित हैं।

इंटरफ़ेस का आंतरिक प्रतिनिधित्व

रस कॉक्स ने गो में एक इंटरफ़ेस स्थापित करने के बारे में एक विस्तृत ब्लॉग पोस्ट लिखा। कोई कम अच्छा लेख Habr'e पर नहीं है । पूरी कहानी को दोहराने की आवश्यकता नहीं है, मुख्य बिंदुओं का उल्लेख किया गया है।

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

 var r io.Reader tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0) if err != nil { return nil, err } r = tty 

r में, योजनाबद्ध रूप से, एक जोड़ी (, ) --> (tty, *os.File) । ध्यान दें कि *os.File प्रकार Read() अलावा अन्य तरीकों को लागू करता है; यहां तक ​​कि अगर इंटरफ़ेस मूल्य केवल रीड () विधि तक पहुंच प्रदान करता है, तो अंदर का मूल्य इस मूल्य के प्रकार के बारे में सभी जानकारी प्रदान करता है। यही कारण है कि हम ऐसी चीजें कर सकते हैं:

 var w io.Writer w = r.(io.Writer) 

इस असाइनमेंट में अभिव्यक्ति एक प्रकार का कथन है; यह दावा करता है कि r अंदर का तत्व io.Writer भी लागू io.Writer , और इसलिए हम इसे w को असाइन कर सकते हैं। एक बार सौंपे जाने पर, w में एक जोड़ा (tty, *os.File) । यह r रूप में एक ही जोड़ी है। इंटरफ़ेस का स्थिर प्रकार यह निर्धारित करता है कि इंटरफ़ेस चर पर किन तरीकों को बुलाया जा सकता है, हालांकि तरीकों के एक व्यापक सेट के अंदर एक विशिष्ट मूल्य हो सकता है।

जारी रखते हुए, हम निम्नलिखित कर सकते हैं:

 var empty interface{} empty = w 

और खाली फ़ील्ड के खाली मान में फिर से समान जोड़ी (tty, *os.File) । यह सुविधाजनक है: एक खाली इंटरफ़ेस में कोई भी मूल्य और सभी जानकारी हो सकती है जिसकी हमें कभी भी आवश्यकता होगी।

हमें यहां एक प्रकार के दावे की आवश्यकता नहीं है, क्योंकि यह ज्ञात है कि w एक खाली इंटरफ़ेस को संतुष्ट करता है। उदाहरण में, जहां हमने Reader से Writer में वैल्यू ट्रांसफर की है, हमें स्पष्ट रूप से टाइप एश्योरेंस का उपयोग करने की आवश्यकता है, क्योंकि Writer तरीके Reader सबसेट नहीं हैं। इंटरफ़ेस से मेल नहीं खाने वाले मान को परिवर्तित करने का प्रयास करने से घबराहट होगी।

एक महत्वपूर्ण विवरण यह है कि इंटरफ़ेस के अंदर एक जोड़ी में हमेशा एक फॉर्म (मूल्य, विशिष्ट प्रकार) होता है और इसमें एक फॉर्म (मूल्य, इंटरफ़ेस) नहीं हो सकता है। इंटरफेस मान के रूप में इंटरफेस का समर्थन नहीं करते हैं।

अब हम चिंतन का अध्ययन करने के लिए तैयार हैं।

प्रतिबिंब का पहला नियम प्रतिबिंबित करता है

• प्रतिबिंब इंटरफ़ेस से वस्तु के प्रतिबिंब तक फैली हुई है।

एक बुनियादी स्तर पर, एक इंटरफ़ेस चर के अंदर संग्रहीत प्रकार और मूल्य की एक जोड़ी की जांच करने के लिए प्रतिबिंबित केवल एक तंत्र है। आरंभ करने के लिए, दो प्रकार हैं जिनके बारे में हमें जानने की आवश्यकता है: reflect.Value । reflect.Type और reflect.Value । ये दो प्रकार के इंटरफ़ेस चर की सामग्री तक पहुंच प्रदान करते हैं और साधारण कार्यों द्वारा वापस कर दिए जाते हैं, क्रमशः। दर्शाएँ। टाइप करें () और प्रतिबिंबित करें। वाल्यूऑफ़ (), क्रमशः। वे इंटरफ़ेस के अर्थ से भागों को निकालते हैं। (इसके अलावा, reflect.Value प्राप्त करना आसान है। reflect.Type , लेकिन आइए फिलहाल Value और Type की अवधारणाओं को न मिलाएं।)

चलिए TypeOf() शुरू करते हैं:

 package main import ( "fmt" "reflect" ) func main() { var x float64 = 3.4 fmt.Println("type:", reflect.TypeOf(x)) } 

कार्यक्रम का उत्पादन होगा
type: float64

कार्यक्रम float64 x करने के लिए एक साधारण चर float64 x करने के reflect.TypeOf() । reflect.TypeOf() । क्या आप इंटरफ़ेस देखते हैं? और यह है - reflect.TypeOf() फ़ंक्शन घोषणा के अनुसार एक खाली इंटरफ़ेस स्वीकार करता है:

 // TypeOf()  reflect.Type    . func TypeOf(i interface{}) Type 

जब हम reflect.TypeOf(x) कहते हैं। reflect.TypeOf(x) , x पहले एक खाली इंटरफ़ेस में संग्रहीत किया जाता है, जिसे तब एक तर्क के रूप में पारित किया जाता है; reflect.TypeOf() टाइप जानकारी को पुनर्स्थापित करने के लिए इस खाली इंटरफ़ेस को reflect.TypeOf() करता है।

reflect.ValueOf() फ़ंक्शन, निश्चित रूप से, मूल्य को पुनर्स्थापित करता है (इसके बाद हम टेम्पलेट को अनदेखा करेंगे और कोड पर ध्यान केंद्रित करेंगे):

 var x float64 = 3.4 fmt.Println("value:", reflect.ValueOf(x).String()) 

छप जाएगा
value: <float64 Value>
(हम String() विधि को स्पष्ट रूप से कहते हैं, क्योंकि डिफ़ॉल्ट रूप से, fmt पैकेज reflect.Value करने के लिए reflect.Value और एक विशिष्ट मूल्य प्रिंट करता है।)
दोनों reflect.Type और reflect.Value में कई विधियां हैं, जो आपको उन्हें तलाशने और संशोधित करने की अनुमति देती हैं। एक महत्वपूर्ण उदाहरण यह है कि reflect.Value में एक Type() विधि है जो मूल्य के प्रकार को वापस करती है। reflect.Type और reflect.Value में एक reflect.Value Kind() विधि है जो एक निरंतर संकेत देता है जो बताता है कि कौन सा आदिम तत्व संग्रहीत है: Uint, Float64, Slice ... ये स्थिरांक Uint, Float64, Slice पैकेज में गणना में घोषित किए जाते हैं। Int() और Float() जैसे नामों के साथ Value विधियाँ हमें मानों को बाहर निकालने की अनुमति देती हैं (जैसे कि int64 और float64) संलग्न:

 var x float64 = 3.4 v := reflect.ValueOf(x) fmt.Println("type:", v.Type()) fmt.Println("kind is float64:", v.Kind() == reflect.Float64) fmt.Println("value:", v.Float()) 

छप जाएगा

 type: float64 kind is float64: true value: 3.4 

SetInt() और SetFloat() जैसे तरीके भी हैं, लेकिन उनका उपयोग करने के लिए हमें निपटान को समझने की आवश्यकता है, प्रतिबिंब के तीसरे कानून का विषय।

प्रतिबिंबित पुस्तकालय में कुछ गुण होते हैं जिन्हें आपको हाइलाइट करने की आवश्यकता होती है। सबसे पहले, एपीआई को सरल रखने के लिए, "गेट्टर" और "सेटर" Value विधियां सबसे बड़े प्रकार पर कार्य करती हैं जिसमें एक मूल्य हो सकता है: सभी int64 पूर्णांक के लिए int64 । अर्थात, Value मान का Int() विधि int64 देता है, और SetInt() मान int64 लेता है; वास्तविक प्रकार में रूपांतरण की आवश्यकता हो सकती है:

 var x uint8 = 'x' v := reflect.ValueOf(x) fmt.Println("type:", v.Type()) fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) x = uint8(v.Uint()) // v.Uint  uint64. 

होगा

 type: uint8 kind is uint8: true 

यहाँ v.Uint() uint64 , एक स्पष्ट प्रकार के कथन की आवश्यकता है।

दूसरी संपत्ति यह है कि Kind() वस्तु का प्रतिबिंब आधार प्रकार का वर्णन करता है, न कि स्थैतिक प्रकार। यदि प्रतिबिंब ऑब्जेक्ट में उपयोगकर्ता-परिभाषित पूर्णांक प्रकार का मान होता है, जैसे कि

 type MyInt int var x MyInt = 7 v := reflect.ValueOf(x) // v   Value. 

v.Kind() == reflect.Int , हालांकि x का स्थिर प्रकार MyInt , int नहीं। दूसरे शब्दों में, Kind() Type() MyInt , MyInt से int को अलग नहीं कर सकता है। Kind केवल अंतर्निहित प्रकारों के मूल्यों को स्वीकार कर सकते हैं।

प्रतिबिंब का दूसरा नियम प्रतिबिंबित करता है

• परावर्तन परावर्तित वस्तु से इंटरफ़ेस तक फैला हुआ है।

भौतिक प्रतिबिंब की तरह, गो में प्रतिबिंबित इसके विपरीत बनाता है।

reflect.Value होने के बाद। हम, Interface() विधि का उपयोग करके इंटरफ़ेस के मूल्य को पुनर्स्थापित कर सकते हैं; विधि इंटरफ़ेस में वापस प्रकार और मूल्य जानकारी पैक करती है और परिणाम लौटाती है:

 // Interface   v  interface{}. func (v Value) Interface() interface{} 

BVT
एक उदाहरण के रूप में:

 y := v.Interface().(float64) // y   float64. fmt.Println(y) 

float64 के मान को दर्शाता है, जो वस्तु v को दर्शाता है।
हालाँकि, हम और भी बेहतर कर सकते हैं। fmt.Println() और fmt.Printf() में तर्कों को खाली इंटरफेस के रूप में पारित किया जाता है, जो बाद में fmt पैकेज द्वारा आंतरिक रूप से अनपैक किए जाते हैं, पिछले उदाहरणों की तरह। इसलिए, वह सब जो reflect.Value की सामग्री को प्रिंट करने के लिए आवश्यक है। सही तरीके से स्वरूपित आउटपुट फ़ंक्शन के लिए Interface() विधि के परिणाम को पास करना है:

 fmt.Println(v.Interface()) 

( fmt.Println(v) क्यों नहीं? fmt.Println(v) ; क्योंकि v प्रकार के reflect.Value । reflect.Value ; हम अंदर निहित मूल्य प्राप्त करना चाहते हैं।) चूंकि हमारा मान float64 , हम चाहें तो फ्लोटिंग पॉइंट प्रारूप का भी उपयोग कर सकते हैं:

 fmt.Printf("value is %7.1e\n", v.Interface()) 

एक विशिष्ट मामले में उत्पादन करेगा
3.4e+00

फिर, परिणाम प्रकार v.Interface() को float64 में float64 ; एक खाली इंटरफ़ेस मान में एक विशिष्ट मूल्य के बारे में जानकारी होती है, और fmt.Printf() पुनर्स्थापित करेगा।
संक्षेप में, Interface() विधि ValueOf() फ़ंक्शन का विलोम है, सिवाय इसके कि इसका परिणाम हमेशा स्टैटिक टाइप interface{} ।

पुनरावृत्ति: प्रतिबिंब इंटरफ़ेस मूल्यों से प्रतिबिंब वस्तुओं और इसके विपरीत तक फैली हुई है।

परावर्तन प्रतिबिंब का तीसरा नियम

• परावर्तन वस्तु को बदलने के लिए, मान को व्यवस्थित होना चाहिए।

तीसरा नियम सबसे सूक्ष्म और भ्रामक है। हम पहले सिद्धांतों से शुरू करते हैं।
यह कोड काम नहीं करता है, लेकिन यह ध्यान देने योग्य है।

 var x float64 = 3.4 v := reflect.ValueOf(x) v.SetFloat(7.1) //  

यदि आप यह कोड चलाते हैं, तो यह एक महत्वपूर्ण संदेश के साथ घबराहट से दुर्घटनाग्रस्त हो जाएगा:
panic: reflect.Value.SetFloat
समस्या यह नहीं है कि शाब्दिक 7.1 पता नहीं है; यह वह है जो v इंस्टॉल करने v नहीं है। reflect.Value की एक संपत्ति है। reflect.Value , और हर reflect.Value नहीं। reflect.Value में यह है।
reflect.Value.CanSet() विधि सेट किए जा रहे reflect.Value.CanSet() ; हमारे मामले में:

 var x float64 = 3.4 v := reflect.ValueOf(x) fmt.Println("settability of v:", v.CanSet()) 

प्रिंट होगा:
settability of v: false

अप्रबंधित मान पर Set() विधि को कॉल करते समय एक त्रुटि हुई। लेकिन किस्तनीयता क्या है?

स्थिरता साध्यता की तरह एक सा है, लेकिन कठोर है। यह एक ऐसी संपत्ति है जहां प्रतिबिंब वस्तु संग्रहित मूल्य को बदल सकती है जिसका उपयोग प्रतिबिंब वस्तु बनाने के लिए किया गया था। स्थिरता का निर्धारण इस बात से होता है कि प्रतिबिंब वस्तु में स्रोत तत्व है, या केवल इसकी एक प्रति है। जब हम लिखते हैं:

 var x float64 = 3.4 v := reflect.ValueOf(x) 

हम reflect.ValueOf() करने के लिए x की एक प्रतिलिपि पास करते हैं। reflect.ValueOf() , इसलिए इंटरफ़ेस को reflect.ValueOf() करने के लिए एक तर्क के रूप में बनाया गया है। reflect.ValueOf() - यह x की एक प्रति है, न कि स्वयं x । इस प्रकार, यदि कथन:

 v.SetFloat(7.1) 

यदि इसे निष्पादित किया गया था, तो यह x अपडेट नहीं करेगा, हालांकि v ऐसा लगता है कि यह x से बनाया गया था। इसके बजाय, वह v के मान के अंदर संग्रहीत x की प्रतिलिपि को अद्यतन करेगा, और x स्वयं प्रभावित नहीं होगा। यह निषिद्ध है, इसलिए समस्या का कारण नहीं है, और किसी समस्या को रोकने के लिए उपयोग की जाने वाली संपत्ति है।

यह अजीब नहीं लगना चाहिए। असामान्य कपड़ों में यह एक सामान्य स्थिति है। किसी फ़ंक्शन को x करने पर विचार करें:
f(x)

हम x को बदलने में सक्षम होने के f() उम्मीद नहीं करते हैं, क्योंकि हमने x के मूल्य की एक प्रति पारित की है, न कि स्वयं x । अगर हम चाहते हैं कि f() सीधे x को बदले, तो हमें अपने फ़ंक्शन के x को पॉइंटर पास करना होगा:
f(&x)

यह सीधा और परिचित है, और प्रतिबिंब इसी तरह काम करता है। यदि हम परावर्तन का उपयोग करके x को बदलना चाहते हैं, तो हमें परावर्तक पुस्तकालय को एक सूचक के साथ प्रदान करना चाहिए, जिस मूल्य को हम बदलना चाहते हैं।

चलो करते हैं। सबसे पहले, हम हमेशा की तरह x को इनिशियलाइज़ करते हैं, और फिर एक reflect.Value p बनाते हैं। reflect.Value p जो इसे इंगित करता है।

 var x float64 = 3.4 p := reflect.ValueOf(&x) //   x. fmt.Println("type of p:", p.Type()) fmt.Println("settability of p:", p.CanSet()) 

उत्पादन होगा
type of p: *float64
settability of p: false

परावर्तन ऑब्जेक्ट p सेट नहीं किया जा सकता है, लेकिन यह वह p नहीं है जिसे हम सेट करना चाहते हैं, यह पॉइंटर *p । क्या p अंक प्राप्त करने के लिए, हम मान लेते हैं। मूल्य Value.Elem() विधि, जो सूचक के माध्यम से अप्रत्यक्ष रूप से मूल्य लेता है, और परिणाम को reflect.Value v । reflect.Value v :

 v := p.Elem() fmt.Println("settability of v:", v.CanSet()) 

अब v एक संस्थापन योग्य वस्तु है;
settability of v: true
और चूंकि यह x प्रतिनिधित्व करता है, हम अंत में x का मान बदलने के लिए v.SetFloat() का उपयोग कर सकते हैं:

 v.SetFloat(7.1) fmt.Println(v.Interface()) fmt.Println(x) 

उम्मीद के मुताबिक निष्कर्ष
7.1
7.1
प्रतिबिंबित को समझना मुश्किल हो सकता है, लेकिन यह वही करता है जो भाषा करती है, reflection.Value की सहायता से यद्यपि। reflect.Type और reflection.Value । reflect.Type , जो छिपा सकता है कि क्या हो रहा है। बस ध्यान रखें कि reflection.Value । वाल्यू को इसे बदलने के लिए एक चर के पते की आवश्यकता है।

संरचना

हमारे पिछले उदाहरण में, v एक पॉइंटर नहीं v , यह सिर्फ इससे निकला था। इस स्थिति को बनाने का एक सामान्य तरीका संरचना क्षेत्रों को बदलने के लिए प्रतिबिंब का उपयोग करना है। जब तक हमारे पास संरचना का पता है, हम इसके क्षेत्रों को बदल सकते हैं।

यहां एक सरल उदाहरण है जो संरचना t के मूल्य का विश्लेषण करता t । हम बाद में इसे संशोधित करने के लिए संरचना के पते के साथ एक प्रतिबिंब वस्तु बनाते हैं। फिर टाइपऑफटी को इसके प्रकार पर सेट करें और सरल विधि कॉल का उपयोग करके फ़ील्ड पर पुनरावृति करें ( विस्तृत विवरण के लिए पैकेज देखें)। ध्यान दें कि हम संरचना के प्रकार से फ़ील्ड नाम निकाल रहे हैं, लेकिन फ़ील्ड स्वयं नियमित रूप से reflect.Value ।

 type T struct { A int B string } t := T{23, "skidoo"} s := reflect.ValueOf(&t).Elem() typeOfT := s.Type() for i := 0; i < s.NumField(); i++ { f := s.Field(i) fmt.Printf("%d: %s %s = %v\n", i, typeOfT.Field(i).Name, f.Type(), f.Interface()) } 

कार्यक्रम का उत्पादन होगा
0: A int = 23
1: B string = skidoo
किस्त के बारे में एक और बात यहां दिखाई गई है: ऊपरी क्षेत्र (निर्यात) में T फ़ील्ड्स के नाम, क्योंकि केवल निर्यात किए गए फ़ील्ड व्यवस्थित हैं।
चूँकि s में एक संस्थापित प्रतिबिंब वस्तु है, इसलिए हम संरचना क्षेत्र को बदल सकते हैं।

 s.Field(0).SetInt(77) s.Field(1).SetString("Sunset Strip") fmt.Println("t is now", t) 

परिणाम:
t is now {77 Sunset Strip}
यदि हम प्रोग्राम को बदल देते हैं ताकि s t &t t बजाय t से बनाया गया t , तो SetInt() और SetString() के कॉल घबराहट में समाप्त हो जाएंगे, क्योंकि फ़ील्ड t SetString() नहीं होगा।

निष्कर्ष

प्रतिबिंब के नियमों को याद करें:

• प्रतिबिंब इंटरफ़ेस से वस्तु के प्रतिबिंब तक फैली हुई है।
• प्रतिबिंब वस्तु के प्रतिबिंब से इंटरफ़ेस तक फैलता है।
• प्रतिबिंब वस्तु को बदलने के लिए, मान सेट होना चाहिए।

रोब पाइक द्वारा पोस्ट किया गया।