Wie überprüfe ich, ob eine Zeichenfolge in Objective-C eine andere Zeichenfolge enthält?

HINWEIS: Diese Antwort ist jetzt veraltet

Erstellen Sie eine Kategorie für 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

EDIT: Beachten Sie den Kommentar von Daniel Galasko bezüglich der Benennung

Da dies in Google ein hochrangiges Ergebnis zu sein scheint, möchte ich Folgendes hinzufügen:

iOS 8 und OS X 10.10 fügen NSString die Methode containsString: hinzu. Eine aktualisierte Version von Dave DeLongs Beispiel für diese Systeme:

_NSString *string = @"hello bla bla";
if ([string containsString:@"bla"]) {
    NSLog(@"string contains bla!");
} else {
    NSLog(@"string does not contain bla");
}
_

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

// Sie können alternativ auch Folgendes verwenden:

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

Mit iOS 8 und Swift können wir die localizedCaseInsensitiveContainsString -Methode verwenden

 let string: NSString = "Café"
 let substring: NSString = "É"

 string.localizedCaseInsensitiveContainsString(substring) // true

Ich persönlich hasse NSNotFound wirklich, verstehe aber die Notwendigkeit.

Aber einige Leute verstehen möglicherweise nicht die Komplexität des Vergleichs mit NSNotFound

Zum Beispiel dieser Code:

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

hat seine Probleme:

1) Offensichtlich stürzt dieser Code ab, wenn otherString = nil. Ein einfacher Test wäre:

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

ergibt !! ABSTURZ !!

2) Was für jemanden, der neu bei Objective-C ist, nicht so offensichtlich ist, ist, dass derselbe Code NICHT abstürzt, wenn string = nil. Zum Beispiel dieser Code:

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

und dieser Code:

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

wird beides ergeben

does string contains string - YES

Welches ist eindeutig nicht das, was Sie wollen.

Die bessere Lösung, von der ich glaube, dass sie funktioniert, ist die Verwendung der Tatsache, dass rangeOfString die Länge 0 zurückgibt. Ein zuverlässigerer Code ist also der folgende:

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

ODER EINFACH:

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

was wird für die Fälle 1 und 2 zurückkehren

does string contains string - NO

Das sind meine 2 Cent ;-)

Weitere hilfreiche Informationen finden Sie in meinem Gist .

Eine verbesserte Version von P i s Lösung , einer Kategorie auf NSString, die nicht nur Aufschluss gibt Wenn eine Zeichenfolge in einer anderen Zeichenfolge gefunden wird, aber auch einen Referenzbereich annimmt, lautet Folgendes:

@interface NSString (Contains)
-(BOOL)containsString: (NSString*)substring
              atRange:(NSRange*)range;

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

@implementation NSString (Contains)

-(BOOL)containsString:(NSString *)substring
              atRange:(NSRange *)range{

    NSRange r = [self rangeOfString : substring];
    BOOL found = ( r.location != NSNotFound );
    if (range != NULL) *range = r;
    return found;
}

-(BOOL)containsString:(NSString *)substring
{
    return [self containsString:substring
                        atRange:NULL];
}

@end

Verwenden Sie es wie folgt:

NSString *string = @"Hello, World!";

//If you only want to ensure a string contains a certain substring
if ([string containsString:@"Ello" atRange:NULL]) {
    NSLog(@"YES");
}

// Or simply
if ([string containsString:@"Ello"]) {
    NSLog(@"YES");
}

//If you also want to know substring's range
NSRange range;
if ([string containsString:@"Ello" atRange:&range]) {
    NSLog(@"%@", NSStringFromRange(range));
}

Hier ist ein Code-Schnipsel zum Kopieren und Einfügen:

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

Oneliner (Kleinere Menge an Code. TROCKEN, da Sie nur einen NSLog haben):

NSString *string = @"hello bla bla";
NSLog(@"String %@", ([string rangeOfString:@"bla"].location == NSNotFound) ? @"not found" : @"cotains bla"); 

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

Beste Lösung. So einfach ist das! Wenn Sie ein Wort oder einen Teil der Zeichenfolge suchen möchten. Sie können diesen Code verwenden. In diesem Beispiel prüfen wir, ob der Wert von Word "acter" enthält.

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

versuche dies,

NSString *string = @"test Data";
if ([[string lowercaseString] rangeOfString:@"data"].location == NSNotFound) 
{
    NSLog(@"string does not contain Data");
}   
else 
{
    NSLog(@"string contains data!");
}

Im Falle von Swift kann dies verwendet werden

let string = "Package #23"
if string.containsString("Package #") {
    //String contains substring
}
else {
    //String does not contain substring
}

In Swift 4:

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

Wenn Sie dies einmal brauchen, schreiben Sie:

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;

Wenn Sie sich nicht um Groß- und Kleinschreibung kümmern. Versuchen Sie dies einmal.

NSString *string  = @"Hello World!";

if([string rangeOfString:@"hello" options:NSCaseInsensitiveSearch].location !=NSNotFound)
{
    NSLog(@"found");
}
else
{
    NSLog(@"not found");
}

Verwenden Sie die Option NSCaseInsensitiveSearch mit rangeOfString: options:

NSString *me = @"toBe" ;
NSString *target = @"abcdetobe" ;
NSRange range = [target  rangeOfString: me options: NSCaseInsensitiveSearch];
NSLog(@"found: %@", (range.location != NSNotFound) ? @"Yes" : @"No");
if (range.location != NSNotFound) {
// your code
}

Das Ausgabeergebnis wurde gefunden: Ja

Die Optionen können zusammen "or'ed" werden und umfassen:

NSCaseInsensitiveSearch NSLiteralSearch NSBackwardsSearch und mehr

Bitte benutzen Sie diesen Code

NSString *string = @"hello bla bla";
if ([string rangeOfString:@"bla"].location == NSNotFound) 
{
    NSLog(@"string does not contain bla");
} 
else 
{  
    NSLog(@"string contains bla!");
}

Erste Zeichenfolge enthält oder nicht zweite Zeichenfolge,

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

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

Swift 4 und höher

 let str = "Hello iam midhun"

   if str.contains("iam") {
     //contain substring
   }
   else {
     //doesn't contain substring
   }

Versuche dies:

Swift 4.1, 4.2:

let stringData = "Black board"

//Swift quick way and case sensitive
if stringData.contains("bla") {
    print("data contains string");
}

//case sensitive
if stringData.range(of: "bla",options: .caseInsensitive) != nil {
    print("data contains string");
}else {
    print("data does not contains string");
}

Für Ziel-C:

NSString *stringData = @"Black board";

//Quick way and case sensitive
if ([stringData containsString:@"bla"]) {
    NSLog(@"data contains string");
}

//Case Insensitive
if ([stringData rangeOfString:@"bla" options:NSCaseInsensitiveSearch].location != NSNotFound) {
   NSLog(@"data contains string");
}else {
   NSLog(@"data does not contain string");
}