Jak sprawdzić, czy NSStringw Objective-C jest pusty?

Możesz sprawdzić, czy [string length] == 0. Spowoduje to sprawdzenie, czy jest to poprawny, ale pusty ciąg (@ ""), a także czy jest zerowy, ponieważ wywołanie lengthzerowego zwróci również 0.

Odpowiedź Marca jest poprawna. Ale skorzystam z okazji, aby dołączyć wskaźnik do uogólnionego Wila ShipleyaisEmpty , który udostępnił 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 zawiera puste spacje ( @" "). Więc musisz wyczyścić te białe przestrzenie przed przetestowaniem.

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

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Jednym dobrym pomysłem jest utworzenie jednego makra, więc nie musisz wpisywać tej linii potworów:

#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 (lepszym niż Matt G), jest ta ulepszona funkcja wbudowana, którą wybrałem w niektórych repozytoriach Git Hub (jedno Wil Wadley, ale nie mogę znaleźć linku):

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

Lepiej skorzystaj z tej kategorii:

@implementation NSString (Empty)

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

@end

Kładę 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 zero, funkcja ta nigdy nie jest wywoływana. Zwróci false, co jest pożądane.

Inną opcją jest sprawdzenie, czy jest równe @""z isEqualToString:podobnym:

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

Po prostu przekaż swój ciąg 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;
}

Wystarczy użyć jednego z poniższych if elsewarunków:

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
}

Szybka wersja

Mimo że jest to pytanie Celu C, musiałem użyć go NSStringw Swift, więc w tym miejscu również zamieszczę odpowiedź.

let myNSString: NSString = ""

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

Lub jeśli NSStringjest opcjonalny:

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 Stringwersja Swift to

let myString: String = ""

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

Zobacz także: Sprawdź pusty ciąg znaków 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ę odnieść się do poniższego kodu:

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

Za pomocą tej metody możesz sprawdzić, czy Twój łańcuch jest pusty, czy nie.

+(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 wspólna klasa mówiła UtilityClass i reklamowała tę metodę, abyś mógł skorzystać z tej metody, po prostu wywołując ją w aplikacji.

Masz 2 metody sprawdzenia, czy ciąg 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 ciąg znaków jest pusty, czy nie.

Wystarczy sprawdzić długość sznurka

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

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

Miłego kodowania ...

Działa jak dla mnie urok

Jeśli tak NSStringjests

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

    NSLog(@"s is empty");

} else {

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

}

Poza podstawową koncepcją sprawdzania długości łańcucha mniejszej niż 1, ważne jest głębokie rozważenie kontekstu. Języki ludzkie lub komputerowe lub w inny sposób mogą mieć różne definicje pustych ciągów znaków i w tych samych językach dodatkowy kontekst może dodatkowo zmienić znaczenie.

Powiedzmy, że pusty ciąg oznacza „ciąg, który nie zawiera żadnych znaczących znaków w bieżącym kontekście”.

Może to oznaczać wizualnie, ponieważ kolor i kolor tła są takie same w przypisywanym ciągu. Skutecznie pusty.

Może to oznaczać brak znaczących znaków. Wszystkie kropki, wszystkie myślniki lub wszystkie podkreślenia można uznać za puste. Ponadto brak znaczących znaczących znaków może oznaczać ciąg, który nie zawiera znaków, które czytelnik rozumie. Mogą to być znaki w języku lub zestawie znaków zdefiniowane jako nieistotne dla czytelnika. Moglibyśmy zdefiniować to nieco inaczej, mówiąc, że ciąg znaków nie zna znanych słów w danym języku.

Można powiedzieć, że pusty jest funkcją procentu ujemnej przestrzeni w renderowanych glifach.

Nawet ciąg znaków niedrukowalnych bez ogólnej reprezentacji wizualnej nie jest naprawdę pusty. Przychodzą mi na myśl postacie kontrolne. Zwłaszcza niski zakres ASCII (dziwię się, że nikt nie wspomniał o nich, ponieważ łączą wiele systemów i nie są spacjami, ponieważ zwykle nie mają glifów ani wskaźników wizualnych). Jednak długość łańcucha nie jest równa zero.

Wniosek. Sama długość nie jest tu jedyną miarą. Przynależność do zestawu kontekstowego jest również bardzo ważna.

Członkostwo w zestawie znaków jest bardzo ważnym wspólnym dodatkowym środkiem. Znaczące sekwencje są również dość powszechne. (pomyśl SETI lub krypto lub captchas) Istnieją również dodatkowe abstrakcyjne zestawy kontekstów.

Zastanów się więc, zanim łańcuch będzie pusty tylko na podstawie długości lub białych znaków.

Bardzo przydatny post, aby dodać obsługę 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);
}

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

W każdym przypadku najlepszym sposobem jest sprawdzenie długości podanego ciągu. W tym przypadku, jeśli ciąg ma ciąg myString, kod jest następujący:

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

Mam nadzieję, że to pomoże.

Za pomocą tego możesz łatwo sprawdzić, czy ciąg znaków jest pusty:

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

Sprawdziłem pusty ciąg za pomocą 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"];  
}

To tak proste jak if([myString isEqual:@""])lubif([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;
}

Możesz mieć pusty ciąg na dwa sposoby:

1) @ "" // Nie zawiera spacji

2) @ "" // Zawiera spację

Technicznie oba ciągi są puste. Obie rzeczy możemy napisać tylko za pomocą 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(str.length == 0 || [str isKindOfClass: [NSNull class]]){
    NSLog(@"String is empty");
}
else{
    NSLog(@"String is not empty");
}    

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