¿Cómo pruebo si un NSStringestá vacío en Objective-C?

Puedes comprobar si [string length] == 0. Esto verificará si es una cadena válida pero vacía (@ ""), así como si es nula, ya que llamar lengtha nil también devolverá 0.

La respuesta de Marc es correcta. Pero aprovecharé esta oportunidad para incluir un puntero al generalizado de Wil Shipley isEmpty, que compartió en su 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);
}

El primer enfoque es válido, pero no funciona si su cadena tiene espacios en blanco ( @" "). Por lo tanto, debe borrar estos espacios en blanco antes de probarlo.

Este código borra todos los espacios en blanco a ambos lados de la cadena:

[stringObject stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet] ];

Una buena idea es crear una macro, para que no tenga que escribir esta línea de monstruo:

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

Ahora puedes usar:

NSString *emptyString = @"   ";

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

Una de las mejores soluciones que he visto (mejor que la de Matt G) es esta función en línea mejorada que elegí en algún repositorio de Git Hub (la de Wil Shipley, pero no puedo encontrar el enlace):

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

Deberías usar mejor esta categoría:

@implementation NSString (Empty)

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

@end

Pongo esto:

@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

El problema es que si self es nulo, esta función nunca se llama. Volverá falso, lo que se desea.

Otra opción es comprobar si es igual a @""la isEqualToString:de este modo:

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

Simplemente pase su cadena al siguiente 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;
}

Solo usa uno de los if else condiciones como se muestra a continuación:

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
}

Versión rápida

Aunque esta es una pregunta del Objetivo C, necesitaba usarla NSStringen Swift, así que también incluiré una respuesta aquí.

let myNSString: NSString = ""

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

O si NSStringes un 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.")
    }
}

La Stringversión normal de Swift es

let myString: String = ""

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

Ver también: ¿ Comprobar cadena vacía en Swift?

Puede ser que esta respuesta sea el duplicado de las respuestas ya dadas, pero hice pocas modificaciones y cambios en el orden de verificación de las condiciones. Por favor, consulte el siguiente código:

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

Puede verificar si su cadena está vacía o no 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;
}

La mejor práctica es hacer que una clase compartida diga UtilityClass y agregue este método para que pueda usar este método simplemente llamándolo a través de su aplicación.

Tiene 2 métodos para verificar si la cadena está vacía o no:

Supongamos que su nombre de cadena es 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
}

Elija cualquiera de los métodos anteriores y conozca si la cadena está vacía o no.

Simplemente verifique la longitud de su cuerda

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

un mensaje a NIL devolverá nil o 0, por lo que no es necesario probar nil :).

Feliz codificación ...

Funciona como un encanto para mi

Si el NSStringess

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

    NSLog(@"s is empty");

} else {

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

}

Entonces, aparte del concepto básico de verificar una longitud de cadena menor que 1, es importante considerar el contexto profundamente. Los idiomas humanos o informáticos o de otro modo pueden tener diferentes definiciones de cadenas vacías y dentro de esos mismos idiomas, el contexto adicional puede cambiar aún más el significado.

Digamos que una cadena vacía significa "una cadena que no contiene ningún carácter significativo en el contexto actual".

Esto podría significar visualmente, ya que el color y el color de fondo son los mismos en una cadena atribuida. Efectivamente vacío.

Esto podría significar vacío de caracteres significativos. Todos los puntos o todos los guiones o todos los guiones bajos pueden considerarse vacíos. Además, vacío de caracteres significativos significativos podría significar una cadena que no tiene caracteres que el lector entienda. Pueden ser caracteres en un idioma o conjunto de caracteres definido como sin sentido para el lector. Podríamos definirlo un poco diferente decir que la cadena no forma palabras conocidas en un idioma dado.

Podríamos decir que vacío es una función del porcentaje de espacio negativo en los glifos representados.

Incluso una secuencia de caracteres no imprimibles sin representación visual general no está realmente vacía. Los personajes de control vienen a la mente. Especialmente el bajo rango ASCII (me sorprende que nadie los haya mencionado ya que manejan muchos sistemas y no son espacios en blanco, ya que normalmente no tienen glifos ni métricas visuales). Sin embargo, la longitud de la cadena no es cero.

Conclusión. La longitud por sí sola no es la única medida aquí. La membresía contextual también es bastante importante.

La membresía del juego de caracteres es una medida adicional común muy importante. Las secuencias significativas también son bastante comunes. (piense en SETI o crypto o captchas) También existen conjuntos de contexto más abstractos adicionales.

Por lo tanto, piense detenidamente antes de asumir que una cadena solo está vacía según la longitud o el espacio en blanco.

Publicación muy útil, para agregar soporte NSDictionary y un pequeño cambio

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 mejor manera es usar la categoría.
Puede verificar la siguiente función. Que tiene todas las condiciones 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;
    }

La mejor manera en cualquier caso es verificar la longitud de la cadena dada. Para esto, si su cadena es myString, entonces el código es:

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

if (string.length == 0) stringIsEmpty;

Mira esto :

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

O

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

Espero que esto ayude.

Puede verificar fácilmente si la cadena está vacía con esto:

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

He comprobado una cadena vacía usando el siguiente código:

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

Es tan simple como 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;
}

Puede tener una cadena vacía de dos maneras:

1) @ "" // No contiene espacio

2) @ "" // Contiene espacio

Técnicamente ambas cadenas están vacías. Podemos escribir ambas cosas simplemente usando UNA condición

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

Intenta lo siguiente

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