From the isKindOfClass: method documentation in NSObject:
Be careful when using this method on objects represented by a class cluster. Because of the nature of class clusters, the object you get back may not always be the type you expected.
The documentation then proceeds to give an example of why you should never ask something like the following of an NSArray instance:
// DO NOT DO THIS!
if ([myArray isKindOfClass:[NSMutableArray class]])
{
// Modify the object
}
Now to give an example of a different use, let's say I have an instance of NSObject where I would like to determine if I have an NSString or NSArray.
Both of these types are class clusters – but it seems from the documentation above that the danger lies in the answer to isKindOfClass: being too affirmative (answering YES sometimes when you really do not have a mutable array) whereas asking a question about simple membership in a cluster would still be valid.
An example:
NSObject *originalValue;
// originalValue gets set to some instance
if ( [originalValue isKindOfClass:[NSString class]] )
// Do something with string
Is this assumption correct? Is it really safe to use isKindOfClass: against class cluster instances to determine membership? I'm specifically interested in the answer for the omnipresent NSString, NSArray and NSDictionary but I'd be interested to know if it's generalizable.
Best Answer
The warning in the documentation uses the
NSMutableArray
example. Suppose some developer usesNSMutableArray
as base class for his own implementation of a new kind of arrayCoolFunctioningArray
. ThisCoolFunctioningArray
by design is not mutable. However,isKindOfClass
will returnYES
toisKindOfClass:[NSMutableArray class]
, which is true, but by design is not.isKindOfClass:
will returnYES
if the receiver somewhere inherits from the class passed as argument.isMemberOfClass:
will returnYES
only if the receiver is an instance of the class passed as argument only, i.e. not including subclasses.Generally
isKindOfClass:
is not safe to use to test for membership. If an instance returnsYES
forisKindOfClass:[NSString class]
, you know only that it will respond to all methods defined in theNSString
class, but you will not know for sure what the implementation of those methods might do. Someone might have subclassedNSString
to raise an exception for the length method.I think you could use
isKindOfClass:
for this kind of testing, especially if you're working with your own code which you (as a good Samaritan) designed in such a way it will respond in a way we all expect it to (e.g. the length method of anNSString
subclass to return the length of the string it represents instead of raising an exception). If you're using a lot of external libraries of weird developers (such as the developer of theCoolFunctioningArray
, which should be shot) you should use theisKindOfClass
method with caution, and preferably use theisMemberOfClass:
method (possibly multiple times to test membership of a group of classes).