[ios] ¿Cómo puedo verificar si una cadena contiene otra cadena en Objective-C?


Answers

NOTA: esta respuesta ahora está obsoleta

Crea una categoría para NSString:

@interface NSString ( SubstringSearch )
    - (BOOL)containsString:(NSString *)substring;
@end

// - - - - 

@implementation NSString ( SubstringSearch )

- (BOOL)containsString:(NSString *)substring
{    
    NSRange range = [self rangeOfString : substring];
    BOOL found = ( range.location != NSNotFound );
    return found;
}

@end

EDITAR: Observe el comentario de Daniel Galasko a continuación sobre el nombramiento

Question

¿Cómo puedo verificar si una cadena ( NSString ) contiene otra cadena más pequeña?

Esperaba algo como:

NSString *string = @"hello bla bla";
NSLog(@"%d",[string containsSubstring:@"hello"]);

Pero lo más cerca que pude encontrar fue:

if ([string rangeOfString:@"hello"] == 0) {
    NSLog(@"sub string doesnt exist");
} 
else {
    NSLog(@"exists");
}

De todos modos, ¿es esa la mejor manera de encontrar si una cadena contiene otra cadena?




Si necesita esto una vez, escriba:

NSString *stringToSearchThrough = @"-rangeOfString method finds and returns the range of the first occurrence of a given string within the receiver.";
BOOL contains = [stringToSearchThrough rangeOfString:@"occurence of a given string"].location != NSNotFound;



En Swift 4:

let a = "Hello, how are you?"
a.contains("Hello")   //will return true



Mejor solución. ¡Tan simple como esto! Si quieres encontrar una palabra o parte de la cadena. Puedes usar este código En este ejemplo, vamos a verificar si el valor de la palabra contiene "acter".

NSString *word =@"find a word or character here";
if ([word containsString:@"acter"]){
    NSLog(@"It contains acter");
} else {
     NSLog (@"It does not contain acter");
}



Aquí hay un fragmento de función de copiar y pegar:

-(BOOL)Contains:(NSString *)StrSearchTerm on:(NSString *)StrText
{
    return [StrText rangeOfString:StrSearchTerm 
        options:NSCaseInsensitiveSearch].location != NSNotFound;
}



NSString *categoryString = @"Holiday Event";
if([categoryString rangeOfString:@"Holiday"].location == NSNotFound)
{
    //categoryString does not contains Holiday
}
else
{
    //categoryString contains Holiday
}



La primera cadena contiene o no segunda cuerda,

    NSString *first = @"Banana";
    NSString *second = @"BananaMilk";
    NSRange range = [first rangeOfString:second options:NSCaseInsensitiveSearch];

    if (range.length > 0) {
        NSLog(@"Detected");
    }
    else {
        NSLog(@"Not detected");
    }



NSString *myString = @"hello bla bla";
NSRange rangeValue = [myString rangeOfString:@"hello" options:NSCaseInsensitiveSearch];

if (rangeValue.length > 0)
{
    NSLog(@"string contains hello");
} 
else 
{
    NSLog(@"string does not contain hello!");
}

// Alternativamente, también puedes usar lo siguiente:

if (rangeValue.location == NSNotFound) 
{
    NSLog(@"string does not contain hello");
} 
else 
{
    NSLog(@"string contains hello!");
}



Personalmente, realmente odio NSNotFound pero entiendo su necesidad.

Pero algunas personas pueden no entender las complejidades de comparar contra NSNotFound

Por ejemplo, este código:

- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
    if([string rangeOfString:otherString].location != NSNotFound)
        return YES;
    else
        return NO;
}

tiene sus problemas:

1) Obviamente si otherString = nil este código se bloqueará. una prueba simple sería:

NSLog(@"does string contain string - %@", [self doesString:@"hey" containString:nil] ? @"YES": @"NO");

resultados en !! ¡CRASH!

2) Lo que no es tan obvio para alguien nuevo en el objetivo-c es que el mismo código NO se bloqueará cuando string = nil . Por ejemplo, este código:

NSLog(@"does string contain string - %@", [self doesString:nil containString:@"hey"] ? @"YES": @"NO");

y este código:

NSLog(@"does string contain string - %@", [self doesString:nil containString:nil] ? @"YES": @"NO");

ambos resultarán en

does string contains string - YES

Lo cual claramente NO es lo que quieres.

Entonces, la mejor solución que creo que funciona es usar el hecho de que rangeOfString devuelve la longitud de 0 entonces un código mejor y más confiable es este:

- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
    if(otherString && [string rangeOfString:otherString].length)
        return YES;
    else
        return NO;
}

O SIMPLEMENTE:

- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
    return (otherString && [string rangeOfString:otherString].length);
}

que para los casos 1 y 2 volverá

does string contains string - NO

Esa es mi 2 centavos ;-)

Por favor revisa mi Gist para obtener un código más útil.




Related