Lo stavo usando nella mia app per iPhone

if (title == nil) {
    // do something
}

ma genera qualche eccezione e la console mostra che il titolo è "(null)".

Quindi sto usando questo ora:

if (title == nil || [title isKindOfClass:[NSNull class]]) {
    //do something
}

Qual è la differenza e qual è il modo migliore per determinare se una stringa è nulla?

Come altri hanno sottolineato, ci sono molti tipi di "null" in Cocoa / Obiettivo C. Ma un'altra cosa da notare è che [title isKindOfClass: [NSNull class]] è inutilmente complesso poiché [NSNull null] è documentato come un singleton in modo da poter verificare l'uguaglianza del puntatore. Vedi Argomenti per Cacao: Usare Null .

Quindi un buon test potrebbe essere:

if (title == (id)[NSNull null] || title.length == 0 ) title = @"Something";

Nota come puoi usare il fatto che anche se title è zero, title.length restituirà 0 / nil / false, ovvero 0 in questo caso, quindi non è necessario un caso speciale. Questo è qualcosa a cui le persone che non conoscono l'Obiettivo C hanno difficoltà ad abituarsi, in particolare provenienti da altre lingue in cui messaggi / metodi chiamano a zero crash.

è semplice come

if([object length] >0)
{
  // do something
}

ricorda che nell'obiettivo C se l'oggetto è null restituisce 0 come valore.

Questo ti darà sia una stringa nulla che una stringa di lunghezza 0.

Fare riferimento ai seguenti articoli correlati su questo sito:

• È if (variabile) uguale a if (variabile! = Zero) in Objective-C h

Penso che il tuo errore sia correlato a qualcos'altro in quanto non dovresti dover fare il controllo extra.

Vedi anche questa domanda correlata: controllo corretto della colonna di testo zero sqlite

Ho scoperto che per farlo davvero bene devi finire per fare qualcosa di simile

if ( ( ![myString isEqual:[NSNull null]] ) && ( [myString length] != 0 ) ) {
}

Altrimenti si verificano strane situazioni in cui il controllo ignorerà comunque il controllo. Non ne ho mai trovato uno che riesca a superare i isEqualcontrolli di lunghezza.

Che cosa succede con tutte queste "risposte per me"? Stiamo tutti codificando nella stessa lingua e le regole lo sono

1. Assicurarsi che il riferimento non sia nullo
2. Controlla e assicurati che la lunghezza della stringa non sia 0

Questo è ciò che funzionerà per tutti. Se una determinata soluzione "funziona solo per te", è solo perché il flusso dell'applicazione non consente uno scenario in cui il riferimento può essere nullo o la lunghezza della stringa deve essere 0. Il modo corretto per farlo è il metodo che gestirà quello che vuoi in tutti i casi.

Se si desidera eseguire il test su tutti gli oggetti nulli / vuoti (come stringhe vuote o matrici / set vuoti) è possibile utilizzare quanto segue:

static inline BOOL IsEmpty(id object) {
    return object == nil
        || ([object respondsToSelector:@selector(length)]
        && [(NSData *) object length] == 0)
        || ([object respondsToSelector:@selector(count)]
        && [(NSArray *) object count] == 0);
}

Esistono due situazioni:

È possibile che un oggetto sia [NSNull null]o sia impossibile.
La tua applicazione di solito non dovrebbe usarla, ma [NSNull null];usala solo se vuoi mettere un oggetto " null " in un array o usarlo come valore di dizionario. E quindi dovresti sapere quali array o dizionari potrebbero contenere valori null e quali no.
Se ritieni che un array non contenga mai [NSNull null]valori, non verificarlo. Se esiste [NSNull null], potresti ottenere un'eccezione, ma va bene: le eccezioni Objective-C indicano errori di programmazione. E hai un errore di programmazione che deve essere risolto modificando un po 'di codice.

Se un oggetto potrebbe essere [NSNull null], allora lo controlli semplicemente testando
(object == [NSNull null]). Chiamare isEqualo controllare la classe dell'oggetto non ha senso. C'è solo un [NSNull null]oggetto e il semplice vecchio operatore C lo controlla nel modo più semplice ed efficiente.

Se controlli un NSStringoggetto che non può essere [NSNull null](perché sai che non può essere [NSNull null]o perché hai appena verificato che sia diverso da [NSNull null], allora devi chiederti come vuoi trattare una stringa vuota, cioè una con lunghezza 0. Se tu trattarlo è una nullstringa come nil, quindi test (object.length == 0). object.length restituirà 0 se object == nil, quindi questo test copre zero oggetti e stringhe con lunghezza 0. Se trattate una stringa di lunghezza 0 diversa da una stringa nulla, controllate semplicemente se object == nil.

Infine, se si desidera aggiungere una stringa a un array o un dizionario e la stringa potrebbe essere nulla, è possibile scegliere di non aggiungerla, sostituirla con @""o sostituirla [NSNull null]. Sostituendolo con @""si perde la capacità di distinguere tra "nessuna stringa" e "stringa di lunghezza 0". Sostituirlo con [NSNull null]significa che è necessario scrivere codice quando si accede alla matrice o al dizionario che verifica la presenza di [NSNull null]oggetti.

Basta controllare zero

if(data[@"Bonds"]==nil){
  NSLog(@"it is nil");
}

o

if ([data[@"Bonds"] isKindOfClass:[NSNull class]]) {
    NSLog(@"it is null");
}

Soluzione MACRO (2020)

Ecco la macro che uso per una stringa sicura invece di ottenere una stringa " (null) " su un UILabel, ad esempio:

#define SafeString(STRING) ([STRING length] == 0 ? @"" : STRING)

supponiamo di avere una classe membro e la proprietà name e il nome è nullo:

NSLog(@"%@", member.name); // prints (null) on UILabel

con macro:

NSLog(@"%@", SafeString(member.name)); // prints empty string on UILabel

bello e pulito 😊

Extension Solution (2020)

Se preferisci controllare lo zero e la stringa vuota nel tuo progetto, puoi utilizzare la mia linea di estensione di seguito:

NSString + Extension.h

///
/// Checks if giving String is an empty string or a nil object or a Null.
/// @param string string value to check.
///
+ (BOOL)isNullOrEmpty:(NSString*)string;

NSString + Extension.m

+ (BOOL)isNullOrEmpty:(NSString*)string {
    if (string) { // is not Nil
        NSRange range = [string rangeOfString:string];
        BOOL isEmpty = (range.length <= 0 || [string isEqualToString:@" "]);
        BOOL isNull = string == (id)[NSNull null];

        return (isNull || isEmpty);
    }

    return YES;
}

Esempio di utilizzo

if (![NSString isNullOrEmpty:someTitle]) {
    // You can safely use on a Label or even add in an Array for example. Remember: Arrays don't like the nil values!
}

if(textfield.text.length == 0){
   //do your desired work
}

Prova questo per controllare null

 if (text == nil)

@interface NSString (StringFunctions)
- (BOOL) hasCharacters;
@end

@implementation NSString (StringFunctions)
- (BOOL) hasCharacters {
    if(self == (id)[NSNull null]) {
        return NO;
    }else {
        if([self length] == 0) {
            return NO;
        }
    }
    return YES;
}
@end

NSString *strOne = nil;
if([strOne hasCharacters]) {
    NSLog(@"%@",strOne);
}else {
    NSLog(@"String is Empty");
}

Funzionerebbe con i seguenti casi, NSString *strOne = @""OR NSString *strOne = @"StackOverflow"OR NSString *strOne = [NSNull null]OR NSString *strOne.

Se quel genere di cose non esiste già, puoi creare una categoria NSString:

@interface NSString (TrucBiduleChoseAdditions)

- (BOOL)isEmpty;

@end

@implementation NSString (TrucBiduleChoseAdditions)

- (BOOL)isEmpty {
    return self == nil || [@"" isEqualToString:self];
}

@end

Ciò che funziona per me è if ( !myobject )

Il controllo completo di una stringa per condizioni null può essere il seguente: <\ br>

    se (Stringa)
     {
       if ([mystring isEqualToString: @ ""])
        {
          mystring = @ "some string";
        }
     }    
    altro
     {
        // dichiarazioni
     }

Controllo solo la stringa null con

if ([myString isEqual: [NSNull null]])

if ([linkedStr isEqual:(id)[NSNull null]])
                {
                    _linkedinLbl.text=@"No";
                }else{
                    _linkedinLbl.text=@"Yes";
                }

if ([strpass isEqual:[NSNull null]] || strpass==nil || [strpass isEqualToString:@"<null>"] || [strpass isEqualToString:@"(null)"] || strpass.length==0 || [strpass isEqualToString:@""])
{
    //string is blank  
}

Per stringa:

+ (BOOL) checkStringIsNotEmpty:(NSString*)string {
if (string == nil || string.length == 0) return NO;
return YES;

}

Fare riferimento all'immagine seguente:

Per stringa:

+ (BOOL) checkStringIsNotEmpty:(NSString*)string {
if (string == nil || string.length == 0) return NO;
return YES;}