Wie überprüfe ich, ob ein String in Swift einen anderen String enthält?

Question

In Objective-C lautet der Code zum Überprüfen eines Teilstrings in einem NSString:

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

Aber wie mache ich das in Swift?

Answer 1

Sie können genau denselben Aufruf mit Swift machen:

Swift 4 & Swift 5

In Swift 4 ist String eine Sammlung von Character-Werten, in Swift 2 und 3 war dies nicht der Fall, daher können Sie diesen prägnanteren Code verwenden1:

let string = "Hallo Swift"
if string.contains("Swift") {
    print("existiert")
}

Swift 3.0+

var string = "Hallo Swift"

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

// Alternative: nicht Groß-/Kleinschreibung beachten
if string.lowercased().range(of:"swift") != nil {
    print("existiert")
}

Älteres Swift

var string = "Hallo Swift"

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

// Alternative: nicht Groß-/Kleinschreibung beachten
if string.lowercaseString.rangeOfString("swift") != nil {
    println("existiert")
}

Ich hoffe, diese Lösung hilft, da einige Leute, einschließlich mir, auf seltsame Probleme gestoßen sind, indem sie containsString() aufgerufen haben.1

PS. Vergessen Sie nicht, import Foundation zu verwenden

Fußnoten

1. Bitte denken Sie daran, dass die Verwendung von Sammelfunktionen auf Strings einige besondere Fälle enthält, die zu unerwarteten Ergebnissen führen können, z. B. beim Umgang mit Emojis oder anderen Graphemclustern wie akzentuierten Buchstaben.

Answer 2

Erweiterungsmethode

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 = "Hallo Welt"

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

print(value.containsIgnoringCase(find: "hallo"))    // true
print(value.containsIgnoringCase(find: "Hallo"))    // true
print(value.containsIgnoringCase(find: "bo"))       // false

---

Generell hat Swift 4 die contains Methode, die jedoch ab iOS 8.0 verfügbar ist.

---

Swift 3.1

Sie können die Erweiterung contains: und containsIgnoringCase für String schreiben

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 
   }
 }

---

Ältere Swift-Version

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
     }
}

---

Beispiel:

var value = "Hallo Welt"

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

print(value.containsIgnoringCase("hallo"))    // true
print(value.containsIgnoringCase("Hallo"))    // true
print(value.containsIgnoringCase("bo"))       // false

Answer 3

Aus den Dokumenten heraus scheint es, dass der Aufruf von containsString() auf einem String funktionieren sollte:

Swift's String-Typ ist nahtlos mit der Foundation-NSString-Klasse verbunden. Wenn Sie mit dem Foundation-Framework in Cocoa oder Cocoa Touch arbeiten, steht Ihnen die gesamte NSString-API zur Verfügung, die auf jedem erstellten String-Wert aufgerufen werden kann, zusätzlich zu den in diesem Kapitel beschriebenen String-Funktionen. Sie können auch einen String-Wert mit jeder API verwenden, die eine NSString-Instanz erfordert.

Es scheint jedoch nicht auf diese Weise zu funktionieren.

Wenn Sie versuchen, someString.containsString(anotherString) zu verwenden, erhalten Sie einen Kompilierungsfehler, der besagt 'String' enhält kein Element namens 'containsString'.

Sie haben also einige Optionen, eine davon besteht darin, Ihren String explizit auf Objective-C zu überbrücken, indem Sie bridgeToObjectiveC() verwenden oder andere zwei beinhalten die explizite Verwendung eines NSString und die letzte erfordert das Umwandeln des String in ein NSString

Durch die Überbrückung würden Sie folgendes erhalten:

var string = "Hallo Swift"
if string.bridgeToObjectiveC().containsString("Swift") {
    println("JA")
}

Durch das explizite Tippen des Strings als NSString erhalten Sie:

var string: NSString = "Hallo Swift"
if string.containsString("Swift") {
    println("JA")
}

Wenn Sie einen vorhandenen String haben, können Sie ein NSString daraus initialisieren, indem Sie NSString(string:) verwenden:

var string = "Hallo Swift"
if NSString(string: string).containsString("Swift") {
    println("JA")
}

Und schließlich können Sie einen vorhandenen String wie folgt in ein NSString umwandeln

var string = "Hallo Swift"
if (string as NSString).containsString("Swift") {
    println("JA")
}

Answer 4

Ein weiterer. Unterstützt Groß-/Kleinschreibung und diakritische Optionen.

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
  }
}

Verwendung

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

iOS 9+

Funktion für Groß-/Kleinschreibung und diakritische Unterscheidung seit iOS 9 verfügbar.

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

Answer 5

Ab Xcode 7.1 und Swift 2.1 containsString() funktioniert gut für mich.

let string = "hallo swift"
if string.containsString("swift") {
    print("swift gefunden")
}

Swift 4:

let string = "hallo swift"
if string.contains("swift") {
    print("swift gefunden")
}

Und ein Beispiel für Swift 4, das nicht zwischen Groß- und Kleinschreibung unterscheidet:

let string = "Hallo Swift"
if string.lowercased().contains("swift") {
    print("swift gefunden")
}

Oder mit einer Groß-/Kleinschreibungs-ignorierenden String-Erweiterung:

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

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

// Konsolenausgabe:
gefunden: SWIFT
string: Hallo Swift
stringToFind: SWIFT