Come posso verificare se an NSStringè vuoto in Objective-C?

Puoi verificare se [string length] == 0. Questo verificherà se si tratta di una stringa valida ma vuota (@ "") e se è nulla, poiché la chiamata lengtha zero restituirà anche 0.

La risposta di Marc è corretta. Ma colgo l'occasione per includere un puntatore al generalizzato di Wil Shipley isEmpty, che ha condiviso sul suo 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);
}

Il primo approccio è valido, ma non funziona se la stringa ha spazi vuoti ( @" "). Quindi è necessario cancellare questi spazi bianchi prima di testarlo.

Questo codice cancella tutti gli spazi vuoti su entrambi i lati della stringa:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Una buona idea è creare una macro, quindi non è necessario digitare questa linea di mostri:

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

Ora puoi usare:

NSString *emptyString = @"   ";

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

Una delle migliori soluzioni che abbia mai visto (migliore di quella di Matt G) è questa funzione inline migliorata che ho acquisito su alcuni repository Git Hub (quello di Wil Shipley, ma non riesco a trovare il link):

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

Dovresti usare meglio questa categoria:

@implementation NSString (Empty)

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

@end

Ho messo questo:

@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

Il problema è che se l'io è zero, questa funzione non viene mai chiamata. Restituirà false, il che è desiderato.

Un'altra opzione è quella di verificare se è uguale @""con isEqualToString:in questo modo:

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

Basta passare la stringa al seguente metodo:

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

Basta usare una delle if elsecondizioni come mostrato di seguito:

Metodo 1:

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

Metodo 2:

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

Versione rapida

Anche se questa è una domanda dell'obiettivo C, dovevo usare NSStringSwift, quindi includerò anche una risposta qui.

let myNSString: NSString = ""

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

O se NSStringè un opzionale:

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 normale Stringversione di Swift è

let myString: String = ""

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

Vedi anche: Controlla la stringa vuota in Swift?

Potrebbe essere questa risposta il duplicato di risposte già fornite, ma ho apportato poche modifiche e cambiamenti nell'ordine di verifica delle condizioni. Si prega di fare riferimento al codice seguente:

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

Puoi controllare che la tua stringa sia vuota o meno usando questo metodo:

+(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 migliore pratica è far dire a una classe condivisa UtilityClass e aggiungere questo metodo in modo da poter utilizzare questo metodo semplicemente chiamandolo attraverso l'applicazione.

Hai 2 metodi per verificare se la stringa è vuota o meno:

Supponiamo che il nome della stringa sia NSString *strIsEmpty.

Metodo 1:

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

else
{
    //String is not empty
}

Metodo 2:

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

else
{
    //String is not empty
}

Scegli uno dei metodi sopra indicati e scopri se la stringa è vuota o meno.

Controlla semplicemente la lunghezza della stringa

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

un messaggio a NIL restituirà zero o 0, quindi non è necessario testare nulla :).

Buona codifica ...

Funziona come un incanto per me

Se la NSString ès

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

    NSLog(@"s is empty");

} else {

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

}

Quindi, a parte il concetto base di controllo per una lunghezza della stringa inferiore a 1, è importante considerare profondamente il contesto. Le lingue umane o informatiche o altrimenti potrebbero avere definizioni diverse di stringhe vuote e all'interno di quelle stesse lingue, un contesto aggiuntivo potrebbe cambiare ulteriormente il significato.

Diciamo che stringa vuota significa "una stringa che non contiene caratteri significativi nel contesto corrente".

Ciò potrebbe significare visivamente, poiché il colore e il colore di sfondo sono gli stessi in una stringa attribuita. Efficacemente vuoto.

Questo potrebbe significare privo di caratteri significativi. Tutti i punti o tutti i trattini o tutti i trattini bassi possono essere considerati vuoti. Inoltre, privo di caratteri significativi significativi potrebbe significare una stringa che non ha caratteri che il lettore capisce. Potrebbero essere personaggi in una lingua o set di caratteri definiti insignificanti per il lettore. Potremmo definire in modo leggermente diverso dire che la stringa non forma parole conosciute in una determinata lingua.

Potremmo dire che vuoto è una funzione della percentuale di spazio negativo nei glifi resi.

Anche una sequenza di caratteri non stampabili senza una rappresentazione visiva generale non è veramente vuota. I personaggi di controllo vengono in mente. Soprattutto la bassa gamma ASCII (sono sorpreso che nessuno abbia menzionato quelli in quanto utilizzano molti sistemi e non sono spazi bianchi in quanto normalmente non hanno glifi né metriche visive). Tuttavia la lunghezza della stringa non è zero.

Conclusione. La sola lunghezza non è l'unica misura qui. Anche l'appartenenza al set contestuale è piuttosto importante.

L'appartenenza al set di caratteri è una misura aggiuntiva comune molto importante. Le sequenze significative sono anche abbastanza comuni. (pensa a SETI o cripto o captcha) Esistono anche altri set di contesti più astratti.

Quindi pensa attentamente prima di assumere che una stringa sia vuota solo in base alla lunghezza o agli spazi.

Post molto utile, per aggiungere il supporto NSDictionary e una piccola modifica

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

Il modo migliore è usare la categoria.
È possibile verificare la seguente funzione. Che ha tutte le condizioni per verificare.

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

Il modo migliore in ogni caso è controllare la lunghezza di una determinata stringa. Per questo se la tua stringa è myString, il codice è:

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

if (string.length == 0) stringIsEmpty;

verificare questo :

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

O

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

Spero che questo possa aiutare.

Puoi facilmente verificare se la stringa è vuota con questo:

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

Ho controllato una stringa vuota usando il codice seguente:

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

È semplice come if([myString isEqual:@""])oif([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;
}

Puoi avere una stringa vuota in due modi:

1) @ "" // Non contiene spazio

2) @ "" // Contenere lo spazio

Tecnicamente entrambe le stringhe sono vuote. Possiamo scrivere entrambe le cose semplicemente usando UNA Condizione

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

Prova quanto segue

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