Wie teste ich, ob ein NSStringin Objective-C leer ist?

Sie können überprüfen, ob [string length] == 0. Dies prüft, ob es sich um eine gültige, aber leere Zeichenfolge (@ "") handelt und ob es sich um Null handelt, da der Aufruf lengthvon Null ebenfalls 0 zurückgibt.

Marc's Antwort ist richtig. Aber ich werde diese Gelegenheit nutzen, um einen Hinweis auf Wil Shipleys Verallgemeinerung aufzunehmen isEmpty, den er in seinem Blog geteilt hat :

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

Der erste Ansatz ist gültig, funktioniert jedoch nicht, wenn Ihre Zeichenfolge Leerzeichen enthält ( @" "). Sie müssen diese Leerzeichen also löschen, bevor Sie sie testen.

Dieser Code löscht alle Leerzeichen auf beiden Seiten der Zeichenfolge:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Eine gute Idee ist es, ein Makro zu erstellen, damit Sie diese Monsterzeile nicht eingeben müssen:

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

Jetzt können Sie verwenden:

NSString *emptyString = @"   ";

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

Eine der besten Lösungen, die ich je gesehen habe (besser als die von Matt G), ist diese verbesserte Inline-Funktion, die ich bei einem Git Hub-Repo (Wil Shipleys, aber ich kann den Link nicht finden) übernommen habe:

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

Sie sollten diese Kategorie besser verwenden:

@implementation NSString (Empty)

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

@end

Ich sage das:

@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

Das Problem ist, dass diese Funktion niemals aufgerufen wird, wenn self null ist. Es wird false zurückgegeben, was erwünscht ist.

Eine andere Möglichkeit besteht darin, zu überprüfen, ob es @""mit isEqualToString:like so gleich ist:

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

Übergeben Sie einfach Ihren String an folgende Methode:

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

Verwenden Sie einfach eine der folgenden if elseBedingungen:

Methode 1:

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

Methode 2:

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

Schnelle Version

Obwohl dies eine objektive C-Frage ist, musste ich sie NSStringin Swift verwenden, damit ich hier auch eine Antwort einfügen kann.

let myNSString: NSString = ""

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

Oder wenn NSStringist eine Option:

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

Die normale Swift- StringVersion ist

let myString: String = ""

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

Siehe auch: Leere Zeichenfolge in Swift prüfen?

Vielleicht ist diese Antwort das Duplikat der bereits gegebenen Antworten, aber ich habe nur wenige Modifikationen und Änderungen in der Reihenfolge der Überprüfung der Bedingungen vorgenommen. Bitte beachten Sie den folgenden Code:

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

Mit dieser Methode können Sie überprüfen, ob Ihre Zeichenfolge leer ist oder nicht:

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

Es wird empfohlen, eine gemeinsam genutzte Klasse UtilityClass zu verwenden und diese Methode hinzuzufügen, damit Sie diese Methode verwenden können, indem Sie sie einfach in Ihrer Anwendung aufrufen.

Sie haben zwei Methoden, um zu überprüfen, ob die Zeichenfolge leer ist oder nicht:

Angenommen, Ihr String-Name lautet NSString *strIsEmpty.

Methode 1:

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

else
{
    //String is not empty
}

Methode 2:

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

else
{
    //String is not empty
}

Wählen Sie eine der oben genannten Methoden und erfahren Sie, ob die Zeichenfolge leer ist oder nicht.

Überprüfen Sie einfach Ihre Saitenlänge

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

Eine Nachricht an NIL gibt nil oder 0 zurück, sodass Sie nicht auf nil testen müssen :).

Viel Spaß beim Codieren ...

Es wirkt als Zauber für mich

Wenn das NSStringists

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

    NSLog(@"s is empty");

} else {

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

}

Abgesehen von dem Grundkonzept der Überprüfung auf eine Zeichenfolgenlänge von weniger als 1 ist es daher wichtig, den Kontext gründlich zu berücksichtigen. Sprachen, die menschlich oder computergestützt sind oder auf andere Weise unterschiedliche Definitionen für leere Zeichenfolgen haben, und innerhalb derselben Sprachen kann ein zusätzlicher Kontext die Bedeutung weiter ändern.

Angenommen, eine leere Zeichenfolge bedeutet "eine Zeichenfolge, die im aktuellen Kontext keine signifikanten Zeichen enthält".

Dies kann visuell bedeuten, da Farbe und Hintergrundfarbe in einer zugeordneten Zeichenfolge gleich sind. Effektiv leer.

Dies könnte bedeuten, dass keine aussagekräftigen Zeichen mehr vorhanden sind. Alle Punkte oder alle Striche oder alle Unterstriche können als leer betrachtet werden. Darüber hinaus kann ein Leerzeichen ohne aussagekräftige signifikante Zeichen eine Zeichenfolge bedeuten, die keine Zeichen enthält, die der Leser versteht. Dies können Zeichen in einer Sprache oder einem Zeichensatz sein, die für den Leser als bedeutungslos definiert sind. Wir könnten es etwas anders definieren, zu sagen, dass die Zeichenfolge in einer bestimmten Sprache keine bekannten Wörter bildet.

Wir könnten sagen, leer ist eine Funktion des Prozentsatzes des negativen Raums in den gerenderten Glyphen.

Selbst eine Folge nicht druckbarer Zeichen ohne allgemeine visuelle Darstellung ist nicht wirklich leer. Steuerzeichen kommen mir in den Sinn. Besonders der niedrige ASCII-Bereich (ich bin überrascht, dass niemand diese erwähnt hat, da sie viele Systeme abspritzen und keine Leerzeichen sind, da sie normalerweise keine Glyphen und keine visuellen Metriken haben). Die Stringlänge ist jedoch nicht Null.

Fazit. Länge allein ist hier nicht das einzige Maß. Die kontextbezogene Mitgliedschaft ist auch ziemlich wichtig.

Die Mitgliedschaft im Zeichensatz ist eine sehr wichtige allgemeine zusätzliche Maßnahme. Sinnvolle Sequenzen sind auch ziemlich häufig. (Denken Sie an SETI oder Krypto oder Captchas.) Es gibt auch weitere abstraktere Kontextsätze.

Überlegen Sie also genau, bevor Sie davon ausgehen, dass eine Zeichenfolge nur aufgrund der Länge oder des Leerzeichens leer ist.

Sehr nützlicher Beitrag, um NSDictionary-Unterstützung sowie eine kleine Änderung hinzuzufügen

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

Der beste Weg ist, die Kategorie zu verwenden.
Sie können die folgende Funktion überprüfen. Welches hat alle Bedingungen zu überprüfen.

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

In jedem Fall ist es am besten, die Länge der angegebenen Zeichenfolge zu überprüfen. Wenn Ihre Zeichenfolge myString ist, lautet der Code:

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

if (string.length == 0) stringIsEmpty;

Überprüfen Sie dies :

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

Oder

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

Hoffe das wird helfen.

Sie können leicht überprüfen, ob die Zeichenfolge leer ist:

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

Ich habe eine leere Zeichenfolge mit dem folgenden Code überprüft:

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

Es ist so einfach wie if([myString isEqual:@""])oderif([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;
}

Sie können eine leere Zeichenfolge auf zwei Arten haben:

1) @ "" // Enthält kein Leerzeichen

2) @ "" // Platz enthalten

Technisch gesehen sind beide Saiten leer. Wir können beide Dinge nur mit EINER Bedingung schreiben

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

Versuche Folgendes

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