Comment puis-je convertir des NSMutableArray de NSArray?

Comment puis-je convertir des NSMutableArray de NSArray dans objective-c?

juste NSArray *array = [mutableArray copy];
NSArray *array = mutableArray;
le béryllium: Absolument droit. vladof81: bien sûr que non.

InformationsquelleAutor marcy | 2009-11-20

496
```
NSArray *array = [mutableArray copy];
```
Copier fait immuable des copies. C'est très utile parce que Apple peut faire de diverses optimisations. Par exemple pour envoyer des copy à un immuable tableau ne retient que l'objet et retourne self.

Si vous n'utilisez pas de collecte des ordures ou d'un ARC rappelez-vous que -copy conserve l'objet.
- cette réponse est très bien, mais comment puis-je dire d'après les docs que copy crée un normal NSArray et pas un NSMutableArray?
- Vous regardez la documentation de NSCopying Il affirme: copyWithZone La copie retournée est immuable, si la contrepartie “immuable vs mutable” s'applique à la réception de l'objet; autrement, la nature exacte de la copie est déterminé par la classe.
- Très soigné - je préfère cela à m5h de la solution. À la fois laconique et plus efficace.
- Je suis d'accord David, mis à jour à ma réponse à point pour cette réponse.
- Je vois beaucoup de votes pour votre commentaire, mais franchement je n'ai pas la moindre idée de ce qu'Apple doc commentaire signifie réellement. Comment peut-on déterminer si "l'examen immuable vs mutable s'applique à l'objet de réception"?
- Cela veut simplement dire que les classes qui ont à la fois changeant et immuable implémentations. E. g. NSArray & NSMutableArray, NSString & NSMutableString. Mais pas, par exemple, NSViewController qui contient toujours mutable état.
InformationsquelleAutor Georg Schölly
359

Un NSMutableArray est une sous-classe de NSArray de sorte que vous n'aurez pas toujours besoin de convertir, mais si vous voulez vous assurer que le tableau ne peut pas être modifié, vous pouvez créer un NSArray l'une de ces manières, selon que vous voulez qu'il autoreleased ou pas:
```
/* Not autoreleased */
NSArray *array = [[NSArray alloc] initWithArray:mutableArray];

/* Autoreleased array */
NSArray *array = [NSArray arrayWithArray:mutableArray];
```
EDIT: La solution fournis par Georg Schölly est une meilleure façon de le faire et beaucoup plus propre, surtout maintenant que nous avons de l'ARC et de ne même pas avoir à appeler autorelease.
- Puis-je faire (NSArray *) myMutableArray ?
- Oui, comme NSMutableArray est une sous-classe de NSArray qui est valable.
- Toutefois, l'association (NSArray *) permet encore une fonte de retour jusqu'à (NSMutable *). N'est-ce pas le cas?
- Oui, c'est correct. Vous recevez un avertissement si vous ne lancez pas mais attribuer une super-classe sous-classe directement. Habituellement, vous voulez retourner un immuable copie, parce que c'est la seule façon d'être sûr que votre tableau vraiment de ne pas obtenir modifié.
- Anciennement connu sous le nom de "Upcasting" (NSArray *) myMutableArray et l'inverse est appelé "Passer"
InformationsquelleAutor hallski
112

J'aime les 2 solutions principales:
```
NSArray *array = [NSArray arrayWithArray:mutableArray];
```
Ou
```
NSArray *array = [mutableArray copy];
```
La principale différence je vois en eux est de savoir comment ils se comportent quand mutableArray est nul:
```
NSMutableArray *mutableArray = nil;
NSArray *array = [NSArray arrayWithArray:mutableArray];
//array == @[] (empty array)

NSMutableArray *mutableArray = nil;
NSArray *array = [mutableArray copy];
//array == nil
```
- C'est tellement mauvais. Viens de vérifier. [mutableArray copie] renvoie un tableau vide.
- Il n'est pas faux. Vérifiez votre test. Si [mutableArray copie] retourne un tableau vide, puis mutableArray doit avoir été un tableau vide. Ma réponse ne s'applique que lorsque mutableArray est nul.
- Bien que cela est vrai, je me sens comme vous êtes absent plus fondamental de la vérité dans votre exemple. Depuis que vous avez attribué mutableArray être nul, [mutableArray copy] peut être simplifié à [nil copy]. En objective-c aucun message envoyé à néant sera toujours nul. Il est important de rappeler la distinction entre "rien" et "un tableau avec rien dedans".
- Laissez pas détourner de la question: "Comment puis-je convertir des NSMutableArray de NSArray?" Il y a 2 solutions principales, et la principale différence entre eux est de savoir comment ils se comportent quand la mutable tableau est nul.
InformationsquelleAutor Richard Venable

vous essayez ce code---

NSMutableArray *myMutableArray = [myArray mutableCopy];

NSArray *myArray = [myMutableArray copy];

Ce ne ce ne que les autres ne font pas?

InformationsquelleAutor Jerry Thomsan

4

Objective-C

Ci-dessous est la façon de convertir NSMutableArray de NSArray:
```
//oldArray is having NSMutableArray data-type.
//Using Init with Array method.
NSArray *newArray1 = [[NSArray alloc]initWithArray:oldArray];

//Make copy of array
NSArray *newArray2 = [oldArray copy];

//Make mutablecopy of array
NSArray *newArray3 = [oldArray mutableCopy];

//Directly stored NSMutableArray to NSArray.
NSArray *newArray4 = oldArray;
```
Swift

Dans Swift 3.0 il y a un nouveau type de données Tableau. Déclarer un Tableau avec let mot-clé, alors il deviendrait NSArray Et si la déclarer à l'aide de var mot-clé, c'est devenu NSMutableArray.

Exemple de code:
```
let newArray = oldArray as Array
```
- La Swift n'est pas tout à fait juste. Voir ici et ici pour la différence entre mutable/immuable Arrays et NSArray/NSMutableArrays. Ils ne sont pas les mêmes.
InformationsquelleAutor Sakir Sherasiya

En objective-c :

NSArray *myArray = [myMutableArray copy];

Dans swift :

 var arr = myMutableArray as NSArray

InformationsquelleAutor Vikram Biwal

2
```
NSArray *array = mutableArray;
```
Ce [mutableArray copy] antipattern est tout au plus un exemple de code. Cesser de le faire pour du jetable mutable tableaux qui sont transitoires et désallouées à la fin du présent champ d'application.

Il n'y a aucun moyen de l'exécution d'optimiser le gaspillage de la copie d'une mutable tableau qui est sur le point d'aller hors de portée, decrefed à 0 et libéré pour de bon.
- L'attribution d'une NSMutableArray à un NSArray variable ne sera pas le convertir (ce qui est le cas des OP question est sur). Exposer une telle valeur (par exemple une valeur de retour ou de propriété) pourrait entraîner très dur pour déboguer les problèmes si cette valeur a été muté de façon inattendue. Cela s'applique à la fois interne et externe mutations depuis la mutable valeur est partagée.
- À muter, ce tableau vous auriez à [NSMutableArray arrayWithArray:... ou quelque chose comme ça.
- Pas nécessairement. Tout simplement en l'assignant à un NSMutableArray variable est assez. Depuis l'objet de jamais cessé d'être une mutable tableau, l'appel de la mutation des méthodes, il va réussir et de muter les données partagées. En revanche, si l'original mutable tableau a été copié un immuable de la matrice, puis assigné à un NSMutableArray variable et a une mutation des méthodes appelé sur elle, ces appels échouerait avec doesNotRespondToSelector des erreurs parce que l'objet qui a reçu la mutation de l'appel de méthode est en fait immuable et ne répond pas à ces méthodes.
- ok, cela pourrait avoir un certain mérite pour les développeurs à ne pas tenir compte de l'avertissement du compilateur sur tyope de conversion assignations de
InformationsquelleAutor Anton Tropashko
1

Si vous êtes à la construction d'un tableau via la mutabilité et que vous souhaitez retourner un immuable version, vous pouvez simplement retourner les mutable tableau comme un "NSArray" via l'héritage.
```
- (NSArray *)arrayOfStrings {
    NSMutableArray *mutableArray = [NSMutableArray array];
    mutableArray[0] = @"foo";
    mutableArray[1] = @"bar";

    return mutableArray;
}
```
Si vous "confiance" en l'appelant pour traiter l' (techniquement toujours mutable) rendement de l'objet comme une immuable NSArray, c'est une option moins coûteuse que [mutableArray copy].

Apple est d'accord:

De déterminer si elle peut changer de réception d'un objet, le destinataire d'un message doit s'appuyer sur le type formel de la valeur de retour. S'il reçoit, par exemple, un tableau d'objet typé comme immuable, il ne doit pas tenter de les transformer. Il n'est pas acceptable, en programmation, afin de déterminer si un objet est modifiable en fonction de sa classe d'appartenance.

La pratique ci-dessus est discuté plus en détail ici:

Meilleure Pratique: Retour mutableArray.copie ou mutableArray si le type de retour est NSArray

InformationsquelleAutor pkamb
0

j'ai été chercher la réponse à swift 3 et cette question a été montré comme premier résultat de recherche et j'ai trouver de l'inspiration, la réponse de il
voici donc la swift 3 code
```
let array: [String] = nsMutableArrayObject.copy() as! [String]
```
InformationsquelleAutor Amr Angry

Vous devez vous connecter pour publier un commentaire.

Objective-C

Swift