¿Es mejor dar un NSMutableArray o crear un NSArray a partir de él?

Esta es una pregunta que me ha estado molestando por un time.

Quiero enviar algunos datos en un NSArray a un viewController y, a veces, necesito crear un NSMutableArray y poblarlo elemento por elemento.

Si lo envío al viewController, será inútil, ya que solo necesita leer la matriz. Entonces, me pregunto si es más costoso enviar un NSMutableArray, o crear un NSArray (¿tal vez?) Más ligero, con el costo de la asignación de memory y liberar el NSMutableArray (quizás?) Más pesado.

Por cierto, sé que está por encima de la optimization, pero tengo curiosidad.

Esto no tiene nada que ver con la optimization.

(O muy, muy poco y solo en casos poco comunes)

Tiene todo que ver con cuán a la defensiva quieres que sea tu código.

Siempre puede devolver una subclass de lo que sea que un método declare que es tipo de devolución. Eso solo funciona .

La persona que llama solo lo verá como lo que sea la superclass ( NSArray en este caso), a less que haga algo excepcionalmente peligroso al NSMutableArray hacia abajo a NSMutableArray y mutar la matriz.

Cuando esto sucede, si todavía está utilizando esa matriz como un almacén de respaldo en su object, la persona que llama modificará efectivamente su almacén de respaldo de debajo de usted.

Por return [[mutArray copy] autorelease]; usted está asegurando que esa tontería nunca puede suceder. Y, de hecho, el AppKit sufrió suficientes errores de personas que lanzaban y se deshacían con las matrices, que varios methods se han movido para return [[mutArray copy] autorelease];

También hay una implicación de hilo; Los types de base de solo lectura generalmente son seguros para subprocesss. La lectura-escritura no es y eso incluye la lectura mientras que otra cosa está escribiendo . Por lo tanto, si devuelve una reference a una matriz mutable, no puede volver a modificar esa matriz de otra cadena a less que sepa absolutamente que todas las references externas se han ido (que, por cierto, no se puede conocer sin un layout deficiente).

La implicación de performance de inmutable vs. mutable en la copy es muy raramente un problema.

Puede crearlo como un NSMutableArray pero luego enviarlo como un NSArray. Esto es válido, tenga en count que el tipo de retorno es NSArray pero el object es NSMutableArray. Puede hacer esto porque un NSMutableArray es un NSArray, es una subclass de NSArray. En este ejemplo, la persona que llama recibe un NSArray que no pueden * modificar.

 -(NSArray*)buildArray { NSMutableArray* mutArray = [NSMutableArray arrayWithCapacity:50]; ... fill the array... return mutArray; } 

* no sin casting

NSArray y NSMutableArray se implementan con CFArray, por lo que deberían tener el mismo performance en el elemento de acceso, si echas un vistazo a la versión de código abierto, pero la fuente cerrada que estás usando puede diferir (ver comentarios).

La diferencia de performance de utilizar NSArray vs NSMutable array surge principalmente cuando copy la matriz. si envía -copy a una matriz inmutable, simplemente choca con el recuento de retención, pero enviar -copy a una matriz mutable asignará memory de montón.

Si nunca más volverás a utilizar esa matriz en particular, declararía que el valor de retorno es un NSArray y simplemente devolveré el NSMutableArray que acabas de usar para comstackrlo.

Si puede usar internamente esa matriz o devolverla más tarde, usaría [NSArray arrayWithArray:mutableArray] para "degradarla". Especialmente si está creando un marco que otros usarán.