Objective-C Language
NSArray

Syntaxis

• NSArray * woorden; // Onveranderlijke array verklaren
• NSMutableArray * woorden; // Verklaarbare array verklaren
• NSArray * words = [NSArray arrayWithObjects: @ "one", @ "two", nihil]; // Syntaxis van de initialisatie van de array
• NSArray * words = @ [@ "list", @ "of", @ "words", @ 123, @ 3.14]; // Arrayliterals declareren
• NSArray * stringArray = [NSArray arrayWithObjects: [NSMutableArray array], [NSMutableArray array], [NSMutableArray array], nul]; // Multidimentionele arrays maken

Arrays maken

Onveranderlijke arrays maken:

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

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

Zie NSMutableArray voor veranderlijke arrays.

Het aantal elementen in een array achterhalen

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

Toegang tot elementen

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

Eén item krijgen

De methode objectAtIndex: biedt een enkel object. Het eerste object in een NSArray is index 0. Omdat een NSArray homogeen kan zijn (met verschillende soorten objecten), is het id ("elk object"). (Een id kan worden toegewezen aan een variabele van elk ander objecttype.) Belangrijk is dat NSArray s alleen objecten kunnen bevatten. Ze kunnen geen waarden bevatten zoals int .

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

Clang biedt een betere subscript-syntaxis als onderdeel van de array literals-functionaliteit :

NSString *color = myColors[idx];

Beide werpen een uitzondering op als de doorgegeven index kleiner is dan 0 of groter dan count - 1 .

Eerste en laatste item

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

Het firstObject en lastObject zijn berekende eigenschappen en retourneren nil plaats van crashen voor lege arrays. Voor arrays met één element retourneren ze hetzelfde object. Hoewel, de firstObject methode pas in iOS 4.0 werd geïntroduceerd in NSArray .

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

Arrays filteren met predicaten

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" }

Meer over

NSP-certificaat :

Apple doc: NSPredicate

NSArray converteren naar NSMutableArray om aanpassing toe te staan

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

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

Sorteerarray met aangepaste objecten

Vergelijk methode

Ofwel implementeert u een vergelijkingsmethode voor uw object:

- (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];

U kunt eenvoudig sorteren op meerdere toetsen door meer dan één aan de array toe te voegen. Het gebruik van aangepaste vergelijkingsmethoden is ook mogelijk. Bekijk de documentatie .

Blocks

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

Prestatie

De -compare: en -compare: methoden zijn over het algemeen een stuk sneller dan het gebruik van NSSortDescriptor omdat deze op KVC vertrouwt. Het primaire voordeel van de NSSortDescriptor methode is dat deze een manier biedt om uw sorteervolgorde te definiëren met behulp van gegevens, in plaats van code, waardoor het bijvoorbeeld eenvoudig is om dingen in te stellen zodat gebruikers een NSTableView kunnen sorteren door op de kopregel te klikken.

Converteren tussen sets en arrays

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

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

Een array omkeren

NSArray *reversedArray = [myArray.reverseObjectEnumerator allObjects];

Doorlussen

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);
}];

Generics gebruiken

Voor extra veiligheid kunnen we het type object definiëren dat de array bevat:

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

Opgemerkt moet worden dat dit alleen tijdens de compilatie wordt gecontroleerd.

Opsommen met blokken

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

Door de parameter stop op YES kunt u aangeven dat verdere opsomming niet nodig is. om dit te doen, stel &stop = YES .

NSEnumerationOptions
U kunt de array in omgekeerde volgorde en / of gelijktijdig opsommen:

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

Subset van array opsommen

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);
                            }];

Arrays vergelijken

Arrays kunnen worden vergeleken voor gelijkheid met de toepasselijke naam isEqualToArray: methode, die JA retourneert wanneer beide arrays hetzelfde aantal elementen hebben en elk paar een isEqual: vergelijking doorgeeft .

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");
}

Het belangrijkste is dat elk paar de isEqual: test moet doorstaan. Voor aangepaste objecten moet deze methode worden geïmplementeerd. Deze bestaat in het NSObject-protocol.

Voeg objecten toe aan NSArray

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

Deze methoden zijn geoptimaliseerd om de nieuwe array zeer efficiënt te maken, meestal zonder de oorspronkelijke array te vernietigen of zelfs meer geheugen toe te wijzen.