Objective-C Language
NSArray

वाक्य - विन्यास

• NSArray * शब्द; // अपरिवर्तनीय सरणी की घोषणा
• NSMutableArray * शब्द; // म्यूटेबल ऐरे को डिक्लेयर करना
• NSArray * शब्द = [NSArray arrayWithObjects: @ "one", @ "two", nil]; // ऐरे इनिशियलाइज़ेशन सिंटैक्स
• NSArray * शब्द = @ [@ "सूची", @ "का", @ "शब्द", @ 123, @ 3.14]; // सरणी शाब्दिकों की घोषणा
• NSArray * stringArray = [NSArray arrayWithObjects: [NSMutableArray array], [NSMutableArray array], [NSMutableArray array], nil]; // बहुआयामी सरणियाँ बनाना

ऐरे बनाना

अपरिवर्तनीय सरणियाँ बनाना:

NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];

// Using the array literal syntax:
NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];

म्यूटेबल सरणियों के लिए, NSMutableArray देखें।

एक ऐरे में तत्वों की संख्या का पता लगाना

NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];
NSLog (@"Number of elements in array = %lu", [myColors count]);

तत्वों तक पहुंचना

NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
// Preceding is the preferred equivalent to [NSArray arrayWithObjects:...]

एक ही वस्तु प्राप्त करना

objectAtIndex: विधि एकल ऑब्जेक्ट प्रदान करती है। NSArray में पहली वस्तु इंडेक्स है। 0. चूंकि NSArray समरूप हो सकता है (विभिन्न प्रकार की वस्तुओं को पकड़ना), रिटर्न प्रकार id ("कोई भी वस्तु") है। (एक id को किसी अन्य ऑब्जेक्ट प्रकार के एक चर को सौंपा जा सकता है।) महत्वपूर्ण रूप से, NSArray s में केवल ऑब्जेक्ट हो सकते हैं। उनमें int जैसे मान नहीं हो सकते।

NSUInteger idx = 2;
NSString *color = [myColors objectAtIndex:idx];
// color now points to the string @"Green"

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

NSString *color = myColors[idx];

ये दोनों एक अपवाद को फेंक देते हैं यदि पारित सूचकांक 0 से कम या count - 1 से अधिक है count - 1 ।

पहला और अंतिम आइटम

NSString *firstColor = myColors.firstObject;
NSString *lastColor = myColors.lastObject;

firstObject और lastObject गुण गणना की और वापसी कर रहे हैं nil खाली सरणियों के लिए दुर्घटनाग्रस्त बजाय। एकल तत्व सरणियों के लिए वे एक ही वस्तु लौटाते हैं। हालाँकि, पहले firstObject विधि को NSArray लिए iOS 4.0 तक पेश नहीं किया गया था।

NSArray *empty = @[]
id notAnObject = empty.firstObject;    // Returns `nil`
id kaboom = empty[0];    // Crashes; index out of bounds

छानने के साथ Arrays Predicates

NSArray *array = [NSArray arrayWithObjects:@"Nick", @"Ben", @"Adam", @"Melissa", nil];

NSPredicate *aPredicate = [NSPredicate predicateWithFormat:@"SELF beginswith[c] 'a'"];
NSArray *beginWithA = [array filteredArrayUsingPredicate:bPredicate];
     // beginWithA contains { @"Adam" }.

NSPredicate *ePredicate = [NSPredicate predicateWithFormat:@"SELF contains[c] 'e'"];
[array filterUsingPredicate:ePredicate];
    // array now contains { @"Ben", @"Melissa" }

के बारे में अधिक

NSPredicate :

Apple डॉक्टर: NSPredicate

NSArray को NSMutableArray में परिवर्तित करने के लिए संशोधन की अनुमति देना

NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];

// Convert myColors to mutable
NSMutableArray *myColorsMutable = [myColors mutableCopy]; 

कस्टम ऑब्जेक्ट्स के साथ सरणी को सॉर्ट करना

विधि की तुलना करें

या तो आप अपनी वस्तु के लिए तुलना-विधि लागू करते हैं:

- (NSComparisonResult)compare:(Person *)otherObject {
    return [self.birthDate compare:otherObject.birthDate];
}

NSArray *sortedArray = [drinkDetails sortedArrayUsingSelector:@selector(compare:)];

NSSortDescriptor

NSSortDescriptor *sortDescriptor;
sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"birthDate"
                                              ascending:YES];
NSArray *sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
NSArray *sortedArray = [drinkDetails sortedArrayUsingDescriptors:sortDescriptors];

आप कई कुंजियों को आसानी से एक से अधिक सरणी में जोड़कर सॉर्ट कर सकते हैं। कस्टम तुलनित्र-विधियों का उपयोग करना संभव है। प्रलेखन पर एक नजर है।

ब्लाकों

NSArray *sortedArray;
sortedArray = [drinkDetails sortedArrayUsingComparator:^NSComparisonResult(id a, id b) {
    NSDate *first = [(Person*)a birthDate];
    NSDate *second = [(Person*)b birthDate];
    return [first compare:second];
}];

प्रदर्शन

-compare: और ब्लॉक-आधारित विधियाँ सामान्य रूप से काफी तेज़ NSSortDescriptor , सामान्य रूप से NSSortDescriptor का उपयोग करने की NSSortDescriptor जैसा कि KVC पर निर्भर करता है। NSSortDescriptor विधि का प्राथमिक लाभ यह है कि यह कोड के बजाय डेटा का उपयोग करके आपके क्रम को परिभाषित करने का एक तरीका प्रदान करता है, NSSortDescriptor सेट करना आसान हो जाता है ताकि उपयोगकर्ता हेडर पंक्ति पर क्लिक करके NSTableView सॉर्ट कर सकें।

सेट्स और एरर्स के बीच रूपांतरण

NSSet *set = [NSSet set];
NSArray *array = [NSArray array];

NSArray *fromSet = [set allObjects];
NSSet *fromArray = [NSSet setWithArray:array];

एक उल्टा

NSArray *reversedArray = [myArray.reverseObjectEnumerator allObjects];

के माध्यम से लूपिंग

NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];

// Fast enumeration
// myColors cannot be modified inside the loop
for (NSString *color in myColors) {
    NSLog(@"Element %@", color);
}

// Using indices
for (NSUInteger i = 0; i < myColors.count; i++) {
    NSLog(@"Element %d = %@", i, myColors[i]);
}

// Using block enumeration
[myColors enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL * stop) {
    NSLog(@"Element %d = %@", idx, obj);

    // To abort use:
    *stop = YES
}];

// Using block enumeration with options
[myColors enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL * stop) {
    NSLog(@"Element %d = %@", idx, obj);
}];

जेनरिक का उपयोग करना

अतिरिक्त सुरक्षा के लिए हम उस ऑब्जेक्ट के प्रकार को परिभाषित कर सकते हैं जिसमें सरणी शामिल है:

NSArray<NSString *> *colors = @[@"Red", @"Green", @"Blue", @"Yellow"];
NSMutableArray<NSString *> *myColors = [NSMutableArray arrayWithArray:colors];
[myColors addObject:@"Orange"]; // OK
[myColors addObject:[UIColor purpleColor]]; // "Incompatible pointer type" warning

यह ध्यान दिया जाना चाहिए कि यह केवल संकलन समय के दौरान जाँच की जाती है।

ब्लॉकों का उपयोग कर गणना करना

NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
[myColors enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    NSLog(@"enumerating object %@ at index %lu", obj, idx);
}];

YES लिए stop पैरामीटर सेट करके आप संकेत कर सकते हैं कि आगे की गणना की आवश्यकता नहीं है। ऐसा करने के लिए बस सेट करें &stop = YES ।

NSEnumerationOptions
आप सरणी को उल्टा और / या समवर्ती में गणना कर सकते हैं:

[myColors enumerateObjectsWithOptions:NSEnumerationConcurrent | NSEnumerationReverse
                               usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
                                   NSLog(@"enumerating object %@ at index %lu", obj, idx);
                               }];

सरणी के सबसेट को अलग करना

NSIndexSet *indexSet = [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(1, 1)];
[myColors enumerateObjectsAtIndexes:indexSet
                            options:kNilOptions
                         usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
                                NSLog(@"enumerating object %@ at index %lu", obj, idx);
                            }];

तुलनात्मक सरणियाँ

एरे की तुलना बराबरी के लिए की जा सकती है जिसका नाम इस्क्लेतोअरे: विधि है, जो यस लौटाता है जब दोनों एरे में समान तत्वों की संख्या होती है और हर जोड़ा एक इस्क्वाल: तुलना करता है।

NSArray *germanMakes = @[@"Mercedes-Benz", @"BMW", @"Porsche",
                     @"Opel", @"Volkswagen", @"Audi"];
NSArray *sameGermanMakes = [NSArray arrayWithObjects:@"Mercedes-Benz",
                        @"BMW", @"Porsche", @"Opel",
                        @"Volkswagen", @"Audi", nil];

if ([germanMakes isEqualToArray:sameGermanMakes]) {
    NSLog(@"Oh good, literal arrays are the same as NSArrays");
}

महत्वपूर्ण बात यह है कि प्रत्येक जोड़ी को आइस्कल: टेस्ट पास करना चाहिए। कस्टम ऑब्जेक्ट के लिए इस विधि को लागू किया जाना चाहिए। यह NSObject प्रोटोकॉल में मौजूद है।

NSArray में ऑब्जेक्ट जोड़ें

NSArray *a = @[@1];
a = [a arrayByAddingObject:@2];
a = [a arrayByAddingObjectsFromArray:@[@3, @4, @5]];

इन तरीकों को नए सरणी को बहुत ही कुशलता से बनाने के लिए अनुकूलित किया जाता है, आमतौर पर मूल सरणी को नष्ट किए बिना या अधिक मेमोरी आवंटित करने के बिना।