Buscar..


Sintaxis

  • NSArray * palabras; // Declarando matriz inmutable
  • NSMutableArray * palabras; // Declarando matriz mutable
  • NSArray * palabras = [NSArray arrayWithObjects: @ "one", @ "two", nil]; // Sintaxis de inicialización de matriz
  • NSArray * words = @ [@ "list", @ "of", @ "words", @ 123, @ 3.14]; // Declarando matrices literales
  • NSArray * stringArray = [NSArray arrayWithObjects: [NSMutableArray array], [NSMutableArray array], [NSMutableArray array], nil]; // Creando matrices multidimensionales

Creando Arrays

Creando arreglos inmutables:

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

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

Para matrices mutables, vea NSMutableArray .

Averiguar el número de elementos en una matriz

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

Elementos de acceso

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

Obtener un solo artículo

El método objectAtIndex: proporciona un solo objeto. El primer objeto en una NSArray es el índice 0. Dado que una NSArray puede ser homogénea (que contiene diferentes tipos de objetos), el tipo de retorno es id ("cualquier objeto"). (Un id puede asignarse a una variable de cualquier otro tipo de objeto). Es importante destacar que NSArray s solo puede contener objetos. No pueden contener valores como int .

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

Clang proporciona una mejor sintaxis de subíndices como parte de su funcionalidad de literales de matriz :

NSString *color = myColors[idx];

Ambos lanzan una excepción si el índice pasado es menor que 0 o mayor que count - 1 .

Primer y último artículo

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

firstObject y lastObject son propiedades computadas y devuelven nil lugar de fallar para matrices vacías. Para matrices de elementos individuales devuelven el mismo objeto. Aunque, el método firstObject no se introdujo en NSArray hasta iOS 4.0.

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

Filtrado de matrices con predicados

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

Más sobre

NSPredicate :

Apple doc: NSPredicate

Convertir NSArray a NSMutableArray para permitir modificaciones

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

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

Ordenando matriz con objetos personalizados

Método de comparación

O implementas un método de comparación para tu objeto:

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

Puede ordenar fácilmente por varias claves agregando más de una a la matriz. También es posible usar métodos de comparación personalizados. Echa un vistazo a la documentación .

Bloques

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

Actuación

El -compare: y los métodos basados en bloques serán un poco más rápido, en general, que el uso de NSSortDescriptor ya que éste se basa en KVC. La principal ventaja del método NSSortDescriptor es que proporciona una manera de definir su orden de clasificación utilizando datos, en lugar de código, lo que facilita, por ejemplo, configurar las cosas para que los usuarios puedan ordenar un NSTableView haciendo clic en la fila del encabezado.

Conversión entre conjuntos y matrices

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

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

Revertir una matriz

NSArray *reversedArray = [myArray.reverseObjectEnumerator allObjects];

En bucle

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

Usando Genéricos

Para mayor seguridad, podemos definir el tipo de objeto que contiene la matriz:

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

Cabe señalar que esto se verifica solo durante el tiempo de compilación.

Enumerar utilizando bloques

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

Al establecer el parámetro de stop en YES , puede indicar que no se necesita más enumeración. para hacer esto simplemente establece &stop = YES .

NSEnumerationOptions
Puede enumerar la matriz en sentido inverso y / o concurrentemente:

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

Enumerar subconjunto de matriz

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

Comparando arrays

Las matrices se pueden comparar para igualarlas con el método acertadamente llamado isEqualToArray: que devuelve cuando ambas matrices tienen el mismo número de elementos y cada par pasa una comparación 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");
}

Lo importante es que cada par debe pasar la prueba isEqual:. Para los objetos personalizados, este método debe implementarse. Existe en el protocolo NSObject.

Añadir objetos a NSArray

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

Estos métodos están optimizados para recrear la nueva matriz de manera muy eficiente, generalmente sin tener que destruir la matriz original o incluso asignar más memoria.



Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow