Quand dois-je utiliser nil et NULL dans Objective-C?

Ceci est un exemple de code:

NSDictionary *myDictionary = [NSDictionary dictionary]; NSNumber *myNumber = [myDictionary valueForKey: @"MyNumber"]; NSLog(@"myNumber = %@", myNumber); // output myNumber = (null) if (myNumber == nil) NSLog(@"test 1 myNumber == nil"); if (myNumber == NULL) NSLog(@"test 2 myNumber == NULL"); if ([myNumber isEqual:[NSNull null]]) NSLog(@"test 3 myNumber == [NSNull null]"); 

Quand dois-je utiliser nil, NULL et [NSNull null]?

Vous pouvez utiliser nil à peu près partout où vous pouvez utiliser null . La principale différence est que vous pouvez envoyer des messages à nil , vous pouvez donc l’utiliser dans des endroits où null ne peut pas fonctionner.

En général, utilisez simplement nil .

Ils diffèrent par leurs types. Ils sont tous nuls, mais NULL est un void * , nil est un id et Nil est un pointeur de classe.

nil est une valeur vide liée / correspondant à un object (le type d’ID dans Objective-C). nil n’a pas de référence / adresse, juste une valeur vide.

 NSSsortingng *str = nil; 

Donc, nul ne devrait être utilisé si nous avons affaire à un object.

 if(str==nil) NSLog("str is empty"); 

Maintenant, NULL est utilisé pour le pointeur non-object (comme un pointeur C) dans Objective-C. Comme nil , NULL n’a aucune valeur ni adresse.

 char *myChar = NULL; struct MyStruct *dStruct = NULL; 

Donc s’il y a une situation, quand j’ai besoin de vérifier ma structure (variable de type structure) est vide ou pas alors, j’utiliserai:

 if (dStruct == NULL) NSLog("The struct is empty"); 

Avons un autre exemple, le

 - (void)observeValueForKeyPath:(NSSsortingng *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context 

En ce qui concerne l’ observation des valeurs-clés , le contexte doit être un pointeur C ou une référence d’object. Ici, pour le contexte, nous ne pouvons pas utiliser nil ; nous devons utiliser NULL .

Enfin, la classe NSNull définit un object singleton utilisé pour représenter des valeurs NULL dans des objects de collection (NSArray, NSDictionary). Le [NSNull null] renvoie l’instance singleton de NSNull. Fondamentalement, [NSNull null] est un object approprié.

Il est impossible d’insérer un object nil dans un object de type collection. Prenons un exemple:

 NSMutableArray *check = [[NSMutableArray alloc] init]; [check addObject:[NSNull null]]; [check addObject:nil]; 

Sur la deuxième ligne, nous n’obtiendrons aucune erreur, car il est parfaitement juste d’insérer un object NSNull dans un object de type collection. Sur la troisième ligne, nous obtiendrons l’erreur “object ne peut pas être nul”. Parce que nil n’est pas un object.

NULL et nil sont égaux l’un à l’autre, mais nil est une valeur d’object alors que NULL est une valeur de pointeur générique ( (void*)0 , pour être spécifique). [NSNull null] est un object destiné à [NSNull null] nil dans des situations où rien n’est autorisé. Par exemple, vous ne pouvez pas avoir de valeur nulle dans un NSArray. Donc, si vous devez représenter un “nil”, vous pouvez utiliser [NSNull null] .

J’ai trouvé ce qui suit:

objc.h

 #define Nil __DARWIN_NULL /* id of Nil class */ #define nil __DARWIN_NULL /* id of Nil instance */ 

_types.h

 #define __DARWIN_NULL ((void *)0) 

stddef.h

 #undef NULL #ifdef __cplusplus #undef __null // VC++ hack. #define NULL __null #else #define NULL ((void*)0) #endif 

MacTypes.h

 #ifndef NULL #define NULL __DARWIN_NULL #endif /* ! NULL */ #ifndef nil #define nil NULL #endif /* ! nil */ 

La façon dont cela se présente, il n’y a pas de différence, mais conceptuelle.

Attention, if([NSNull null]) renvoie true .

Pour développer un commentaire de @cobbal:

MacTypes.h contient:

 #ifndef nil #define nil NULL #endif 

Ils sont tous les deux juste typecast zéro. Fonctionnellement, il n’y a pas de différence entre eux. c’est à dire.,

 #define NULL ((void*)0) #define nil ((id)0) 

Il y a une différence, mais seulement pour vous et les autres humains qui lisent le code, le compilateur ne s’en soucie pas.

Une chose de plus est une valeur d’object alors que NULL est une valeur de pointeur générique.

Dans les SDK OS X et iOS modernes:

  • nil et Nil et NULL sont identiques dans Objective-C et Objective-C ++ avant C ++ 11.
  • nil et Nil et std::nullptr sont identiques dans Objective-C ++ avec C ++ 11.

De manière stylistique, de nombreuses personnes préfèrent utiliser nil pour les objects Objective-C et NULL ou nullptr pour les autres types de pointeurs. Je me sers maintenant de nil partout.

[NSNull null] est un object singleton utilisé pour représenter des valeurs NULL dans des situations où nil est interdit en tant que valeur (généralement dans un object de collection tel qu’un NSArray ou NSDictionary ). Rubriques de programmation de nombres et de valeurs: Utilisation de NSNull

Comme déjà mentionné, ils sont identiques, mais j’utilise l’un ou l’autre selon la langue dans laquelle le framework correspondant a été écrit.

Pour tout ce qui concerne Objective-C, j’utilise nil. Par exemple:

 - (BOOL)doSomethingWithObjectsInArray:(NSArray *)anArray { if (anArray == nil) return NO; // process elements ... } 

Cependant, lors de la vérification de la validité des modèles de données à partir d’un framework C (comme le framework AddressBook et CoreFoundation), j’utilise NULL. Par exemple:

 - (BOOL)showABUnknownPersonVCForABRecordRef:(ABRecordRef)aRecord { if (aRecord == NULL) return NO; // set-up the ABUnknownPersonViewController and display it on screen .. } 

De cette façon, j’ai des indices subtils dans mon code si je traite de code basé sur Obj-C ou C.

Il y a une différence dans certains contextes.

Littéralement, Null est un caractère: ASCII 0.

Nil est équivalent à blanc, pas de valeur.

Selon le contexte de programmation, cela peut être une grande différence.

Utilisez NULL par exemple lorsque vous appelez une méthode Objective-C avec un paramètre de sortie de type (NSError **).

Je vois beaucoup d’exemples de code sur le web où les gens fournissent nil au lieu de NULL dans ce cas. C’est parce que c’est un pointeur sur un pointeur et donc pas directement un type d’object Objective-C. Comme indiqué ci-dessus, nil doit être utilisé pour les types d’object Objective-C.

nil signifie absence de valeur alors que NULL représente No Object,

NSArray * array = @ [@ “Hello World!”, @ 101, [NSNULL null]];

Ici, [NSNULL null] est un object qui ne signifie aucun object. En même temps, vous ne pouvez append aucun object pour indiquer l’absence d’object.

vous pouvez utiliser nil et [NSNUll null] pour vérifier aussi.

Cela vous aidera à comprendre la différence entre nil, NIL et null.

Le lien ci-dessous peut vous aider d’une certaine manière:

http://nshipster.com/nil/

nil -> valeur littérale nulle pour les objects Objective-C.

Nil -> Valeur littérale nulle pour les classes Objective-C.

NULL -> Valeur littérale nulle pour les pointeurs C.

NSNULL -> object singleton utilisé pour représenter null.

Fondamentalement: nil: pointeur nul sur un object et null: est pour un autre type de pointeur

nil est un pointeur d’object à rien. Bien que sémantiquement distincts de NULL , ils sont techniquement équivalents les uns aux autres.

Au niveau de la structure, Foundation définit NSNull , qui définit une méthode de classe, + null, qui renvoie l’object singleton NSNull. NSNull est différent de Nil ou NULL , en ce sens qu’il s’agit d’un object réel , plutôt que d’une valeur nulle.

De plus, dans Foundation / NSObjCRuntime.h, Nil est défini comme un pointeur de classe sur rien.

Reportez-vous pour plus d’informations – nil / Nil / NULL / NSNull