नील हमेशा शून्य नहीं होता है

"क्या? यहाँ क्या लिखा है?" तुम पूछते हो। अब मैं इसे बाहर रख दूंगा।

जब मैंने भाषा सीखना शुरू किया, तो मुझे नहीं लगा कि मैं इस संकीर्ण मामले में आऊंगा। एक पुनरावृत्ति संग्रह को संशोधित करना भी तर्कसंगत नहीं है।

उदाहरण के लिए:

func Foo() error { var err *os.PathError = nil return err } func main() { err := Foo() fmt.Println(err) // <nil> fmt.Println(err == nil) // false } 

WAT!

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

Go runtime / runtime2.go पैकेज फ़ाइल पर जाएं और देखें:

 type itab struct { // 40 bytes on a 64bit arch inter *interfacetype _type *_type ... } 

एक इंटरफ़ेस इंटरफ़ेस के प्रकार और मूल्य के प्रकार को खुद में संग्रहीत करता है।

किसी भी इंटरफ़ेस का मूल्य, न कि केवल त्रुटि, मामले में शून्य है जब AND और मान शून्य होते हैं।

फू फ़ंक्शन प्रकार का ओएस रिटर्न करता है * os.PathError, हम परिणाम की तुलना टाइप एनआईएल के शून्य से करते हैं, जिससे उनकी असमानता का पालन होता है।

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

मेरा उदाहरण है

 type Response struct { Result ResponseResult `json:"result,omitempty"` Error *ResponseError `json:"error,omitempty"` } type ResponseError struct { Message string `json:"message"` } func (e *ResponseError) Error() string { return e.Message } ... func (s *NotificationService) NotifyIfError(w *ResponseWriter) error { ... var res handlers.Response _ = json.Unmarshal(body, &res) if res.Error == nil { return } return s.NotifyError(err) } 

प्रतिक्रिया में हमेशा एक परिणाम या त्रुटि होती है।

यदि कोई त्रुटि है, तो हम इसे अधिसूचना सेवा के माध्यम से आवश्यक होने पर भेजते हैं।
सेवा के अंदर, त्रुटि विधि कहा जाता है, और चूंकि हमारा मूल्य शून्य है, हमें घबराहट होती है।

क्या करें?

एक इंटरफ़ेस प्रकार का सख्ती से एक इंटरफेस लौटें।

त्रुटि के मामले में - त्रुटि का प्रकार।

• एक प्रकार की त्रुटि की घोषणा जोड़ें

 func (s *NotificationService) NotifyIfError(w *ResponseWriter) error { ... var res Response _ = json.Unmarshal(body, &res) var err error = res.Error return s.NotifyError(err) } 

यह तकनीक, मेरे आश्चर्य के लिए, या तो काम नहीं करती है।

यह पता चला है कि जब गलत चर का मान निर्दिष्ट करते हैं, तो हम इसके बारे में भी प्रारंभिक जानकारी टाइप करते हैं, जो शून्य नहीं है।

• आइए हमारे स्रोत प्रकार को इंटरफ़ेस प्रकार से प्राप्त करने का प्रयास करें और इसके मूल्य की जांच करें।

 func (s *NotificationService) NotifyIfError(w *ResponseWriter) error { ... if e, ok := err.(*ResponseError); ok && e == nil { return s.NotifyError(err) } return nil } 

हां, यह तकनीक काम करती है।

लेकिन ईमानदार होने के लिए, हम उन सभी प्रकार की त्रुटियों की जांच करने का जोखिम नहीं उठा सकते हैं जिन्हें हम संचारित करेंगे।

यह डेटाबेस ड्राइवर, हमारे सभी आंतरिक त्रुटियों और अन्य कचरे से सभी त्रुटियां हो सकती हैं।

मेरे द्वारा देखे जाने वाले सबसे तर्कसंगत विकल्प क्या है:

 func (s *NotificationService) NotifyIfError(w *ResponseWriter) error { var err error ... var res Response _ = json.Unmarshal(body, &res) if res.Error != nil { return s.NotifyError(err) } return nil } 

पहले, हमने टाइप त्रुटि का एक चर घोषित किया, क्योंकि यह मान और प्रकार एनआईएल के साथ निकला।
और इस चर के लिए हमारे प्रकार और मूल्य को पारित करने से पहले, आइए nil पर हमारे प्रकार और उसके मूल्य की जांच करें।

यह हमें घबराहट के साथ नहीं आने देगा।

अंत में

आप आगे भी जा सकते हैं और प्रतिक्रिया के साथ "वैकल्पिक" त्रुटि को लागू कर सकते हैं, OptionalError या ErrorOrNil प्रकार, जैसे:

 func (r *Response) ErrorOrNil() error { if r.Error == nil { return nil } return r.Error } 

टिप्पणी

गो विकी नोटों में, कोड की समीक्षा इंटरफ़ेस के विषय में एक नोट है: इसके बजाय एक ठोस प्रकार लौटाएं और उपभोक्ता को निर्माता कार्यान्वयन का मजाक उड़ाएं।

मैं ध्यान देता हूं कि उपरोक्त नृत्य इस बारे में नहीं हैं।

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

लेकिन अगर आप एक निश्चित प्रकार को वापस करने का जोखिम उठा सकते हैं, तो उसे वापस कर दें।

संदर्भ

जाने-internals

मैं हूं

लिंक्डइन
तार
चहचहाना
Github