आईओएस पर उद्देश्य-सी में, संश्लेषित गेटर्स का उपयोग करते समय "self.foo" और "foo" के बीच (शैली) अंतर क्या है?

Question

मैंने ओबीजेसी एक्सेसर्स और संश्लेषित एक्सेसर्स पर कई प्रश्नों की खोज नहीं की है। यह सवाल "मुझे किसी मुद्दे को सुलझाने में मदद करें" प्रश्न है; मुझे एक जवाब की उम्मीद नहीं है, लेकिन मैं तर्क के आधार पर विशेषज्ञों की तलाश में हूं।

id foo = [self.soundEffects objectAtIndex:1]; 

एक सहयोगी ने मुझसे पूछा कि समझाने के लिए क्यों ऊपर इस लाइन के अलावा कोई बेहतर है:

एक कोको टच कक्षा में, मैं इस तरह कुछ कोड (जहां soundEffects है एक संश्लेषित NSArray संपत्ति) लिखते थे:

id foo = [soundEffects objectAtIndex:1]; 

अच्छा, कार्यात्मक रूप से, यह कोई अलग नहीं है।

1. self.soundEffects हर दूसरे सांकेतिक शब्दों में बदलनेवाला कोड है कि यह एक इवर, नहीं एक स्थानीय रूप से scoped चर रहा है पर काम कर बताता है:

   पूर्व के लिए मेरे तर्क इस प्रकार हैं।

2. यदि हमें कभी भी आवश्यकता होती है, तो हम soundEffects गेटटर एक्सेसर में कस्टम तर्क डाल सकते हैं।

3. कोई ठोस कारण नहीं है, यह एक वर्ष के लिए ओब्जे-सी में काम करने के बाद सही काम की तरह "महसूस करता है"।

उन्होंने तर्क # 1 और # 2 के रूप में मान्य स्वीकार करता है, लेकिन यह भी सुर देता है:

1. यह सिर्फ कोड ब्लोट नहीं है?

2. क्या किसी वर्ग को अपने स्वयं के iVars से सीधे किसी विधि (गेटटर) को कॉल किए बिना बात करने की अनुमति नहीं दी जानी चाहिए?

कोई भी लेने वाला?

Answer 1

आपका बिंदु 1 बिल्कुल सही नहीं है: self.soundEffectsनहीं एक इवर है, हालांकि यह है कि आप कुछ है जो है देने के लिए हो सकता है - यह करने के मामले में करता है के रूप में अपने पल पर NSArray, संश्लेषित ।

यह बदले में यह इंगित करता है कि आपका बिंदु 2 इस मामले का क्रूक्स है - यदि आप एक्सेसर के माध्यम से सभी पहुंच को रूट करते हैं, तो सबकुछ अच्छी तरह से encapsulated है और आप पक्ष के बारे में चिंता किए बिना बाद में कार्यान्वयन को संशोधित करने के लिए स्वतंत्र हैं प्रभाव।

जब आप म्यूटेटर का उपयोग करते हैं तो यह भी अच्छा अभ्यास है, इसलिए आप लगातार स्मृति प्रबंधन बनाए रखते हैं।

अधिकांश भाग के लिए, मैं यह सब कुछ है कि एक संपत्ति है के लिए self.property के माध्यम से रूट करने के लिए सलाह दी जाती है कहते हैं, और चीजें हैं जो सख्ती से आंतरिक हैं करने के लिए प्रत्यक्ष इवर उपयोग को सीमित होगी। हालांकि, मैं मानता हूं कि कुछ मामलों में - विशेष रूप से उन चीज़ों के लिए जो retain/copy अर्थशास्त्र का उपयोग नहीं करते हैं - यह शैली की प्राथमिकता के अधिक हो सकता है।

Answer 2

self.variable = nil जैसे कुछ का उपयोग कर चर को अपने सेटर के माध्यम से जाना जाता है और इसलिए स्मृति को मुफ्त में प्रबंधित किया जाता है। यदि आप उदाहरण के लिए variable = nil का उपयोग करते हैं, उदाहरण के लिए यह एक रिसाव का कारण बनता है क्योंकि यह वास्तव में परिवर्तनीय के लिए संश्लेषित सेटटर के माध्यम से नहीं जा रहा है और बनाए रखने की गिनती को कम करता है। यह पोस्ट देखें memory leak with self.

इस कारण से, यह हमेशा सलाह दी जाती है (मुझे विश्वास है) हमेशा स्वयं का उपयोग करने के लिए। उदाहरण के चर के साथ व्यवहार करते समय आपके पास स्मृति प्रबंधन तक का संबंध है।

Answer 3

मैं व्यक्तिगत रूप से ivars के लिए एक अंडरस्कोर उपसर्ग के प्रयोग पर आकर बस गए हैं, और संश्लेषित इस तरह

@synthesize name = _name; 

इस तरह मैं उन्हें मिश्रण नहीं है।स्वयं का उपयोग नहीं के साथ प्रमुख मुद्दा है कि इस कोड

_name = ... 

self.name = ... 

@property विकल्प को बनाए रखने का उपयोग करता है से बहुत अलग है। पहला ऑब्जेक्ट बरकरार नहीं रखता है, और दूसरा संश्लेषित सेटटर को बनाए रखता है जो बरकरार रहता है।

असाइन करने के साथ एक बड़ा अंतर बनाता है, इसलिए मैं हर समय self. का उपयोग करता हूं, इसलिए मैं सुनिश्चित करता हूं कि मैं इसे असाइन करता हूं।

Answer 4

self.soundEffects

सेटटर/गेटर के माध्यम से आवृत्ति चर सेट/प्राप्त करता है, और इसलिए यदि हम उनके मूल्य में परिवर्तन करते समय कुछ कस्टम ऑपरेशन करना चाहते हैं, तो तर्क उनके गेटर/सेटर में जा सकता है।

iOS 6 के अनुसार

इसके अलावा, इवर

@property (nonatomic)NSArray *propertyName;

करने के लिए इसी

_propertyName

हो जाएगा तो मैं लगता है कि आप नहीं कर सकते

id foo = [soundEffects objectAtIndex:1];

anymore.Not यकीन है कि का उपयोग though.Instead आप का उपयोग करना चाहिए

id foo = soundEffects[1];