Como faço para testar se um NSStringestá vazio no Objective-C?

Você pode verificar se [string length] == 0. Isso verificará se é uma sequência válida, mas vazia (@ "") e se é nula, pois a chamada lengthnil também retornará 0.

A resposta de Marc está correta. Mas aproveito a oportunidade para incluir um ponteiro para a generalização de Wil Shipley isEmpty, que ele compartilhou em seu 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);
}

A primeira abordagem é válida, mas não funciona se sua string tiver espaços em branco ( @" "). Portanto, você deve limpar esses espaços em branco antes de testá-lo.

Este código limpa todos os espaços em branco nos dois lados da string:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Uma boa idéia é criar uma macro, para que você não precise digitar esta linha de monstro:

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

Agora você pode usar:

NSString *emptyString = @"   ";

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

Uma das melhores soluções que eu já vi (melhor que a de Matt G) é essa função inline aprimorada que peguei em um repo do Git Hub (o de Wil Shipley, mas não consigo encontrar o 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);
}

Você deve usar melhor esta categoria:

@implementation NSString (Empty)

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

@end

Eu coloquei isso:

@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

O problema é que, se o eu for nulo, essa função nunca será chamada. Retornará false, o que é desejado.

Outra opção é verificar se ele é igual a @""com isEqualToString:assim:

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

Apenas passe sua string para o seguinte método:

+(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 usar uma das if elsecondições, como mostrado abaixo:

Método 1:

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

Método 2:

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

Versão rápida

Embora essa seja uma pergunta do Objetivo C, eu precisava usar o NSStringSwift, por isso também incluirei uma resposta aqui.

let myNSString: NSString = ""

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

Ou se NSStringfor um opcional:

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

A Stringversão normal do Swift é

let myString: String = ""

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

Veja também: Verifique a sequência vazia no Swift?

Pode ser que essa resposta seja a duplicata das respostas já fornecidas, mas fiz poucas modificações e alterações na ordem de verificação das condições. Consulte o código abaixo:

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

Você pode verificar se sua string está vazia ou não usando este método:

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

A melhor prática é fazer com que uma classe compartilhada diga UtilityClass e anuncie esse método para que você possa usar esse método apenas chamando-o através de seu aplicativo.

Você tem 2 métodos para verificar se a sequência está vazia ou não:

Vamos supor que seu nome de string seja NSString *strIsEmpty.

Método 1:

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

else
{
    //String is not empty
}

Método 2:

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

else
{
    //String is not empty
}

Escolha qualquer um dos métodos acima e saiba se a string está vazia ou não.

Basta verificar o comprimento da corda

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

uma mensagem para NIL retornará nulo ou 0, portanto, não é necessário testar nil :).

Feliz codificação ...

Está funcionando como charme para mim

Se o NSStringés

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

    NSLog(@"s is empty");

} else {

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

}

Portanto, além do conceito básico de verificar se o comprimento de uma string é menor que 1, é importante considerar o contexto profundamente. Os idiomas humano ou computador ou de outra forma podem ter definições diferentes de cadeias vazias e, nesses mesmos idiomas, um contexto adicional pode alterar ainda mais o significado.

Digamos que string vazia signifique "uma string que não contenha caracteres significativos no contexto atual".

Isso pode significar visualmente, pois na cor e na cor de fundo são as mesmas em uma sequência atribuída. Efetivamente vazio.

Isso pode significar vazio de caracteres significativos. Todos os pontos, traços ou sublinhados podem ser considerados vazios. Além disso, vazio de caracteres significativos significativos pode significar uma sequência que não possui caracteres que o leitor entenda. Eles podem ser caracteres em um idioma ou conjunto de caracteres definido como sem sentido para o leitor. Poderíamos definir um pouco diferente dizer que a string não forma palavras conhecidas em um determinado idioma.

Poderíamos dizer que vazio é uma função da porcentagem de espaço negativo nos glifos renderizados.

Mesmo uma sequência de caracteres não imprimíveis sem representação visual geral não está realmente vazia. Personagens de controle vêm à mente. Especialmente a faixa ASCII baixa (fico surpreso que ninguém tenha mencionado isso porque eles usam muitos sistemas e não são espaços em branco, pois normalmente não têm glifos nem métricas visuais). No entanto, o comprimento da string não é zero.

Conclusão. O comprimento por si só não é a única medida aqui. A associação ao conjunto contextual também é bastante importante.

A associação ao conjunto de caracteres é uma medida adicional comum muito importante. Sequências significativas também são bastante comuns. (pense em SETI ou cripto ou captchas) Também existem conjuntos de contexto mais abstratos.

Portanto, pense com cuidado antes de assumir que uma string está vazia apenas com base no comprimento ou espaço em branco.

Postagem muito útil, para adicionar suporte ao NSDictionary, bem como uma pequena alteração

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

A melhor maneira é usar a categoria.
Você pode verificar a seguinte função. Que tem todas as condições para verificar.

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

A melhor maneira, em qualquer caso, é verificar o comprimento da string fornecida. Para isso, se a string for myString, o código será:

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

if (string.length == 0) stringIsEmpty;

verifique isto:

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

Ou

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

Espero que isso ajude.

Você pode facilmente verificar se a string está vazia com isso:

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

Eu verifiquei uma string vazia usando o código abaixo:

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

É tão simples quanto 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;
}

Você pode ter uma sequência vazia de duas maneiras:

1) @ "" // Não contém espaço

2) @ "" // Contém espaço

Tecnicamente, as duas cordas estão vazias. Podemos escrever as duas coisas apenas usando UMA condição

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

Tente o seguinte

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