NSDictionary + dictionnaireWithDictionary ou -copy?

Qui est considéré comme la meilleure façon de tirer un nouveau dictionnaire à partir d'un original:

[NSDictionary dictionaryWithDictionary:otherDictionary];

[otherDictionary copy];

De temps à autre, nous devons faire une mutable dictionnaire de immuable et cette question ne cesse de revenir. Peut-être il n'y a aucun, mais je suis curieux de voir si, dans certains cas d'utilisation de l'un est meilleur que l'autre.

MODIFIER: je sais que les méthodes ci-dessus ne peuvent pas être utilisées pour établir une mutable dictionnaire. Je voulais juste poser la question de manière générale, puis d'expliquer comment je dois faire face à cette question au jour le jour. J'aurais été plus clair à ce sujet.

source d'informationauteur matehat | 2013-06-12

foundation objective-c

28

En fait, ils sont différents, mais pas pour la raison que vous attendez. Je vais supposer que vous êtes à l'aide de l'ARC (et si vous n'êtes pas, pourquoi pas?), donc, l'auto-releasedness de l'objet retourné n'a pas d'importance.

Voici comment elles diffèrent: voyons ce qui se passe si otherDictionary est nil.

Bien, si vous utilisez:
```
[otherDictionary copy]; //or -mutableCopy
```
Vous allez obtenir nilparce que vous avez un nil récepteur.

D'autre part, si vous utilisez:
```
[NS(Mutable)Dictionary dictionaryWithDictionary:otherDictionary];
```
Vous sera obtenir un NS(Mutable)Dictionaryindépendamment de si otherDictionary est nil ou pas.

C'est bien dans la situation où vous avez besoin pour créer une copie d'un dictionnaire et veulent un NSDictionary instance par la suitemais vous ne voulez pas tester pour nil (yay pour la réduction de la complexité cyclomatique!).
7

Il ya un couple de choses à propos de cette question:

Tout d'abord, ces deux sont légèrement différentes:
```
[NSDictionary dictionaryWithDictionary:otherDictionary];    #1
[otherDictionary copy];                                     #2
```
#1 renvoie un autoreleased objet (c'est à dire, l'une avec un +0 retain count); #2 retourne un objet avec un +1 conserver compter, de sorte que l'appelant est responsable de l'appel release à un certain point.

(Ils sont également légèrement différente si otherDictionary est nil: #1 renvoie un dictionnaire vide, alors que #2 renvoie nil.)

Bien sûr, dans votre question, vous demandez à propos de mutable copies. Remarque vous pouvez effectuer l'une de ces:
```
[NSMutableDictionary dictionaryWithDictionary:otherDictionary];
[otherDictionary mutableCopy];
```
Les mêmes réserves que ci-dessus s'appliquent à chacune de ces méthodes.

Il n'y a probablement pas un meilleur façon en soi, mais mutableCopy est le plus clair (rappelez-vous juste que vous avez pour la libération de la retenue de l'objet à un certain point).
3

Ils sont sémantiquement équivalentes. À utiliser est entièrement une question de choix. Je préfère -copyjuste parce que c'est plus court, et fait ce qu'il se passe de plus en plus clair.

Si vous avez besoin d'une mutable copie (en tant que votre texte indique), les lignes que vous avez posté ne travail. Vous avez besoin de:
```
[NSMutableDictionary dictionaryWithDictionary:otherDictionary];
```
ou, de manière équivalente:
```
[otherDictionary mutableCopy];
```
En termes de gestion de la mémoire, -copy et -mutableCopyde retour d'un objet avec un +1 conserver le comte, ce qui signifie que vous devez les libérer lorsque vous avez terminé avec eux. -dictionaryWithDictionary: retourne un autoreleased objet, de sorte que vous n'avez pas besoin de le libérer lorsque vous avez terminé avec elle, et la nécessité de les conserver si vous voulez le garder.
Dans l'ancien (pré-ARC) jours, cette distinction signifie que l'approche que vous utilisé dépend peut-être de votre gestion de la mémoire besoins (ils sont toujours interchangeables après une période additionnelle de conserver ou de libération, bien sûr). Bien sûr, si vous utilisez un ARC, cette distinction n'est pas question pour vous.
0

Le Cacao approuvé consiste à envoyer un mutableCopy méthode qui renvoie une mutable copie:
```
NSMutableDictionary *mutableOtherDictionaryCopy = [otherDictionary mutableCopy]
```

Vous devez vous connecter pour publier un commentaire.