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

Question

How do I test if an NSString is empty in Objective-C?

Smitten

Answer 1

You can check if [string length] == 0. This will check if it's a valid but empty string (@"") as well as if it's nil, since calling length on nil will also return 0.

Southdown

There are some very rare NSStrings where this will result in a false negative (saying the string isn't empty, when, for practical purposes, it is). Consider @"\u200B" (consisting only of Unicode character ZERO WIDTH SPACE. Printing it out will print 0 characters (verify using monospaced font), but string.length will give 1. There are other Unicode characters (like OBJECT REPLACEMENT CHARACTER) which behave likewise. You may get the latter when parsing PDF text. – Stirring

@Stirring not to be an arse, but in theory it doesn't give a false negative. It behaves exactly as you'd expect. Your interpretation of what ZERO WIDTH SPACE is doesn't really matter, because @"\u200B" is a character nonetheless so if you test for the string to be empty, it will say it isn't because there is a character in it. It's just not printable following the Unicode standard. – Plott

Of course it is technically correct, I'm not debating that. I just want to caution that this may not exhibit the intended or expected behavior, which is why I wrote "for practical purposes". It depends on the intended meaning of "empty". – Stirring

It's not a false negative. A "zero worth space" is a unicode character like any other. It's just "worth remembering" if relevant to your app. (Great thinking, fzwo!) – Idette

I have a string that looks to be set to "". When I call the length method it returns nil not zero. So this check is failing for me in iOS 7. – Disdain

@Disdain nil and zero are the same value. This approach is still applicable in iOS7. – Leavenworth

Let me know if I'm wrong, but I think you could also omit == 0 part and add a negation in front: ![string length]. Seems more clean. – Ill

@Ill That may be less characters, but it is also less readable. if ([string length] == 0) would be read as "if string length is zero", while if (![string length]) would be read as "if not string length". If someone who is unfamiliar with that code reads it, the second choice would take longer to understand. – Payload

@Payload I agree! 8 months later I actually like if (string.length == 0) the most. – Ill

This will fail if the string is NULL as you cannot call length on NULL. – Markettamarkey

This doesn't work if the string is NSNull *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[NSNull length]: unrecognized selector sent to instance 0x10c252f28' – Consent

Answer 2

Marc's answer is correct. But I'll take this opportunity to include a pointer to Wil Shipley's generalized isEmpty, which he shared on his blog:

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);
}

Diaper

If you want this to be very generalized, one could implement this logic as a category on NSObject instead of using a static method as shown here. – Painful

Oddly, this does not actually check for [NSNull null]. – Contracted

If you are in a situation where you don't know what type of object you are checking, I guess this works. However I suggest that if you don't know whether an object is NSData or NSArray, you have bigger problems. What's your next macro going to be after this call, condenseToSingleNSData(id thing)? expandToNSArray(id thing)? Sooner or later, you will be asking what kind of class you're dealing with, better to do it on first reference. – Disoperation

@Disoperation Good point, but not the point of the generalized function. The generality makes it possible to have a single function for use no matter what class thing is--that is, when you know what class it is already, but don't want to bother with creating a separate function for it. – Amino

isEmpty is the master. – Intervenient

@BradSmith, one could create a category for it but nil values would not be counted since the method would not be called. For instance, if thing = nil, [thing IsEmpty] would not be called and would always return false/NO. To check for nil, there needs to be a parameter. Nil objects cannot compare themselves as nil via a category. – Sonni

@chris then you can change the category method to -isNotEmpty :) – Germin

Answer 3

The first approach is valid, but doesn't work if your string has blank spaces (@" "). So you must clear this white spaces before testing it.

This code clear all the blank spaces on both sides of the string:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

One good idea is create one macro, so you don't have to type this monster line:

#define allTrim( object ) [object stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ]

Now you can use:

NSString *emptyString = @"   ";

if ( [allTrim( emptyString ) length] == 0 ) NSLog(@"Is empty!");

Piecedyed

Why use macros when they are not necessary? In this case any sort type safety is sacrificed for no real benefit. – Valero

Is for simple convenience, if you like to write "[object stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ]" everytime you want to check if one string is empty, is up to you. – Piecedyed

that would better be served by an NSString category that adds a method called trimmedString that does exactly what you wrote. – Weeper

Note that Apple's whitespaceCharacterSet does not include newlines! Here's a category I wrote including trim and some other useful methods: github.com/alexch/unsuck/blob/master/unsuck/NSString%2BUnsuck.m github.com/alexch/unsuck/blob/master/unsuckTests/… – Selfmoving

@Valero I'm not a fan of macros, but i don't understand your type-safety concern. During compilation the macro is replaced with its contents so if you invoke the macro with something different from a NSString you still get a message from the compiler. Categories would be far better anyway. – Hannover

Answer 4

One of the best solution I ever seen (better than Matt G's one) is this improved inline function I picked up on some Git Hub repo (Wil Shipley's one, but I can't find the link) :

// Check if the "thing" passed is empty
static inline BOOL isEmpty(id thing) {
    return thing == nil
    || [thing isKindOfClass:[NSNull class]]
    || ([thing respondsToSelector:@selector(length)]
        && [(NSData *)thing length] == 0)
    || ([thing respondsToSelector:@selector(count)]
        && [(NSArray *)thing count] == 0);
}

Escutcheon

This is Wil Shipley's work. FYI, you can change [thing isKindOfClass:[NSNull class]] to just (thing == [NSNull null]) – Steamtight

Phew.... exactly what I was looking for. I was going mad, trying to work out why my "cellForRowAtIndexPath" function was crashing due to null strings (and I couldn't catch the problem). This function solved it perfectly. – Torhert

Copy of @Disoperation comment: If you are in a situation where you don't know what type of object you are checking, I guess this works. However I suggest that if you don't know whether an object is NSData or NSArray, you have bigger problems. What's your next macro going to be after this call, condenseToSingleNSData(id thing)? expandToNSArray(id thing)? Sooner or later, you will be asking what kind of class you're dealing with, better to do it on first reference. – Gallard

Answer 5

You should better use this category:

@implementation NSString (Empty)

    - (BOOL) isWhitespace{
        return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]length] == 0);
    }

@end

Gosney

That definition would conlude that the string " /r/n /r/n" is empty, when it clearly is not - it contains whitespace. Your function is really: -(BOOL)isWhitespace(NSString*); – Singles

A corollary to this. I implemented this category, and there is a twist. If you call this on a nil string, this function is never called, and you get back a NO(or what evaluates to NO) as a return value. Then you think it's not empty...This might work if the name was isFilled or something like that. – Munafo

I guess the right category would then be: @implementation NSString (Empty) - (BOOL) empty{ return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]length] == 0); } @end As a combination of Marc's and Kyle's answer. – Florie

Answer 6

Another option is to check if it is equal to @"" with isEqualToString: like so:

if ([myString isEqualToString:@""]) {
    NSLog(@"myString IS empty!");
} else {
    NSLog(@"myString IS NOT empty, it is: %@", myString);
}

Camey

Answer 7

I put this:

@implementation NSObject (AdditionalMethod)
-(BOOL) isNotEmpty
{
    return !(self == nil
    || [self isKindOfClass:[NSNull class]]
    || ([self respondsToSelector:@selector(length)]
        && [(NSData *)self length] == 0)
    || ([self respondsToSelector:@selector(count)]
        && [(NSArray *)self count] == 0));

};
@end

The problem is that if self is nil, this function is never called. It'll return false, which is desired.

Sampling

best solution since a) is instance method and b) category c) nil case on itself is handle by 'isNotEmpty' Thx! – Braud

Great idea, just too bad -(BOOL)isEmpty{ return ![self isNotEmpty]} won't work on category. – Satem

Copy of @Disoperation comment: If you are in a situation where you don't know what type of object you are checking, I guess this works. However I suggest that if you don't know whether an object is NSData or NSArray, you have bigger problems. What's your next macro going to be after this call, condenseToSingleNSData(id thing)? expandToNSArray(id thing)? Sooner or later, you will be asking what kind of class you're dealing with, better to do it on first reference. – Gallard

Answer 8

Just pass your string to following method:

+(BOOL)isEmpty:(NSString *)str
{
    if(str.length==0 || [str isKindOfClass:[NSNull class]] || [str isEqualToString:@""]||[str  isEqualToString:NULL]||[str isEqualToString:@"(null)"]||str==nil || [str isEqualToString:@"<null>"]){
        return YES;
    }
    return NO;
}

Alabama

Check out the comments on #21605575 to why this is wrong. Also how is this better then the other answers on here. – Rubicund

Answer 9

May be this answer is the duplicate of already given answers, but i did few modification and changes in the order of checking the conditions. Please refer the below code:

+(BOOL)isStringEmpty:(NSString *)str {
     if(str == nil || [str isKindOfClass:[NSNull class]] || str.length==0) {
            return YES;
       }
      return NO;
  }

Meridith

This is a category, you can see how to create it here: goo.gl/bRcfn7. I like the idea of a category for this – Dashing

No, we can not say this is category. If this function is implemented under the category of NSString class, then it is category. Otherwise we can call this method with the name of class wherever we implemented it. Like Bool isEmptyStr = [MyClassName isStringEmpty:str] But still, It will be more good if we will declare it under category. Because somehow we need to take the advantage of categories also. – Meridith

Answer 10

Swift Version

Even though this is an Objective C question, I needed to use NSString in Swift so I will also include an answer here.

let myNSString: NSString = ""

if myNSString.length == 0 {
    print("String is empty.")
}

Or if NSString is an Optional:

var myOptionalNSString: NSString? = nil

if myOptionalNSString == nil || myOptionalNSString!.length == 0 {
    print("String is empty.")
}

// or alternatively...
if let myString = myOptionalNSString {
    if myString.length != 0 {
        print("String is not empty.")
    }
}

The normal Swift String version is

let myString: String = ""

if myString.isEmpty {
    print("String is empty.")
}

See also: Check empty string in Swift?

Carn

Answer 11

Simply Check your string length

 if (!yourString.length)
 {
   //your code  
 }

a message to NIL will return nil or 0, so no need to test for nil :).

Happy coding ...

Kelila

I have used this so many times. Absolutely no need for extensions, categories and what not. – Incomplete

Answer 12

Just use one of the if else conditions as shown below:

Method 1:

if ([yourString isEqualToString:@""]) {
        // yourString is empty.
    } else {
        // yourString has some text on it.
    }

Method 2:

if ([yourString length] == 0) {
    // Empty yourString
} else {
    // yourString is not empty
}

Gentle

Answer 13

You can check either your string is empty or not my using this method:

+(BOOL) isEmptyString : (NSString *)string
{
    if([string length] == 0 || [string isKindOfClass:[NSNull class]] || 
       [string isEqualToString:@""]||[string  isEqualToString:NULL]  ||
       string == nil)
     {
        return YES;         //IF String Is An Empty String
     }
    return NO;
}

Best practice is to make a shared class say UtilityClass and ad this method so that you would be able to use this method by just calling it through out your application.

Catchpole

Answer 14

You have 2 methods to check whether the string is empty or not:

Let's suppose your string name is NSString *strIsEmpty.

Method 1:

if(strIsEmpty.length==0)
{
    //String is empty
}

else
{
    //String is not empty
}

Method 2:

if([strIsEmpty isEqualToString:@""])
{
    //String is empty
}

else
{
    //String is not empty
}

Choose any of the above method and get to know whether string is empty or not.

Domineering

Answer 15

Very useful post, to add NSDictionary support as well one small change

static inline BOOL isEmpty(id thing) {
    return thing == nil
    || [thing isKindOfClass:[NSNull class]]
    || ([thing respondsToSelector:@selector(length)]
        && ![thing respondsToSelector:@selector(count)]
        && [(NSData *)thing length] == 0)
    || ([thing respondsToSelector:@selector(count)]
        && [thing count] == 0);
}

Cornetcy

Copy of @Disoperation comment: If you are in a situation where you don't know what type of object you are checking, I guess this works. However I suggest that if you don't know whether an object is NSData or NSDictionary, you have bigger problems. What's your next macro going to be after this call, condenseToSingleNSData(id thing)? expandToNSArray(id thing)? Sooner or later, you will be asking what kind of class you're dealing with, better to do it on first reference. – Gallard

Answer 16

It is working as charm for me

If the NSString is s

if ([s isKindOfClass:[NSNull class]] || s == nil || [s isEqualToString:@""]) {

    NSLog(@"s is empty");

} else {

    NSLog(@"s containing %@", s);

}

Viniculture

Answer 17

So aside from the basic concept of checking for a string length less than 1, it is important to consider context deeply. Languages human or computer or otherwise might have different definitions of empty strings and within those same languages, additional context may further change the meaning.

Let's say empty string means "a string which does not contain any characters significant in the current context".

This could mean visually, as in color and background color are same in an attributed string. Effectively empty.

This could mean empty of meaningful characters. All dots or all dashes or all underscores might be considered empty. Further, empty of meaningful significant characters could mean a string that has no characters the reader understands. They could be characters in a language or characterSet defined as meaningless to the reader. We could define it a little differently to say the string forms no known words in a given language.

We could say empty is a function of the percentage of negative space in the glyphs rendered.

Even a sequence of non printable characters with no general visual representation is not truly empty. Control characters come to mind. Especially the low ASCII range (I'm surprised nobody mentioned those as they hose lots of systems and are not whitespace as they normally have no glyphs and no visual metrics). Yet the string length is not zero.

Conclusion. Length alone is not the only measure here. Contextual set membership is also pretty important.

Character Set membership is a very important common additional measure. Meaningful sequences are also a fairly common one. ( think SETI or crypto or captchas ) Additional more abstract context sets also exist.

So think carefully before assuming a string is only empty based on length or whitespace.

Lambertson

Answer 18

- (BOOL)isEmpty:(NSString *)string{
    if ((NSNull *) string == [NSNull null]) {
        return YES;
    }
    if (string == nil) {
        return YES;
    }
    if ([string length] == 0) {
        return YES;
    }
    if ([[string stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceAndNewlineCharacterSet]] length] == 0) {
        return YES;
    }
    if([[string stringByStrippingWhitespace] isEqualToString:@""]){
        return YES;
    }
    return NO;
}

Halutz

First three conditions are redundant, and you haven't included the source for stringByStrippingWhitespace – Midshipman

Answer 19

The best way is to use the category.
You can check the following function. Which has all the conditions to check.

-(BOOL)isNullString:(NSString *)aStr{
        if([(NSNull *)aStr isKindOfClass:[NSNull class]]){
            return YES;
        }
        if ((NSNull *)aStr  == [NSNull null]) {
            return YES;
        }
        if ([aStr isKindOfClass:[NSNull class]]){
            return YES;
        }
        if(![[aStr stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] length]){
            return YES;
        }
        return NO;
    }

Interpleader

Answer 20

I have checked an empty string using below code :

//Check if we have any search terms in the search dictionary.
if( (strMyString.text==(id) [NSNull null] || [strMyString.text length]==0 
       || strMyString.text isEqual:@"")) {

   [AlertView showAlert:@"Please enter a valid string"];  
}

Ritual

Answer 21

The best way in any case is to check the length of the given string.For this if your string is myString then the code is:

    int len = [myString length];
    if(len == 0){
       NSLog(@"String is empty");
    }
    else{
      NSLog(@"String is : %@", myString);
    }

Doucette

Answer 22

if (string.length == 0) stringIsEmpty;

Polk

Answer 23

check this :

if ([yourString isEqualToString:@""])
{
    NsLog(@"Blank String");
}

Or

if ([yourString length] == 0)
{
    NsLog(@"Blank String");
}

Hope this will help.

Nitrification

Answer 24

You can easily check if string is empty with this:

if ([yourstring isEqualToString:@""]) {
    // execute your action here if string is empty
}

Proprietress

Answer 25

Its as simple as if([myString isEqual:@""]) or if([myString isEqualToString:@""])

Less

Answer 26

//Different validations:
 NSString * inputStr = @"Hey ";

//Check length
[inputStr length]

//Coming from server, check if its NSNull
[inputStr isEqual:[NSNull null]] ? nil : inputStr

//For validation in allowed character set
-(BOOL)validateString:(NSString*)inputStr
{
    BOOL isValid = NO;
    if(!([inputStr length]>0))
    {
        return isValid;

    }

    NSMutableCharacterSet *allowedSet = [NSMutableCharacterSet characterSetWithCharactersInString:@".-"];
    [allowedSet formUnionWithCharacterSet:[NSCharacterSet decimalDigitCharacterSet]];
    if ([inputStr rangeOfCharacterFromSet:[allowedSet invertedSet]].location == NSNotFound)
    {
        // contains only decimal set and '-' and '.'

    }
    else
    {
        // invalid
        isValid = NO;

    }
    return isValid;
}

Haga

Answer 27

You can have an empty string in two ways:

1) @"" // Does not contain space

2) @" " // Contain Space

Technically both the strings are empty. We can write both the things just by using ONE Condition

if ([firstNameTF.text stringByReplacingOccurrencesOfString:@" " withString:@""].length==0)
{
    NSLog(@"Empty String");
}
else
{
    NSLog(@"String contains some value");
}

Altazimuth

Answer 28

Try the following

NSString *stringToCheck = @"";

if ([stringToCheck isEqualToString:@""])
{
   NSLog(@"String Empty");
}
else
{
   NSLog(@"String Not Empty");
}

Stipple

Answer 29

Based on multiple answers I have created a ready to use category combining @iDevAmit and @user238824 answers.

Specifically it goes in the following order

1. Check for null/nil
2. Check if if string is empty using it's length count.
3. Check if string is white spaces.

Header

//
//  NSString+Empty.h

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface NSString (Empty)
- (BOOL)isEmptyOrWhiteSpacesOrNil;
@end

NS_ASSUME_NONNULL_END

Implementation

//
//  NSString+Empty.m

#import "NSString+Empty.h"

@implementation NSString (Empty)

- (BOOL) isWhitespace{
      return ([[self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]length] == 0);
  }

- (BOOL)isEmptyOrWhiteSpacesOrNil {
     if(self == nil || [self isKindOfClass:[NSNull class]] || self.length==0 || [self isWhitespace] == YES) {
            return YES;
       }
      return NO;
  }

@end

/*
 Credits
 1. https://mcmap.net/q/56154/-how-do-i-test-if-a-string-is-empty-in-objective-c
 2. https://mcmap.net/q/56154/-how-do-i-test-if-a-string-is-empty-in-objective-c
 */

Usage: of-course the function will never be triggered if your string is null. Case one is there just for extra security. I advice checking for nullability before attempting to use this method.

if (myString) {
  if [myString isEmptyOrWhiteSpacesOrNil] {
     // String is empty
  }
} else {
// String is null
}

Destructive

Answer 30

if(str.length == 0 || [str isKindOfClass: [NSNull class]]){
    NSLog(@"String is empty");
}
else{
    NSLog(@"String is not empty");
}    

Dumpish

The null check must be first. str.length will throw an exception if str is null. – Illaudable