Comment tester si un NSStringest vide dans Objective-C?

Vous pouvez vérifier si [string length] == 0. Cela vérifiera s'il s'agit d'une chaîne valide mais vide (@ "") ainsi que si elle est nulle, car appeler lengthnil renverra également 0.

La réponse de Marc est correcte. Mais je profite de l'occasion pour inclure un pointeur sur le général de Wil Shipley isEmpty, qu'il a partagé sur son 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);
}

La première approche est valide, mais ne fonctionne pas si votre chaîne contient des espaces vides ( @" "). Vous devez donc effacer ces espaces blancs avant de le tester.

Ce code efface tous les espaces vides des deux côtés de la chaîne:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Une bonne idée est de créer une macro, vous n'avez donc pas à taper cette ligne monstre:

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

Vous pouvez maintenant utiliser:

NSString *emptyString = @"   ";

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

L'une des meilleures solutions que j'ai jamais vues (mieux que celle de Matt G) est cette fonction en ligne améliorée que j'ai choisie sur un dépôt Git Hub (celui de Wil Shipley, mais je ne trouve pas le lien):

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

Vous devriez mieux utiliser cette catégorie:

@implementation NSString (Empty)

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

@end

Je mets ceci:

@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

Le problème est que si self est nul, cette fonction n'est jamais appelée. Cela retournera faux, ce qui est souhaité.

Une autre option consiste à vérifier si elle est égale à @""avec isEqualToString:comme ceci:

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

Passez simplement votre chaîne à la méthode suivante:

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

Utilisez simplement l'une des if elseconditions ci-dessous:

Méthode 1:

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

Méthode 2:

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

Version Swift

Même s'il s'agit d'une question sur l'objectif C, je devais l'utiliser NSStringdans Swift, je vais donc également inclure une réponse ici.

let myNSString: NSString = ""

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

Ou s'il NSStrings'agit d'une 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.")
    }
}

La Stringversion normale de Swift est

let myString: String = ""

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

Voir aussi: Vérifier la chaîne vide dans Swift?

Peut-être que cette réponse est le double des réponses déjà données, mais j'ai fait peu de modifications et de changements dans l'ordre de vérification des conditions. Veuillez vous référer au code ci-dessous:

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

Vous pouvez vérifier que votre chaîne est vide ou non en utilisant cette méthode:

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

La meilleure pratique est de faire dire à une classe partagée UtilityClass et d'annoncer cette méthode afin que vous puissiez utiliser cette méthode en l'appelant simplement dans votre application.

Vous avez 2 méthodes pour vérifier si la chaîne est vide ou non:

Supposons que votre nom de chaîne soit NSString *strIsEmpty .

Méthode 1:

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

else
{
    //String is not empty
}

Méthode 2:

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

else
{
    //String is not empty
}

Choisissez l'une des méthodes ci-dessus et apprenez si la chaîne est vide ou non.

Vérifiez simplement la longueur de votre chaîne

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

un message à NIL retournera nil ou 0, donc pas besoin de tester pour nil :).

Bon codage ...

Cela fonctionne comme un charme pour moi

Si le NSStringests

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

    NSLog(@"s is empty");

} else {

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

}

Ainsi, outre le concept de base de vérification d'une longueur de chaîne inférieure à 1, il est important de considérer le contexte en profondeur. Les langues humaines ou informatiques ou autrement peuvent avoir des définitions différentes de chaînes vides et dans ces mêmes langues, un contexte supplémentaire peut encore changer la signification.

Disons qu'une chaîne vide signifie "une chaîne qui ne contient aucun caractère significatif dans le contexte actuel".

Cela pourrait signifier visuellement, car la couleur et la couleur d'arrière-plan sont les mêmes dans une chaîne attribuée. Effectivement vide.

Cela pourrait signifier vide de caractères significatifs. Tous les points ou tous les tirets ou tous les traits de soulignement peuvent être considérés comme vides. En outre, vide de caractères significatifs significatifs pourrait signifier une chaîne qui n'a pas de caractères que le lecteur comprend. Il peut s'agir de caractères dans une langue ou un jeu de caractères défini comme dépourvu de sens pour le lecteur. Nous pourrions le définir un peu différemment pour dire que la chaîne ne forme aucun mot connu dans une langue donnée.

On pourrait dire que vide est fonction du pourcentage d'espace négatif dans les glyphes rendus.

Même une séquence de caractères non imprimables sans représentation visuelle générale n'est pas vraiment vide. Les personnages de contrôle me viennent à l'esprit. Surtout la plage ASCII basse (je suis surpris que personne ne les ait mentionnés car ils utilisent de nombreux systèmes et ne sont pas des espaces car ils n'ont normalement pas de glyphes et pas de métriques visuelles). Pourtant, la longueur de la chaîne n'est pas nulle.

Conclusion. La longueur seule n'est pas la seule mesure ici. L'appartenance à un ensemble contextuel est également très importante.

L'appartenance au jeu de caractères est une mesure supplémentaire commune très importante. Les séquences significatives sont également assez courantes. (pensez SETI ou crypto ou captchas) Il existe également d'autres ensembles de contextes plus abstraits.

Réfléchissez donc bien avant de supposer qu'une chaîne n'est vide qu'en fonction de la longueur ou de l'espace.

Post très utile, pour ajouter un support NSDictionary ainsi qu'un petit changement

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

La meilleure façon est d'utiliser la catégorie.
Vous pouvez vérifier la fonction suivante. Qui a toutes les conditions à vérifier.

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

La meilleure façon dans tous les cas est de vérifier la longueur de la chaîne donnée. Pour cela, si votre chaîne est myString, le code est:

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

if (string.length == 0) stringIsEmpty;

Vérifiez ça :

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

Ou

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

J'espère que cela vous aidera.

Vous pouvez facilement vérifier si la chaîne est vide avec ceci:

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

J'ai vérifié une chaîne vide en utilisant le code ci-dessous:

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

C'est aussi simple que if([myString isEqual:@""])ouif([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;
}

Vous pouvez avoir une chaîne vide de deux manières:

1) @ "" // Ne contient pas d'espace

2) @ "" // Contient de l'espace

Techniquement, les deux chaînes sont vides. Nous pouvons écrire les deux choses en utilisant UNE seule condition

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

Essayez ce qui suit

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