Odpowiedź marca jest prawidłowa. Ale skorzystam z okazji, aby dołączyć wskaźnik do uogólnionego isEmpty Wila Shipleya, który podzielił się na swoim blogu :

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

Pierwsze podejście jest poprawne, ale nie działa, jeśli łańcuch znaków ma spacje (@" "). Musisz więc wyczyścić te białe spacje przed testowaniem.

Ten kod usuwa wszystkie puste spacje po obu stronach łańcucha:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Dobrym pomysłem jest stworzenie jednego makra, więc nie musisz wpisywać tej linii potwora:

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

Teraz możesz użyć:

NSString *emptyString = @"   ";

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

Jednym z najlepszych rozwiązań jakie kiedykolwiek widziałem (lepsze od Matta G) jest ta ulepszona funkcja inline, którą podłapałem na jakimś Git Hub repo (Wil Shipley ' s one, ale nie mogę znaleźć linku):

// Check if the "thing" pass'd 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);
}

Powinieneś lepiej użyć tej kategorii:

@implementation NSString (Empty)

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

@end

Po prostu Przekaż swój łańcuch do następującej metody:

+(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;
}

Dodałem to:

@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

Problem polega na tym, że jeśli self jest zerowy, funkcja ta nigdy nie jest wywoływana. Zwróci false, co jest pożądane.

Inną opcją jest sprawdzenie, czy jest ona równa @"" z isEqualToString: w ten sposób:

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

Wystarczy użyć jednego z if else warunki jak pokazano poniżej:

Metoda 1:

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

Metoda 2:

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

Wersja Swift

Mimo że jest to pytanie Objective C, musiałem użyć NSString w języku Swift, więc dołączę tutaj również odpowiedź.

let myNSString: NSString = ""

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

Lub jeśli NSString jest Opcjonalne:

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.")
    }
}

Normalna wersja Swift String to

let myString: String = ""

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

Zobacz także: Sprawdź pusty łańcuch w Swift?

Być może ta odpowiedź jest duplikatem już udzielonych odpowiedzi, ale zrobiłem kilka modyfikacji i zmian w kolejności sprawdzania warunków. Proszę zapoznać się z poniższym kodem:

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

Możesz sprawdzić, czy twój ciąg jest pusty lub nie mój za pomocą tej metody:

+(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;
}

Najlepszą praktyką jest, aby udostępniona Klasa mówiła UtilityClass i reklamowała tę metodę, abyś mógł użyć tej metody po prostu wywołując ją przez swoją aplikację.

Masz 2 metody, aby sprawdzić, czy łańcuch jest pusty, czy nie:

Załóżmy, że Twoja nazwa łańcucha to NSString *strIsEmpty.

Metoda 1:

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

else
{
    //String is not empty
}

Metoda 2:

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

else
{
    //String is not empty
}

Wybierz dowolną z powyższych metod i dowiedz się, czy string jest pusty czy nie.

Bardzo przydatny post, aby dodać wsparcie NSDictionary, a także jedną małą zmianę

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

Po prostu sprawdź długość łańcucha

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

Wiadomość do NIL zwróci nil lub 0, więc nie ma potrzeby testowania na nil :).

To działa jak urok dla mnie

Jeśli NSString jest s

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

    NSLog(@"s is empty");

} else {

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

}

Tak więc oprócz podstawowej koncepcji sprawdzania długości łańcucha poniżej 1, ważne jest, aby wziąć pod uwagę kontekst głęboko. Języki ludzkie, komputerowe lub inne mogą mieć różne definicje pustych ciągów i w tych samych językach dodatkowy kontekst może dodatkowo zmienić znaczenie.

Załóżmy, że pusty łańcuch oznacza "łańcuch, który nie zawiera żadnych znaków znaczących w bieżącym kontekście".

Może to oznaczać wizualnie, jak w kolorze i tle kolory są takie same w przypisanym ciągu. Skutecznie pusty.

Może to oznaczać brak znaczących znaków. Wszystkie kropki, myślniki lub podkreślenia mogą być uznane za puste. Co więcej, pusty znaczący znak może oznaczać ciąg znaków, który nie ma znaków, które czytelnik rozumie. Mogą to być znaki w języku lub zestawie znaków zdefiniowanym jako bez znaczenia dla czytelnika. Możemy zdefiniować to trochę inaczej, mówiąc, że ciągi znaków nie są znane słowa w danym język.

Możemy powiedzieć, że empty jest funkcją procentową przestrzeni ujemnej w wyrenderowanych glifach.

Nawet sekwencja znaków niedrukowalnych bez ogólnej reprezentacji wizualnej nie jest naprawdę pusta. Postacie sterujące przychodzą na myśl. Szczególnie niski zakres ASCII (dziwię się, że nikt o nich nie wspomniał, ponieważ podłączają wiele systemów i nie są białymi spacjami, ponieważ zwykle nie mają glifów ani metryk wizualnych). Jednak Długość łańcucha nie jest zerowa.

Wniosek. Sama długość nie jest tu jedyną miarą. Bardzo ważne jest również członkostwo w zestawach kontekstowych.

Skład zestawu znaków jest bardzo ważną, wspólną miarą dodatkową. Sekwencje znaczące są również dość powszechne. (think SETI or crypto or captchas ) Istnieją również dodatkowe, bardziej abstrakcyjne zbiory kontekstów.

Więc zastanów się dokładnie przed założeniem, że łańcuch jest pusty tylko na podstawie długości lub białych znaków.

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

Najlepszym sposobem jest użycie kategorii.
Możesz sprawdzić następującą funkcję. Który ma wszystkie warunki do sprawdzenia.

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

Najlepszym sposobem w każdym przypadku jest sprawdzenie długości danego ciągu.W tym przypadku, jeśli twój ciąg znaków jest mistring, to kod jest:

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

if (string.length == 0) stringIsEmpty;

Sprawdź to:

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

Lub

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

Możesz łatwo sprawdzić, czy łańcuch jest pusty za pomocą tego:

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

Sprawdziłem pusty łańcuch używając poniższego kodu:

//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"];  
}

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

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

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

Możesz mieć pusty łańcuch na dwa sposoby:

1) @"" // nie zawiera spacji

2) @" " // Contain Space

Technicznie oba łańcuchy są puste. Możemy napisać obie rzeczy po prostu używając jednego warunku

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

Spróbuj wykonać następujące czynności

NSString *stringToCheck = @"";

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

if( [txtMobile.text length] == 0 )
{
    [Utility showAlertWithTitleAndMessage: AMLocalizedString(@"Invalid Mobile No",nil) message: AMLocalizedString(@"Enter valid Mobile Number",nil)];
}