Related
So I've tested this, but just wanting to make sure it wasn't some random undefined behavior. I want to use the shorthand ternary on a dictionary but I want it to return a default value when it is not set. Here is the test I wrote:
NSMutableDictionary *test = [NSMutableDictionary new];
test[#"test_1"] = #NO;
test[#"test_2"] = #YES;
BOOL test1 = [test[#"test_1"] boolValue] ?: NO;
BOOL test2 = [test[#"test_2"] boolValue] ?: NO;
BOOL test3 = [test[#"test_3"] boolValue] ?: NO;
LogDebug(#"test1 = %#", (test1 ? #"YES" : #"NO"));
LogDebug(#"test2 = %#", (test2 ? #"YES" : #"NO"));
LogDebug(#"test3 = %#", (test3 ? #"YES" : #"NO"));
Now I got the correct value for test3, but I'm wondering whether thats just a random fluke of undefined behavior. I'm wondering this because when I checked for that value in the debugger by typing this in the console:
po [test[#"test_3"] boolValue]
I got:
error: no known method '-boolValue'; cast the message send to the method's return type
error: 1 errors parsing expression
Are the results of test3 reliable?
NSDictionary (and its subclass, NSMutableDictionary) is documented as returning nil for a key with no value.
In Objective-C, sending a message to nil is documented to return NO when you expect a BOOL result.
Therefore, if you want the default value to be NO, this suffices:
BOOL test3 = [test[#"test_3"] boolValue];
If you only intend to store NSString keys and NSNumber values (which #YES and #NO are) in the dictionary, you can declare it like this:
NSMutableDictionary<NSString *, NSNumber *> *test = [NSMutableDictionary new];
And then you can use a property accessor if you prefer:
BOOL test3 = test[#"test_3"].boolValue;
If you want a different default value (and the only other possibility for BOOL values is YES), then #trojanfoe's suggestion of creating a method is what I'd recommend, but I'd probably make a more general category on NSDictionary like this:
// NSDictionary+kailoon.h
#interface NSDictionary<KeyType, ObjectType> (kailoon)
- (ObjectType)kailoon_objectForKey:(KeyType)key default:(ObjectType)defaultObject;
#end
// NSDictionary+kailoon.m
#implementation NSDictionary (kailoon)
- (id)kailoon_objectForKey:(id)key default:(id)defaultObject {
id value = self[key];
return value ? value : defaultObject;
}
#end
Then I'd use it like this:
BOOL test3 = [test kailoon_objectForKey:#"test_3" default:#YES].boolValue;
As for your debugger problem, it's incorrect to use po to print a BOOL, because po means “print object” and a BOOL is not an object. (It is a primitive.) So you should just use p. But that's not really the problem here. To fix the “no known method” problem, you use a cast, like this:
(lldb) p (BOOL)[test[#"test_3"] boolValue]
(BOOL) $1 = NO
The output you are getting from your code is correct and defined.
First off, your code can be simplified to:
BOOL test1 = [test[#"test_1"] boolValue];
BOOL test2 = [test[#"test_2"] boolValue];
BOOL test3 = [test[#"test_3"] boolValue];
You will get NO for any key that doesn't exist. If test[#"some_nonexistent_key"] returns nil, calling boolValue on nil results in NO.
The debugger is just getting confused because it doesn't know what to do with the call to boolValue on nil since there are more than one possible boolValue methods (NSNumber and NSString).
That code is reliable, but only for booleans and only when the default value is NO, as non-existence of the value in the dictionary will give NO and hence the default value will be used.
However it's somewhat clumsy as:
[test[#"test_3"] boolValue] ?: NO;
is basing the result of the ternary expression on whether the boolean stored in the NSNumber is YES or NO, when what you want to know is is the value set in the dictionary?.
This is better:
BOOL test1 = test[#"test_1"] != nil ? [test[#"test_1"] boolValue] : NO;
and will use the default value only if the dictionary does not contain the specified key. This pattern can also be extended to other types and can also be used if the default value is YES.
Wrapped into a method (recommended), it would be the following (this code also checks the value type):
- (BOOL)boolForKey:(NSString *)key defaultValue:(BOOL)defaultValue
{
id value = self.dictionary[key];
return [value isKindOfClass:[NSNumber class]] ? [value boolValue] : defaultValue;
}
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
Difference among nil, Nil, and null
How to detect if NSString is null?
Apple's NSNull Class Reference
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:
When aString is initialized and then assigned with nil:
false for expression in version 1,
true for expression in version 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.
[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].
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
}
nil means nothing.
[NSNull null] is an object, instance of class NSNull
== means equality
something equals to something else is not the same as something is equal to nothing
[NSNull null] returns the singleton instance of NSNull.
aString == [NSNull null] compares two pointers. As long as aString does not point to the NSNull singleton, they will never be equal.
If you want to match a string to nil:
1. if(aString.length==0)
{
}
2.if(sString isEqualToString:#"")
{
}
3.if(aString!=nil)
{
} else
{
//do your stuff here
}
+(NSString*)replaceNullValuesWithEmptyString:(id)tempObj
{
if (([tempObj isKindOfClass:[NSNull class]])||
(tempObj == nil) ||
(tempObj == (id)[NSNull null])||
[tempObj isEqual:[NSNull null]] ||
[tempObj isEqual:nil]) {
}
else {
if([tempObj respondsToSelector:#selector(isEqualToString:)]) {
if ([tempObj isEqualToString:#"<null>"] ||
[tempObj isEqualToString:#"(null)"]) {
}
else {
if ([tempObj respondsToSelector:#selector(length)]) {
if ([tempObj length]>0) {
NSLog(#"Check Passed.");
return tempObj;
}
}
}
}
}
NSLog(#"Check failed.");
return #"";
}
I have the following code:
NSString *content = [[NSUserDefaults standardUserDefaults] stringForKey:#"mykey"];
NSLog(#"string is %#",content);
if ([content stringIsEmpty]){
NSLog(#"empty string");
}else{
NSLog(#"string is not empty");
}
stringIsEmpty is class category on NSString:
- (BOOL ) stringIsEmpty {
if ((NSNull *) self == [NSNull null]) {
return YES;
}
if (self == nil) {
return YES;
} else if ([self length] == 0) {
return YES;
}
return NO;
}
The output is:
string is (null)
string is not empty
How could it be null and not empty at the same time?
What happens is that:
[content stringIsEmpty:YES]
will return false (NO), when content is nil. So your code will take the
NSLog(#"string is not empty");
branch. This would be better:
if (content && [content stringIsEmpty:YES]){
...
A better way of doing this would be reversing the semantics of the method:
if ([content stringIsNotEmpty]) {
this would work finely because when content is nil it would return NO, when it is not nil, it would execute your method.
EDIT:
In Objective-C, sending a message to nil is legal and by definition will evaluate to nil. Google for "objective c sending message to nil".
In another language (C++), your code would crash (actually undefined behaviour, but to make things simple).
I use a small function to test for emptiness. It works on more than just strings:
static inline BOOL isEmpty(id thing) {
return thing == nil
|| ([thing respondsToSelector:#selector(length)]
&& [(NSData *)thing length] == 0)
|| ([thing respondsToSelector:#selector(count)]
&& [(NSArray *)thing count] == 0);
}
I usually import it in my pch file - you can see it along with attribution: https://gist.github.com/325926
As #sergio has already pointed out - when your string is nil you can't send it messages that test it for nil-ness - as sending messages to nil will do nothing for void methods, and return nil where the method returns something.
also
you are calling your method with a parameter
if ([content stringIsEmpty:YES])
but your method declaration doesn't take one:
- (BOOL ) stringIsEmpty {
What's that all about?
You have to check for the 'content == nil' case outside of the method.
If you want to be able to call just one method, change the method to something that tests for a positive, such as "stringHasContent", returning YES if self.length > 0.
I need to check if an dict has a key or not. How?
objectForKey will return nil if a key doesn't exist.
if ([[dictionary allKeys] containsObject:key]) {
// contains key
}
or
if ([dictionary objectForKey:key]) {
// contains object
}
More recent versions of Objective-C and Clang have a modern syntax for this:
if (myDictionary[myKey]) {
}
You do not have to check for equality with nil, because only non-nil Objective-C objects can be stored in dictionaries(or arrays). And all Objective-C objects are truthy values. Even #NO, #0, and [NSNull null] evaluate as true.
Edit: Swift is now a thing.
For Swift you would try something like the following
if let value = myDictionary[myKey] {
}
This syntax will only execute the if block if myKey is in the dict and if it is then the value is stored in the value variable. Note that this works for even falsey values like 0.
if ([mydict objectForKey:#"mykey"]) {
// key exists.
}
else
{
// ...
}
When using JSON dictionaries:
#define isNull(value) value == nil || [value isKindOfClass:[NSNull class]]
if( isNull( dict[#"my_key"] ) )
{
// do stuff
}
I like Fernandes' answer even though you ask for the obj twice.
This should also do (more or less the same as Martin's A).
id obj;
if ((obj=[dict objectForKey:#"blah"])) {
// use obj
} else {
// Do something else like creating the obj and add the kv pair to the dict
}
Martin's and this answer both work on iPad2 iOS 5.0.1 9A405
One very nasty gotcha which just wasted a bit of my time debugging - you may find yourself prompted by auto-complete to try using doesContain which seems to work.
Except, doesContain uses an id comparison instead of the hash comparison used by objectForKey so if you have a dictionary with string keys it will return NO to a doesContain.
NSMutableDictionary* keysByName = [[NSMutableDictionary alloc] init];
keysByName[#"fred"] = #1;
NSString* test = #"fred";
if ([keysByName objectForKey:test] != nil)
NSLog(#"\nit works for key lookups"); // OK
else
NSLog(#"\nsod it");
if (keysByName[test] != nil)
NSLog(#"\nit works for key lookups using indexed syntax"); // OK
else
NSLog(#"\nsod it");
if ([keysByName doesContain:#"fred"])
NSLog(#"\n doesContain works literally");
else
NSLog(#"\nsod it"); // this one fails because of id comparison used by doesContain
Using Swift, it would be:
if myDic[KEY] != nil {
// key exists
}
Yes. This kind of errors are very common and lead to app crash. So I use to add NSDictionary in each project as below:
//.h file code :
#interface NSDictionary (AppDictionary)
- (id)objectForKeyNotNull : (id)key;
#end
//.m file code is as below
#import "NSDictionary+WKDictionary.h"
#implementation NSDictionary (WKDictionary)
- (id)objectForKeyNotNull:(id)key {
id object = [self objectForKey:key];
if (object == [NSNull null])
return nil;
return object;
}
#end
In code you can use as below:
NSStrting *testString = [dict objectForKeyNotNull:#"blah"];
For checking existence of key in NSDictionary:
if([dictionary objectForKey:#"Replace your key here"] != nil)
NSLog(#"Key Exists");
else
NSLog(#"Key not Exists");
Because nil cannot be stored in Foundation data structures NSNull is sometimes to represent a nil. Because NSNull is a singleton object you can check to see if NSNull is the value stored in dictionary by using direct pointer comparison:
if ((NSNull *)[user objectForKey:#"myKey"] == [NSNull null]) { }
Solution for swift 4.2
So, if you just want to answer the question whether the dictionary contains the key, ask:
let keyExists = dict[key] != nil
If you want the value and you know the dictionary contains the key, say:
let val = dict[key]!
But if, as usually happens, you don't know it contains the key - you want to fetch it and use it, but only if it exists - then use something like if let:
if let val = dict[key] {
// now val is not nil and the Optional has been unwrapped, so use it
}
I'd suggest you store the result of the lookup in a temp variable, test if the temp variable is nil and then use it. That way you don't look the same object up twice:
id obj = [dict objectForKey:#"blah"];
if (obj) {
// use obj
} else {
// Do something else
}
if ([MyDictionary objectForKey:MyKey]) {
// "Key Exist"
}
As Adirael suggested objectForKey to check key existance but When you call objectForKeyin nullable dictionary, app gets crashed so I fixed this from following way.
- (instancetype)initWithDictionary:(NSDictionary*)dictionary {
id object = dictionary;
if (dictionary && (object != [NSNull null])) {
self.name = [dictionary objectForKey:#"name"];
self.age = [dictionary objectForKey:#"age"];
}
return self;
}
if ( [dictionary[#"data"][#"action"] isKindOfClass:NSNull.class ] ){
//do something if doesn't exist
}
This is for nested dictionary structure
I want to get the type of NSNumber instance.
I found out on http://www.cocoadev.com/index.pl?NSNumber this:
NSNumber *myNum = [[NSNumber alloc] initWithBool:TRUE];
if ([[myNum className] isEqualToString:#"NSCFNumber"]) {
// process NSNumber as integer
} else if ([[myNum className] isEqualToString:#"NSCFBoolean"]) {
// process NSNumber as boolean
}
Ok, but this doesn't work, the [myNum className] isn't recognized by the compiler.
I'm compiling for iPhone.
I recommend using the -[NSNumber objCType] method.
It allows you to do:
NSNumber * n = [NSNumber numberWithBool:YES];
if (strcmp([n objCType], #encode(BOOL)) == 0) {
NSLog(#"this is a bool");
} else if (strcmp([n objCType], #encode(int)) == 0) {
NSLog(#"this is an int");
}
For more information on type encodings, check out the Objective-C Runtime Reference.
You can get the type this way, no string comparisons needed:
CFNumberType numberType = CFNumberGetType((CFNumberRef)someNSNumber);
numberType will then be one of:
enum CFNumberType {
kCFNumberSInt8Type = 1,
kCFNumberSInt16Type = 2,
kCFNumberSInt32Type = 3,
kCFNumberSInt64Type = 4,
kCFNumberFloat32Type = 5,
kCFNumberFloat64Type = 6,
kCFNumberCharType = 7,
kCFNumberShortType = 8,
kCFNumberIntType = 9,
kCFNumberLongType = 10,
kCFNumberLongLongType = 11,
kCFNumberFloatType = 12,
kCFNumberDoubleType = 13,
kCFNumberCFIndexType = 14,
kCFNumberNSIntegerType = 15,
kCFNumberCGFloatType = 16,
kCFNumberMaxType = 16
};
typedef enum CFNumberType CFNumberType;
If all you want is to differentiate between booleans and anything else, you can make use of the fact that boolean NSNumbers always return a shared instance:
NSNumber *num = ...;
if (num == (void*)kCFBooleanFalse || num == (void*)kCFBooleanTrue) {
// num is boolean
} else {
// num is not boolean
}
NSNumber explicitly doesn't guarantee that the returned type will match the method used to create it, so doing this at all is probably a bad idea.
However, you could probably do something like this (you could also compare to objc_getClass("NSCFNumber") etc., but this is arguably more portable):
Class boolClass = [[NSNumber numberWithBool:YES] class];
/* ... */
if([myNum isKindOfClass:boolClass]) {
/* ... */
}
In Swift:
let numberType = CFNumberGetType(answer)
switch numberType {
case .charType:
//Bool
case .sInt8Type, .sInt16Type, .sInt32Type, .sInt64Type, .shortType, .intType, .longType, .longLongType, .cfIndexType, .nsIntegerType:
//Int
case .float32Type, .float64Type, .floatType, .doubleType, .cgFloatType:
//Double
}
Use the method -[NSNumber objCType] method to get the type.
If the type's equal to #encode(BOOL), or the number itself is kCFBooleanFalse, or kCFBooleanTrue, it's a boolean.
If it's anything else but 'c', it's a number.
If it's 'c', what appears to be the only way supported way, without checking against private class names, or comparing against undocumented singletons, is to turn make an array of one element, the number, and then use NSJSONSerialization to get the string representation. Finally, check if the string representation contains the string "true" or "false". Here is the full code for checking if an NSNumber is a BOOL:
-(BOOL)isBool
{
if(!strcmp(self.objCType, #encode(BOOL)) ||
self == (void*)kCFBooleanFalse ||
self == (void*)kCFBooleanTrue)
{
return YES;
}
if(strcmp(self.objCType, "c"))
{
return NO;
}
NSString * asString = [[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:#[self] options:kNilOptions error:nil] encoding:NSUTF8StringEncoding];
return [asString containsString:#"true"] || [asString containsString:#"false"];
}
Note that using NSJSONSerialization is slow and if #NO/#YES ever stops always equalling kCFBooleanFalse/kCFBooleanTrue, then this method probably shouldn't be used in a tight loop.
The reason the compiler warns you and it doesn't work is because -[NSObject className] is declared in a category on NSObject on Mac OS X (in NSScriptClassDescription.h) and not declared on iPhone. (It doesn't support AppleScript, obviously.) NSStringFromClass([myNum class]) is what you should use to be safe across all platforms. Odds are that -className is declared as a simple wrapper around NSStringFromClass() anyway...
NSString *classString = NSStringFromClass([myNum class]);
That should ger the string you want.
To check that NSNumber contains a bool value Try this:
if (strcmp([myNumber objCType], [#(YES) objCType]) == 0)
NSLog(#"%#", [myNumber boolValue] ? #"true" : #"false");
objCType documentation states that The returned type does not necessarily match the method the number object was created with
Secondly, other methods of comparing the class of number to a given class type or assuming boolean number instances to be shared singletons are not documented behaviour.
A more(not completely though) reliable way is to depend on NSJSONSerialisation as it correctly recognises number instances created with bool and outputs true/false in json. This is something we can expect Apple to take care of while moving with new SDKs and on different architectures. Below is the code:
+(BOOL) isBoolType:(NSNumber*) number {
NSError* err;
NSData* jsonData = [NSJSONSerialization dataWithJSONObject:#{#"key":number}
options:0
error:&err];
NSString* jsonString = [[NSString alloc]
initWithData:jsonData
encoding:NSUTF8StringEncoding];
return [jsonString containsString:#"true"]
|| [jsonString containsString:#"false"];
}
Swift Version
NSNumber is a class-cluster so each underlying type can be figured from the instance. This code avoids hard-coding the different NSNumber types by creating an instance of the expected type, and then comparing it against the unknown type.
extension NSNumber {
var isBool: Bool {
return type(of: self) == type(of: NSNumber(booleanLiteral: true))
}
}
check object is of NSNumber type :
if([obj isKindOfClass:NSClassFromString(#"__NSCFNumber")])
{
//NSNumber
}