Question Comment vérifier si une chaîne contient une autre chaîne dans Swift?


Dans Objective-C le code pour vérifier une sous-chaîne dans un NSString est:

NSString *string = @"hello Swift";
NSRange textRange =[string rangeOfString:@"Swift"];
if(textRange.location != NSNotFound)
{
    NSLog(@"exists");
}

Mais comment je fais ça dans Swift?


411
2018-06-04 09:43


origine


Réponses:


Vous pouvez faire exactement le même appel avec Swift:

Swift 3.0+

var string = "hello Swift"

if string.range(of:"Swift") != nil { 
    print("exists")
}

// alternative: not case sensitive
if string.lowercased().range(of:"swift") != nil {
    print("exists")
}

Ancien Swift

var string = "hello Swift"

if string.rangeOfString("Swift") != nil{ 
    println("exists")
}

// alternative: not case sensitive
if string.lowercaseString.rangeOfString("swift") != nil {
    println("exists")
}

J'espère que c'est une solution utile car certaines personnes, y compris moi, ont rencontré des problèmes étranges en appelant containsString().

PS. Ne pas oublier de import Foundation


773
2018-06-11 11:34



Manière d'extension

Swift 4

extension String {
    func contains(find: String) -> Bool{
        return self.range(of: find) != nil
    }
    func containsIgnoringCase(find: String) -> Bool{
        return self.range(of: find, options: .caseInsensitive) != nil
    }
}

var value = "Hello world"

print(value.contains("Hello")) // true
print(value.contains("bo"))    // false

print(value.containsIgnoringCase(find: "hello"))    // true
print(value.containsIgnoringCase(find: "Hello"))    // true
print(value.containsIgnoringCase(find: "bo"))       // false

Généralement Swift 4 a contient méthode cependant il est disponible à partir d'iOS 8.0+


Swift 3.1

Vous pouvez écrire l'extension contains: et containsIgnoringCase pour String

extension String { 

   func contains(_ find: String) -> Bool{
     return self.range(of: find) != nil
   }

   func containsIgnoringCase(_ find: String) -> Bool{
     return self.range(of: find, options: .caseInsensitive) != nil 
   }
 }

Version plus ancienne de Swift

extension String {

    func contains(find: String) -> Bool{
       return self.rangeOfString(find) != nil
     }

    func containsIgnoringCase(find: String) -> Bool{
       return self.rangeOfString(find, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil
     }
}

Exemple:

var value = "Hello world"

print(value.contains("Hello")) // true
print(value.contains("bo"))    // false

print(value.containsIgnoringCase("hello"))    // true
print(value.containsIgnoringCase("Hello"))    // true
print(value.containsIgnoringCase("bo"))       // false

155
2017-08-27 09:31



De la docs, il semble que l'appel containsString() sur une chaîne devrait fonctionner:

Le type de chaîne de Swift est relié de manière transparente à NSString de la Fondation   classe. Si vous travaillez avec le framework Foundation dans Cocoa ou   Cocoa Touch, l'API NSString entière est disponible pour appeler n'importe quel   Valeur de chaîne que vous créez, en plus des fonctionnalités de chaîne décrites   dans ce chapitre. Vous pouvez également utiliser une valeur String avec n'importe quelle API   nécessite une instance NSString.

Cependant, cela ne semble pas fonctionner de cette façon.

Si vous essayez d'utiliser someString.containsString(anotherString), vous obtiendrez une erreur de compilation qui indique 'String' does not contain a member named 'containsString'.

Donc, vous êtes parti avec quelques options, dont l’une est de combler votre String à Objective-C en utilisant bridgeToObjectiveC() deux autres impliquent explicitement l'utilisation d'un NSString et le dernier consiste à couler le String à un NSString

En faisant le pont, vous obtenez:

var string = "hello Swift"
if string.bridgeToObjectiveC().containsString("Swift") {
    println("YES")
}

En tapant explicitement la chaîne en tant que NSString, vous auriez:

var string: NSString = "hello Swift"
if string.containsString("Swift") {
    println("YES")
}

Si vous avez un existant String, vous pouvez initialiser un NSString en utilisant NSString (string :):

var string = "hello Swift"
if NSString(string: string).containsString("Swift") {
    println("YES")
}

Et enfin, vous pouvez lancer un existant String à un NSString comme ci-dessous

var string = "hello Swift"
if (string as NSString).containsString("Swift") {
    println("YES")
}

47
2018-06-04 12:32



Un autre. Prend en charge les options de cas et diacritiques.

Swift 3.0

struct MyString {
  static func contains(_ text: String, substring: String,
                       ignoreCase: Bool = true,
                       ignoreDiacritic: Bool = true) -> Bool {

    var options = NSString.CompareOptions()

    if ignoreCase { _ = options.insert(NSString.CompareOptions.caseInsensitive) }
    if ignoreDiacritic { _ = options.insert(NSString.CompareOptions.diacriticInsensitive) }

    return text.range(of: substring, options: options) != nil
  }
}

Usage

MyString.contains("Niels Bohr", substring: "Bohr") // true

iOS 9+

Cas et fonction diacritique insensible disponible depuis iOS 9.

if #available(iOS 9.0, *) {
  "Für Elise".localizedStandardContains("fur") // true
}

35
2018-03-24 02:52



A partir de Xcode 7.1 et Swift 2.1 containsString() fonctionne bien pour moi.

let string = "hello swift"
if string.containsString("swift") {
    print("found swift")
}

Swift 4:

let string = "hello swift"
if string.contains("swift") {
    print("found swift")
}

Et un exemple Swift 4 insensible à la casse:

let string = "Hello Swift"
if string.lowercased().contains("swift") {
    print("found swift")
}

Ou en utilisant un cas insensible String extension:

extension String {
    func containsIgnoreCase(_ string: String) -> Bool {
        return self.lowercased().contains(string.lowercased())
    }
}

let string = "Hello Swift"
let stringToFind = "SWIFT"
if string.containsIgnoreCase(stringToFind) {
    print("found: \(stringToFind)")  // found: SWIFT
}
print("string: \(string)")
print("stringToFind: \(stringToFind)")

// console output:
found: SWIFT
string: Hello Swift
stringToFind: SWIFT

30
2017-11-07 14:32



> IN SWIFT 3.0

let str = "Hello Swift"
if str.lowercased().contains("Swift".lowercased()) {
    print("String Contains Another String")
} else {
    print("Not Exists")
}

Sortie

String Contains Another String

16
2017-11-03 10:12



Vous pouvez le faire très facilement dans Swift en utilisant le code:

let string = "hello Swift";
let subString = (string as NSString).containsString("Swift")
if(subString){println("Exist")}

14
2018-02-18 10:39



Dans Swift 4.0

Utilisation

func contains(_ str: String) -> Bool

Exemple

let string = "hello Swift"
let containsSwift = string.contains("Swift")
print(containsSwift) // prints true

13
2017-08-04 11:51



De toutes les réponses ici, je pense qu'ils ne fonctionnent pas, ou ils sont un peu un hack (renvoyer à NSString). Il est très probable que la réponse correcte à cette question ait changé avec les différentes versions bêta.

Voici ce que j'utilise:

let string: String = "hello Swift"
if string.rangeOfString("Swift") != nil
{
    println("exists")
}

Le "! = Nil" est devenu obligatoire avec Beta 5.


9
2017-08-08 00:37



Juste un addendum aux réponses ici.

Vous pouvez également effectuer un test insensible à la casse locale en utilisant:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Exemple:

    import Foundation

    var string: NSString  =  "hello Swift"
   if string.localizedCaseInsensitiveContainsString("Hello") {
    println("TRUE")
}

METTRE À JOUR

Cela fait partie du Foundation Framework pour iOS & Mac OS X 10.10.x  et faisait partie de 10.10 au moment de ma publication originale.

Document généré le: 2014-06-05 12:26:27 -0700 Notes de mise à jour OS X   Copyright 2014 Apple Inc. Tous droits réservés.

Notes de mise à jour d'OS X 10.10 Cadre de la Fondation du cacao

NSString a maintenant les deux méthodes de commodité suivantes:

- (BOOL)containsString:(NSString *)str;

- (BOOL)localizedCaseInsensitiveContainsString:(NSString *)str; 


7
2017-07-07 09:39