Objective-C Language
NSArray
Zoeken…
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
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.
