Comment vérifier si une chaîne contient une autre chaîne dans Objective-C?
Comment puis-je vérifier si une chaîne (NSString) contient une autre chaîne plus petite?
J'espérais quelque chose comme:
NSString *string = @"hello bla bla";
NSLog(@"%d",[string containsSubstring:@"hello"]);
Mais le plus proche que j'ai pu trouver était:
if ([string rangeOfString:@"hello"] == 0) {
NSLog(@"sub string doesnt exist");
}
else {
NSLog(@"exists");
}
Quoi qu'il en soit, est-ce le meilleur moyen de déterminer si une chaîne contient une autre chaîne?
NSString *string = @"hello bla bla";
if ([string rangeOfString:@"bla"].location == NSNotFound) {
NSLog(@"string does not contain bla");
} else {
NSLog(@"string contains bla!");
}
La clé remarque que rangeOfString: renvoie une structure NSRange, et la documentation indique qu'il renvoie la structure {NSNotFound, 0} si la "botte de foin" ne contient pas le " aiguille".
Et si vous êtes sur iOS 8 ou OS X Yosemite, vous pouvez désormais faire ce qui suit: (* REMARQUE: Ceci plantera votre application si ce code est appelé sur un appareil iOS7).
NSString *string = @"hello bla blah";
if ([string containsString:@"bla"]) {
NSLog(@"string contains bla!");
} else {
NSLog(@"string does not contain bla");
}
(C'est aussi comme ça que ça marcherait à Swift)
????
REMARQUE: cette réponse est maintenant obsolète
Créez une catégorie pour 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: Observez le commentaire de Daniel Galasko ci-dessous concernant la dénomination
Étant donné que cela semble être un résultat élevé dans Google, je souhaite ajouter ceci:
iOS 8 et OS X 10.10 ajoutent la méthode containsString: à NSString. Une version mise à jour de l'exemple de Dave DeLong pour ces systèmes:
_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!");
}
// Vous pouvez aussi utiliser ce qui suit:
if (rangeValue.location == NSNotFound)
{
NSLog(@"string does not contain hello");
}
else
{
NSLog(@"string contains hello!");
}
Avec iOS 8 et Swift, nous pouvons utiliser la méthode localizedCaseInsensitiveContainsString
let string: NSString = "Café"
let substring: NSString = "É"
string.localizedCaseInsensitiveContainsString(substring) // true
Donc personnellement, je déteste vraiment NSNotFound mais je comprends sa nécessité.
Mais certaines personnes peuvent ne pas comprendre la complexité de la comparaison avec NSNotFound
Par exemple, ce code:
- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
if([string rangeOfString:otherString].location != NSNotFound)
return YES;
else
return NO;
}
a ses problèmes:
1) Évidemment si otherString = nil ce code va planter. un test simple serait:
NSLog(@"does string contain string - %@", [self doesString:@"hey" containString:nil] ? @"YES": @"NO");
résulte en !! CRASH !!
2) Ce qui n’est pas si évident pour un nouvel utilisateur d’objectif-c, c’est que le même code ne plantera PAS lorsque string = nil. Par exemple, ce code:
NSLog(@"does string contain string - %@", [self doesString:nil containString:@"hey"] ? @"YES": @"NO");
et ce code:
NSLog(@"does string contain string - %@", [self doesString:nil containString:nil] ? @"YES": @"NO");
entraînera à la fois
does string contains string - YES
Ce qui n'est clairement pas ce que vous voulez.
Donc, la meilleure solution qui, à mon avis, fonctionne est d'utiliser le fait que rangeOfString renvoie la longueur de 0; un code plus fiable est donc le suivant:
- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
if(otherString && [string rangeOfString:otherString].length)
return YES;
else
return NO;
}
OU SIMPLEMENT:
- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
return (otherString && [string rangeOfString:otherString].length);
}
qui reviendra pour les cas 1 et 2
does string contains string - NO
C'est mes 2 centimes ;-)
S'il vous plaît vérifier mon Gist pour plus de code utile.
Une version améliorée de la solution de P i , une catégorie sur NSString, qui non seulement dira, si une chaîne est trouvé dans une autre chaîne, mais prend également une plage par référence, est:
@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
Utilisez-le comme:
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));
}
Voici un extrait de fonction copier-coller:
-(BOOL)Contains:(NSString *)StrSearchTerm on:(NSString *)StrText
{
return [StrText rangeOfString:StrSearchTerm
options:NSCaseInsensitiveSearch].location != NSNotFound;
}
Oneliner (Plus petite quantité de code. DRY, car vous n'avez qu'un seul NSLog):
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
}
Meilleure solution. Aussi simple que ça! Si vous voulez trouver un mot ou une partie de la chaîne. Vous pouvez utiliser ce code. Dans cet exemple, nous allons vérifier si la valeur de Word contient "acter".
NSString *Word =@"find a Word or character here";
if ([Word containsString:@"acter"]){
NSLog(@"It contains acter");
} else {
NSLog (@"It does not contain acter");
}
essaye ça,
NSString *string = @"test Data";
if ([[string lowercaseString] rangeOfString:@"data"].location == NSNotFound)
{
NSLog(@"string does not contain Data");
}
else
{
NSLog(@"string contains data!");
}
En cas de Swift, cela peut être utilisé
let string = "Package #23"
if string.containsString("Package #") {
//String contains substring
}
else {
//String does not contain substring
}
Dans Swift 4:
let a = "Hello, how are you?"
a.contains("Hello") //will return true
Si vous en avez besoin une fois, écrivez:
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;
Si vous ne vous souciez pas de la chaîne de caractères sensible à la casse. Essayez ceci une fois.
NSString *string = @"Hello World!";
if([string rangeOfString:@"hello" options:NSCaseInsensitiveSearch].location !=NSNotFound)
{
NSLog(@"found");
}
else
{
NSLog(@"not found");
}
Utilisez l'option NSCaseInsensitiveSearch avec 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
}
Le résultat de sortie est trouvé: oui
Les options peuvent être regroupées et comprennent:
NSCaseInsensitiveSearch NSLiteralSearch NSBackwardsSearch et plus
S'il vous plaît utiliser ce code
NSString *string = @"hello bla bla";
if ([string rangeOfString:@"bla"].location == NSNotFound)
{
NSLog(@"string does not contain bla");
}
else
{
NSLog(@"string contains bla!");
}
La première chaîne contient ou non la deuxième chaîne,
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 et ci-dessus
let str = "Hello iam midhun"
if str.contains("iam") {
//contain substring
}
else {
//doesn't contain substring
}
Essaye ça:
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");
}
pour Objective-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");
}