Objective-C Language
NSArray
Recherche…
Syntaxe
- NSArray * mots; // Déclarer un tableau immuable
- NSMutableArray * mots; // Déclarer un tableau mutable
- NSArray * words = [NSArray arrayWithObjects: @ "one", @ "two", nil]; // Syntaxe d'initialisation de tableau
- NSArray * words = @ [@ "list", @ "de", @ "mots", @ 123, @ 3.14]; // Déclaration des littéraux de tableau
- NSArray * stringArray = [NSArray arrayWithObjects: [NSMutableArray array], [NSMutableArray array], [NSMutableArray array], nil]; // Création de tableaux multidimentionnels
Création de tableaux
Création de tableaux immuables:
NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];
// Using the array literal syntax:
NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
Pour les tableaux mutables, voir NSMutableArray .
Déterminer le nombre d'éléments dans un tableau
NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];
NSLog (@"Number of elements in array = %lu", [myColors count]);
Accès aux éléments
NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
// Preceding is the preferred equivalent to [NSArray arrayWithObjects:...]
Obtenir un seul article
La méthode objectAtIndex: fournit un objet unique. Le premier objet d'un NSArray est l'index 0. Comme un NSArray peut être homogène (avec différents types d'objets), le type de retour est id ("any object"). (Un id peut être assigné à une variable de n'importe quel autre type d'objet.) Il est important de noter que NSArray ne peut contenir que des objets. Ils ne peuvent pas contenir de valeurs comme int .
NSUInteger idx = 2;
NSString *color = [myColors objectAtIndex:idx];
// color now points to the string @"Green"
Clang fournit une meilleure syntaxe d'indice dans le cadre de sa fonctionnalité de littéraux de tableau :
NSString *color = myColors[idx];
Les deux lancent une exception si l'index transmis est inférieur à 0 ou supérieur à count - 1 .
Premier et dernier article
NSString *firstColor = myColors.firstObject;
NSString *lastColor = myColors.lastObject;
Les firstObject et lastObject sont des propriétés calculées et renvoient à nil plutôt que de planter pour des tableaux vides. Pour les tableaux à élément unique, ils renvoient le même objet. Bien que la méthode firstObject n'ait pas été introduite dans NSArray avant iOS 4.0.
NSArray *empty = @[]
id notAnObject = empty.firstObject; // Returns `nil`
id kaboom = empty[0]; // Crashes; index out of bounds
Filtrage de tableaux avec des prédicats
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" }
Plus à propos
Doc Apple: NSPredicate
Conversion de NSArray en NSMutableArray pour permettre la modification
NSArray *myColors = [NSArray arrayWithObjects: @"Red", @"Green", @"Blue", @"Yellow", nil];
// Convert myColors to mutable
NSMutableArray *myColorsMutable = [myColors mutableCopy];
Tri du tableau avec des objets personnalisés
Comparer la méthode
Soit vous implémentez une méthode de comparaison pour votre objet:
- (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];
Vous pouvez facilement trier par plusieurs clés en en ajoutant plusieurs dans le tableau. L'utilisation de méthodes de comparaison personnalisées est également possible. Regardez la documentation .
Blocs
NSArray *sortedArray;
sortedArray = [drinkDetails sortedArrayUsingComparator:^NSComparisonResult(id a, id b) {
NSDate *first = [(Person*)a birthDate];
NSDate *second = [(Person*)b birthDate];
return [first compare:second];
}];
Performance
Les -compare: et les méthodes basées sur les blocs seront en général beaucoup plus rapides qu'en utilisant NSSortDescriptor car ce dernier repose sur KVC. Le principal avantage de la méthode NSSortDescriptor est qu’elle permet de définir l’ordre de tri en utilisant des données plutôt que du code, ce qui facilite la configuration, par exemple, pour que les utilisateurs puissent trier un NSTableView en cliquant sur la ligne d’en-tête.
Conversion entre les ensembles et les tableaux
NSSet *set = [NSSet set];
NSArray *array = [NSArray array];
NSArray *fromSet = [set allObjects];
NSSet *fromArray = [NSSet setWithArray:array];
Inverser un tableau
NSArray *reversedArray = [myArray.reverseObjectEnumerator allObjects];
En boucle à travers
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);
}];
Utiliser des génériques
Pour plus de sécurité, nous pouvons définir le type d'objet que contient le tableau:
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
Il convient de noter que cela est vérifié uniquement au moment de la compilation.
Enumérer à l'aide de blocs
NSArray *myColors = @[@"Red", @"Green", @"Blue", @"Yellow"];
[myColors enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
NSLog(@"enumerating object %@ at index %lu", obj, idx);
}];
En définissant le paramètre d' stop sur YES vous pouvez indiquer qu'une autre énumération n'est pas nécessaire. pour ce faire, il suffit de définir &stop = YES .
NSEnumerationOptions
Vous pouvez énumérer le tableau en sens inverse et / ou simultanément:
[myColors enumerateObjectsWithOptions:NSEnumerationConcurrent | NSEnumerationReverse
usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
NSLog(@"enumerating object %@ at index %lu", obj, idx);
}];
Sous-ensemble énumérant du tableau
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);
}];
Comparaison de tableaux
Les tableaux peuvent être comparés en termes d' égalité avec la méthode isEqualToArray: qui renvoie YES lorsque les deux tableaux ont le même nombre d'éléments et que chaque paire réussit une comparaison isEqual : .
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");
}
La chose importante est que chaque paire doit passer le test isEqual: Pour les objets personnalisés, cette méthode doit être implémentée. Elle existe dans le protocole NSObject.
Ajouter des objets à NSArray
NSArray *a = @[@1];
a = [a arrayByAddingObject:@2];
a = [a arrayByAddingObjectsFromArray:@[@3, @4, @5]];
Ces méthodes sont optimisées pour recréer le nouveau tableau très efficacement, généralement sans avoir à détruire le tableau d'origine ou même à allouer plus de mémoire.