webentwicklung-frage-antwort-db.com.de

Wie teste ich, ob eine Zeichenfolge in Objective-C leer ist?

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

635
Jamey McElveen

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 sie null ist, da der Aufruf von length bei null ebenfalls 0 zurückgibt.

1130

Marc hat richtig geantwortet. Aber ich werde diese Gelegenheit nutzen, um einen Hinweis auf Wil Shipleys verallgemeinertes isEmpty aufzunehmen, den er in seinem 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);
}
127
Matt G

Der erste Ansatz ist gültig, funktioniert aber nicht, wenn Ihre Zeichenfolge Leerzeichen enthält (@" "). Sie müssen also diese Leerzeichen 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, 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 einigen Git Hub-Repos (Wil Shipleys, aber ich kann den Link nicht finden) gefunden habe:

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

Sie sollten diese Kategorie besser verwenden:

@implementation NSString (Empty)

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

@end
16
user238824

Ü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;
}
12
Mani

Eine andere Möglichkeit ist, zu überprüfen, ob es @"" mit isEqualToString: entspricht:

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

Ich habe folgendes gesagt:

@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 gleich null ist. Es wird false zurückgegeben, was erwünscht ist.

11
user4951

Schnelle Version

Obwohl es sich um eine Ziel-C-Frage handelt, musste NSString in Swift verwendet werden, daher werde ich hier auch eine Antwort einfügen.

let myNSString: NSString = ""

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

Oder wenn NSString optional ist:

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 String Version ist

let myString: String = ""

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

Siehe auch: Leerstring in Swift prüfen?

6
Suragch

Verwenden Sie einfach eine der folgenden ifelse Bedingungen:

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
}
6
Samir Jwarchan

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 beziehen Sie sich auf den folgenden Code:

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

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

Die beste Vorgehensweise besteht darin, eine gemeinsam genutzte Klasse dazu zu bringen, UtilityClass zu sagen, und diese Methode zu bewerben, damit Sie diese Methode verwenden können, indem Sie sie einfach in Ihrer Anwendung aufrufen.

4
Fatima Arshad

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

Nehmen wir an, Ihr String-Name ist 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.

4
Aditya

Überprüfen Sie einfach Ihre Stringlänge

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

eine Nachricht an NIL gibt nil oder 0 zurück. Sie müssen also nicht auf nil testen :).

Viel Spaß beim Codieren ...

3
Aks

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);
}
3
Zeev Vax
- (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;
}
2
Ptbaileys

Es wirkt wie ein Zauber für mich

Wenn NSStrings ist

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

    NSLog(@"s is empty");

} else {

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

}
2
Salim

Abgesehen von dem Grundkonzept, nach einer String-Länge von weniger als 1 zu suchen, ist es daher wichtig, den Kontext gründlich zu betrachten. Sprachen Mensch oder Computer oder auf andere Weise haben möglicherweise unterschiedliche Definitionen für leere Zeichenfolgen, und innerhalb derselben Sprachen kann zusätzlicher Kontext die Bedeutung weiter ändern.

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

Dies könnte visuell bedeuten, da Farbe und Hintergrundfarbe in einer zugewiesenen Zeichenfolge identisch sind. Effektiv leer.

Dies kann bedeuten, dass keine aussagekräftigen Zeichen mehr vorhanden sind. Alle Punkte, Bindestriche oder Unterstriche können als leer betrachtet werden. Außerdem kann ein String, der keine aussagekräftigen signifikanten Zeichen enthält, eine Zeichenfolge sein, die der Leser nicht versteht. Dies können Zeichen in einer Sprache oder in einem Zeichensatz sein, die für den Leser als bedeutungslos definiert sind. Wir könnten es etwas anders definieren, wenn wir sagen, dass die Zeichenfolge in einer bestimmten Sprache keine bekannten Wörter bildet.

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

Auch eine Folge nicht druckbarer Zeichen ohne allgemeine visuelle Darstellung ist nicht wirklich leer. Steuerzeichen fallen mir ein. Besonders der niedrige ASCII Bereich (ich bin überrascht, dass niemand diese erwähnt hat, da sie viele Systeme überfluten und keine Leerzeichen sind, da sie normalerweise keine Glyphen und keine visuellen Metriken enthalten). Die Stringlänge ist jedoch nicht Null.

Fazit. Länge allein ist hier nicht das einzige Maß. Die kontextbezogene Set-Mitgliedschaft ist ebenfalls sehr wichtig.

Die Mitgliedschaft im Zeichensatz ist eine sehr wichtige zusätzliche Maßnahme. Sinnvolle Sequenzen sind auch ziemlich häufig. (Denken Sie an SETI oder Crypto oder Captchas.) Weitere abstraktere Kontextmengen sind ebenfalls vorhanden.

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

2
uchuugaka

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

Sie können auf einfache Weise überprüfen, ob die Zeichenfolge leer ist:

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

Es ist so einfach wie if([myString isEqual:@""]) oder if([myString isEqualToString:@""])

1
Ahsan Ebrahim
if (string.length == 0) stringIsEmpty;
1
InvertedHeli

Ich habe eine leere Zeichenfolge mit folgendem 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"];  
}
1

überprüfen Sie dies :

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

Oder

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

Hoffe das wird helfen.

1
Mayur

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

    int len = [myString length];
    if(len == 0){
       NSLog(@"String is empty");
    }
    else{
      NSLog(@"String is : %@", myString);
    }
1
AJS
//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;
}
1
Rohit Kashyap
if(str.length == 0 || [str isKindOfClass: [NSNull class]]){
    NSLog(@"String is empty");
}
else{
    NSLog(@"String is not empty");
}    
0
C_compnay

Versuche Folgendes

NSString *stringToCheck = @"";

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

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

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

2) @ "" // Leerzeichen enthalten

Technisch sind beide Zeichenfolgen leer. Wir können beide Dinge einfach mit ONE Condition schreiben

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