Eu estava usando isso no meu aplicativo para iPhone

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

mas gera alguma exceção, e o console mostra que o título é "(nulo)".

Então, eu estou usando isso agora:

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

Qual é a diferença e qual é a melhor maneira de determinar se uma string é nula?

Como outros já apontaram, existem muitos tipos de "null" em Cocoa / Objective C. Mas outra coisa a ser observada é que [title isKindOfClass: [NSNull class]] é sem sentido complexo, pois [NSNull null] está documentado como um singleton para que você possa apenas verificar a igualdade do ponteiro. Consulte os tópicos para cacau: usando nulo .

Portanto, um bom teste pode ser:

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

Observe como você pode usar o fato de que, mesmo que o título seja nulo, title.length retornará 0 / nil / false, ou seja, 0 neste caso, para que você não precise caso especial. Isso é algo com o qual as pessoas que são novas no Objective C têm problemas para se acostumar, especialmente em outros idiomas em que as mensagens / métodos chamam para nada travar.

é tão simples quanto

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

lembre-se de que no objetivo C, se o objeto for nulo, ele retornará 0 como o valor.

Isso fornecerá a você uma cadeia nula e uma cadeia de comprimento 0.

Consulte os seguintes artigos relacionados neste site:

• É se (variável) o mesmo que se (variável! = Nulo) em Objective-C h

Acho que seu erro está relacionado a outra coisa, pois você não precisa fazer a verificação extra.

Consulte também esta pergunta relacionada: Verificação adequada da coluna de texto nula sqlite

Eu descobri que, para realmente fazer certo, você acaba fazendo algo semelhante a

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

Caso contrário, você terá situações estranhas nas quais o controle ainda ignorará seu cheque. Eu não encontrei um que supere as isEqualverificações de comprimento.

O que há com todas essas "funciona para mim respostas"? Estamos todos codificando no mesmo idioma e as regras são

1. Verifique se a referência não é nula
2. Verifique e verifique se o comprimento da string não é 0

É isso que funcionará para todos. Se uma determinada solução "apenas funciona para você", é apenas porque o fluxo do aplicativo não permite um cenário em que a referência pode ser nula ou o comprimento da string seja 0. A maneira correta de fazer isso é o método que manipulará o que você quer em todos os casos.

Se você quiser testar todos os objetos nulos / vazios (como cadeias vazias ou matrizes / conjuntos vazios), poderá usar o seguinte:

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

Existem duas situações:

É possível que um objeto seja [NSNull null], ou é impossível.
Geralmente, seu aplicativo não deve ser usado [NSNull null];, se você quiser colocar um objeto " nulo " em uma matriz ou usá-lo como um valor de dicionário. E então você deve saber quais matrizes ou dicionários podem conter valores nulos e quais podem não.
Se você acha que uma matriz nunca contém [NSNull null]valores, não verifique. Se houver [NSNull null], você pode obter uma exceção, mas isso é bom: as exceções de Objective-C indicam erros de programação. E você tem um erro de programação que precisa ser corrigido alterando algum código.

Se um objeto puder ser [NSNull null], você verifica isso simplesmente testando
(object == [NSNull null]). Ligar isEqualou verificar a classe do objeto é um absurdo. Existe apenas um [NSNull null]objeto, e o operador C simples e antigo o verifica da maneira mais direta e eficiente.

Se você verificar um NSStringobjeto que não pode ser [NSNull null](porque você sabe que não pode ser [NSNull null]ou porque acabou de verificar se é diferente de [NSNull null], então você precisa se perguntar como deseja tratar uma sequência vazia, ou seja, com comprimento 0. Se você tratá-lo como uma nullstring nil, em seguida, (object.length == 0)test.objeto.length retornará 0 se object == nil, portanto, este teste cobre objetos e cadeias nulos com comprimento 0. Se você tratar uma cadeia de comprimento 0 diferente de uma cadeia nula, verifique se object == nil.

Por fim, se você deseja adicionar uma string a uma matriz ou dicionário, e a string pode ser nula, você pode optar por não adicioná-la, substituí-la por @""ou substituí-la por [NSNull null]. Substituí-lo por @""significa que você perde a capacidade de distinguir entre "sem cadeia" e "cadeia de comprimento 0". Substituí-lo [NSNull null]significa que você precisa escrever um código ao acessar a matriz ou o dicionário que verifica se há [NSNull null]objetos.

Você apenas verifica se não há

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

ou

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

Solução MACRO (2020)

Aqui está a macro que eu uso para uma string segura em vez de obter a string " (null) " em um UILabel, por exemplo:

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

digamos que você tenha uma classe de membro e propriedade de nome e nome seja nulo:

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

com macro:

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

agradável e limpo 😊

Solução de Extensão (2020)

Se você preferir verificar nula e nula e vazia no seu projeto, você pode usar minha linha de extensão abaixo:

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

Exemplo de uso

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
}

Tente isso para verificar nulo

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

Isso funcionaria com os seguintes casos, NSString *strOne = @""OU NSString *strOne = @"StackOverflow"OU NSString *strOne = [NSNull null]OU NSString *strOne.

Se esse tipo de coisa ainda não existir, você poderá criar uma categoria NSString:

@interface NSString (TrucBiduleChoseAdditions)

- (BOOL)isEmpty;

@end

@implementation NSString (TrucBiduleChoseAdditions)

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

@end

O que funciona para mim é if ( !myobject )

A verificação completa de uma cadeia de caracteres para condições nulas pode ser a seguinte: <\ br>

    if (mystring)
     {
       if ([mystring isEqualToString: @ ""])
        {
          mystring = @ "alguma string";
        }
     }    
    outro
     {
        //afirmações
     }

Eu só checo string nula com

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  
}

Para string:

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

}

Consulte a figura abaixo:

Para string:

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