Is nil and (NSString *)[NSNull null] equivalent in checking empty NSString object

Question

I have a NSString object,

NSString *aString;

then are the two following versions equivalent?

Version 1 :

if ( (NSString *)[NSNull null] == aString )
{
   // Logic handling
}

Version 2 :

if ( nil == aString )
{
   // Logic handling
}

Reference Posts

1. Difference among nil, Nil, and null

2. How to detect if NSString is null?

3. Apple's NSNull Class Reference

4. How do I test if a string is empty in Objective C?

Update - Test Result

My simple test result shows that the above two versions have different behaviors:

1. When aString is initialized and then assigned with nil:

   false for expression in version 1,

   true for expression in version 2.

2. When aString is initialized with the value of @"".

   false for expression in version 1,

   false for expression in version 2.

So it's clear that the two versions are not equivalent in their behavior.

The test code:

NSString *aString = nil;
NSString *bString = [NSString stringWithFormat:@""];

if ((NSString *)[NSNull null] == aString) {
    NSLog(@"a1 - true");
} else {
    NSLog(@"a1 - false");
}

if (nil == aString) {
    NSLog(@"a2 - true");
} else {
    NSLog(@"a2 - false");
}

if ((NSString *)[NSNull null] == bString) {
    NSLog(@"b1 - true");
} else {
    NSLog(@"b1 - false");
}

if (nil == bString) {
    NSLog(@"b2 - true");
} else {
    NSLog(@"b2 - false");
}

Console output:

2013-10-31 00:56:48.132 emptyproject[31104:70b] a1 - false
2013-10-31 00:56:48.133 emptyproject[31104:70b] a2 - true
2013-10-31 00:56:48.133 emptyproject[31104:70b] b1 - false
2013-10-31 00:56:48.133 emptyproject[31104:70b] b2 - false

Update - What Do I Mean "Empty string"**

Now I've made it clearer that it's different for a NSString object to be nil and for it to be a valid initialized instance holding an empty string value of @"". What I really need in this post is that how to test if my NSString object is successfully initialized, that is, if aString is nil. I want to know if there is any difference for the above two versions of test code.

Solution 1

[NSNull null] and nil are not equivalent. [NSNull null] is meant to represent the concept of NULL (as in no object) in cases where nil cannot be used, for example in an NSArray (as you can only insert objects in them). [NSNull null] is an object (always the same object), while nil is a pointer to 0.

NSHipster has a nice discussion here. He says:

NSNull is used throughout Foundation and other frameworks to skirt around the limitations of collections like NSArray and NSDictionary not being able to contain nil values. You can think of NSNull as effectively boxing the NULL or nil value so that it can be used in collections.

If you have:

NSString *aString;
if ( aString == (NSString *)[NSNull null] )
{
   // Logic handling
}

then something's wrong, aString should point to an NSString object (or subclass), or nil. But not [NSNull null] which is an object of a different class, you shouldn't cast from one to the other.

EDIT:

Given in the comments you state that you wish to check if the string is empty (as in @""), that is different. See this question. An empty string is an NSString object, it is not nil and it is not [NSNull null].

Solution 2

they are not the same, the NSNull is a valid object (inherited from NSObject) opposite a nil pointer, which points to nothing.

that is how you can check, whether an object is an NSNull object, but you first version is also okay.

id _object = // any kind of NSObject ...

if ([_object isKindOfClass:[NSNull class]]) {
   // Logic handling
}

Comments

[Sulthan]

A check == [NSNull null] is perfectly valid, too.

[George]

To @jbat100, now I've made it clearer that it's different for a NSString object to be nil and for it to have @"". So what I really need in the post is that how to test if my NSString object is successfully initialized, that is, if aString is nil.

[jbat100]

if (aString == nil) {//string is not initialized}

[jbat100]

if (aString != nil) {//string is initialized}

[newacct]

"then something's wrong" The "something wrong" could be laziness. Sometimes people put an object of uncertain class in the variable and check it later, to save having to introduce another variable.

[Nike Kov]

Maybe string.length > 0 ?