दिलचस्प पोस्ट
मैं py2exe में निष्पादन योग्य की वर्तमान निर्देशिका कैसे प्राप्त करूं? Excel VBA में JSON को पार्स करना हैंडलबार / मूंछें – क्या किसी ऑब्जेक्ट के गुणों के माध्यम से लूप का निर्माण होता है? CSS3 रूपांतरण: घुमाएगी; IE9 में पायथन में HTTP प्रतिसाद की वर्णसेट / एन्कोडिंग प्राप्त करने का एक अच्छा तरीका हैशडोड () कैसे सुनिश्चित करने के लिए बराबर () के अनुरूप है? एएसपी.नेट में 404 को लागू करने का सर्वोत्तम तरीका किसी अन्य सूची के अनुसार सूची को कैसे सॉर्ट करना है? एंड्रॉइड एसडीके मैनेजर खुला नहीं होगा फोर्स Google खाता चयनकर्ता जावा EE कंटेनर में धागे क्यों पैदा हो रहे हैं निराश? IE11 में "ब्राउज़र मोड" को कैसे वापस लाया जाए? जब std :: weak_ptr उपयोगी है? पायथन परिपत्र आयात करना? क्या node.js के साथ डेस्कटॉप अनुप्रयोग बनाना संभव है?

एनएसएआरआरई और एनएसएमयूटीएबलएआरआरई पर प्रतिलिपि और अयोग्य परिवर्तन कैसे लागू होते हैं?

copy और mutableCopy बीच अंतर क्या है जब किसी mutableCopy या mutableCopy पर इस्तेमाल किया जाता है?

यह मेरी समझ है; क्या यह सही है?

 // ** NSArray ** NSArray *myArray_imu = [NSArray arrayWithObjects:@"abc", @"def", nil]; // No copy, increments retain count, result is immutable NSArray *myArray_imuCopy = [myArray_imu copy]; // Copys object, result is mutable NSArray *myArray_imuMuta = [myArray_imu mutableCopy]; // Both must be released later 

 // ** NSMutableArray ** NSMutableArray *myArray_mut = [NSMutableArray arrayWithObjects:@"A", @"B", nil]; // Copys object, result is immutable NSMutableArray *myArray_mutCopy = [myArray_mut copy]; // Copys object, result is mutable NSMutableArray *myArray_mutMuta = [myArray_mut mutableCopy]; // Both must be released later 

वेब के समाधान से एकत्रित समाधान "एनएसएआरआरई और एनएसएमयूटीएबलएआरआरई पर प्रतिलिपि और अयोग्य परिवर्तन कैसे लागू होते हैं?"

copy और mutableCopy copy को अलग-अलग प्रोटोकॉल ( NSCopying और NSCopying , क्रमशः) में परिभाषित किया गया है, और NSCopying दोनों के अनुरूप है। mutableCopy को NSArray (न सिर्फ NSMutableArray ) के लिए परिभाषित किया गया है और आपको मूल रूप से अपरिवर्तनीय सरणी की एक अस्थायी प्रतिलिपि बनाने की अनुमति देता है:

 // create an immutable array NSArray *arr = [NSArray arrayWithObjects: @"one", @"two", @"three", nil ]; // create a mutable copy, and mutate it NSMutableArray *mut = [arr mutableCopy]; [mut removeObject: @"one"]; 

सारांश:

  • आप अस्थिर होने के लिए mutableCopy के परिणाम पर निर्भर कर सकते हैं, मूल प्रकार की परवाह किए बिना। सरणियों के मामले में, परिणाम NSMutableArray होना चाहिए।
  • आप copy के परिणाम पर निर्भर नहीं हो सकते हैं ! एक NSMutableArray copy एक NSMutableArray वापस कर सकते हैं, क्योंकि यह मूल वर्ग है, लेकिन किसी भी मनमाना NSArray आवृत्ति copy नहीं होगा।

संपादित करें: मार्क बेसे के उत्तर के प्रकाश में अपने मूल कोड को फिर से पढ़ लें। जब आप अपने सरणी की एक प्रतिलिपि बनाते हैं, ज़ाहिर है कि आप प्रतिलिपि के साथ क्या करते हैं, इसके बावजूद आप मूल को संशोधित कर सकते हैं। copy बनाम mutableCopy प्रभावित करता है कि क्या नया सरणी अस्थिर है।

2 संपादित करें: फिक्स्ड मेरी (झूठे) धारणा है कि NSMutableArray -copy एक NSMutableArray वापस आएगा।

मुझे लगता है कि आपने गलत तरीके से व्याख्या की होगी कि कैसे प्रतिलिपि और अस्थिरता काम करते हैं। आपके पहले उदाहरण में, myArray_COPY myArray की एक अपरिपक्व प्रति है। प्रतिलिपि बनाने के बाद, आप मूल myArray की सामग्री को हेरफेर कर सकते हैं, और myArray_COPY की सामग्री को प्रभावित नहीं कर सकते।

दूसरे उदाहरण में, आप myArray की एक अस्थायी प्रतिलिपि बनाते हैं, जिसका अर्थ है कि आप किसी दूसरे को प्रभावित किए बिना, सरणी की प्रतिलिपि को संशोधित कर सकते हैं।

यदि मैं myArray_COPY से ऑब्जेक्ट्स को सम्मिलित / निकालने का प्रयास करने के लिए पहला उदाहरण बदलता हूं, तो यह विफल हो जाता है, जैसे आप अपेक्षा करते हैं


शायद एक विशिष्ट उपयोग-मामले के बारे में सोचने में मदद मिलेगी यह अक्सर ऐसा मामला है कि आप एक ऐसी विधि लिख सकते हैं जो एक NSArray * पैरामीटर लेती है, और मूल रूप से इसे बाद के उपयोग के लिए संग्रहीत करता है। आप ऐसा कर सकते हैं:

 - (void) doStuffLaterWith: (NSArray *) objects { myObjects=[objects retain]; } 

… लेकिन तब आपको समस्या है कि विधि को NSMutableArray के साथ तर्क के रूप में कहा जा सकता है कोड जो सरणी का निर्माण करता है, उसमें जब इसे doStuffLaterWith: विधि कहा जाता है, और जब आपको बाद में मूल्य का उपयोग करने की आवश्यकता होती है, तब हेरफेर कर सकता है। बहु-थ्रेडेड ऐप में, सरणी की सामग्री को तब भी बदला जा सकता है जब आप इसे फिर से चालू कर रहे हों , जो कुछ रोचक कीड़े पैदा कर सकता है।

यदि आप इसके बजाय ऐसा करते हैं:

 - (void) doStuffLaterWith: (NSArray *) objects { myObjects=[objects copy]; } 

..तो प्रतिलिपि उस विधि की एक स्नैपशॉट बनाता है, जिस पर विधि कहा जाता है।

"कॉपी" विधि एनएससीपीआईपी प्रोटोकॉल को कॉपी करके कार्यान्वित किए गए ऑब्जेक्ट को देता है। विथ ज़ोन:

यदि आप एक प्रति संदेश NSString भेजते हैं:

 NSString* myString; NSString* newString = [myString copy]; 

वापसी मूल्य एक NSString होगा (अस्थिर नहीं)


MutableCopy विधि NSMutableCopying प्रोटोकॉल के अस्थिरता के द्वारा बनाई गई ऑब्जेक्ट देता है CopyWithZone:

भेजकर:

 NSString* myString; NSMutableString* newString = [myString mutableCopy]; 

वापसी मूल्य अस्थिर होगा


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


एनएसएआरए के मामले में उथले और गहरी नकल के बारे में जटिलता का एक अतिरिक्त स्तर है।

एक NSArray की एक उथले प्रतिलिपि मूल सरणी के ऑब्जेक्ट के संदर्भों की प्रतिलिपि को केवल कॉपी कर देगी और उन्हें नए सरणी में रखेंगी।

परिणाम यह है कि:

 NSArray* myArray; NSMutableArray* anotherArray = [myArray mutableCopy]; [[anotherArray objectAtIndex:0] doSomething]; 

यह भी मूल सरणी में 0 सूचकांक पर ऑब्जेक्ट को प्रभावित करेगा।


एक गहरी प्रति वास्तव में एरे में निहित व्यक्तिगत वस्तुओं की प्रतिलिपि होगा। यह प्रत्येक व्यक्ति वस्तु को "copyWithZone:" संदेश भेजकर किया गया

 NSArray* myArray; NSMutableArray* anotherArray = [[NSMutableArray alloc] initWithArray:myArray copyItems:YES]; 

अयोग्य वस्तु प्रतिलिपि के बारे में गलत धारणा को हटाने के लिए संपादित

 NSMutableArray* anotherArray = [[NSMutableArray alloc] initWithArray:oldArray copyItems:YES]; 

anotherArray जो anotherArray की एक प्रति 2 स्तरों के लिए गहरी है। यदि oldArray का एक ऑब्जेक्ट एक अर्रे है जो आम तौर पर ज्यादातर अनुप्रयोगों में मामला है।

ठीक है अगर हमें एक सच्ची गहरी प्रतिलिपि की आवश्यकता होती है तो हम इसका उपयोग कर सकते हैं,

 NSArray* trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData: [NSKeyedArchiver archivedDataWithRootObject: oldArray]]; 

यह सुनिश्चित करेगा कि प्रत्येक स्तर पर मूल वस्तु की परिवर्तनशीलता बनाए रखने के लिए सभी स्तर वास्तव में प्रतिलिपि बनाए गए हैं।

रॉबर्ट क्लेरेंस डी आलमेडा, बैंगलोर, भारत

आप addObject को बुला रहे हैं और मूल ऐरे पर ऑब्जेक्ट आटइंडेक्स को हटा सकते हैं, न कि आपके द्वारा बनाई गई उस की नई प्रति। कॉलिंग बनाम टूटेबल कॉप केवल ऑब्जेक्ट की नई प्रति की परिवर्तनशीलता को प्रभावित नहीं करता, न कि मूल ऑब्जेक्ट।

इसे बस बताएं,

  • प्रतिलिपि एक अपरिवर्तनीय (संशोधित नहीं किया जा सकता है) सरणी की प्रतिलिपि देता है,
  • अस्थिरकैप एक अस्थिर (संशोधित किया जा सकता है) सरणी की प्रतिलिपि देता है।

प्रतिलिपि (दोनों ही मामलों में) का मतलब है कि आप मूल सरणी के लिए ऑब्जेक्ट संदर्भों के साथ "आबादी वाले" एक नया सरणी प्राप्त करते हैं (अर्थात समान (मूल) ऑब्जेक्ट प्रतियों में संदर्भित होते हैं

यदि आप म्यूटटेबल को कॉपी करने के लिए नई ऑब्जेक्ट जोड़ते हैं, तो वे परिवर्तन योग्य कॉप के लिए अद्वितीय होते हैं। यदि आप ऑब्जेक्ट्स अस्थिरता से हटाते हैं, तो उन्हें मूल सरणी से निकाल दिया जाता है।

दोनों मामलों में प्रतिलिपि के बारे में सोचें, प्रतिलिपि बनाने के समय मूल सरणी के समय में स्नैपशॉट के रूप में

मान लीजिये

 NSArray *A = xxx; // A with three NSDictionary objects NSMutableArray *B = [A mutableCopy]; 

बी की सामग्री NSDictionary ऑब्जेक्ट NSMutableDictionary नहीं है, यह सही है?

 -(id)copy always returns a immutable one & -(id)mutableCopy always returns a mutable object,that's it. 

आपको ये प्रतिलिपि बनाने वाले सामान की वापसी के प्रकार को जानना होगा और नई ऑब्जेक्ट को घोषित करना होगा, जिस पर एक को रिटर्न वैल्यू असाइन किया जाएगा, अस्थायी या अस्थिर होना चाहिए, अन्यथा कंपाइलर आपको त्रुटि दिखाएगा।

जिस चीज की प्रतिलिपि बनाई गई है वह नया प्रयोग करके संशोधित नहीं किया जा सकता है, ये पूरी तरह से दो अलग-अलग ऑब्जेक्ट हैं।