Wie überprüfe ich, ob eine Zeichenfolge in Swift eine andere Zeichenfolge enthält?

In Objective-Cdem Code, der nach einem Teilstring in einem sucht, NSStringist:

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

Aber wie mache ich das in Swift?

Mit Swift können Sie genau den gleichen Anruf tätigen:

Swift 4 & Swift 5

In Swift 4 ist String eine Sammlung von CharacterWerten. In Swift 2 und 3 war dies nicht der Fall. Sie können also diesen prägnanteren Code ^{1 verwenden} :

let string = "hello Swift"
if string.contains("Swift") {
    print("exists")
}

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

Älterer Swift

var string = "hello Swift"

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

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

Ich hoffe, dies ist eine hilfreiche Lösung, da einige Leute, einschließlich mir, durch einen Anruf auf seltsame Probleme gestoßen sind containsString(). ¹

PS. Vergiss es nichtimport Foundation

Fußnoten

1. Denken Sie daran, dass die Verwendung von Erfassungsfunktionen für Zeichenfolgen einige Randfälle aufweist, die zu unerwarteten Ergebnissen führen können, z. B. beim Umgang mit Emojis oder anderen Graphemclustern wie Buchstaben mit Akzent.

Verlängerungsweg

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

Im Allgemeinen enthält Swift 4 eine Methode, die jedoch ab iOS 8.0+ verfügbar ist

Swift 3.1

Sie können Erweiterung contains:und containsIgnoringCasefür schreibenString

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

Aus den Dokumenten geht hervor, dass das Aufrufen containsString()eines Strings funktionieren sollte:

Der String-Typ von Swift wird nahtlos mit der NSString-Klasse von Foundation verbunden. Wenn Sie mit dem Foundation-Framework in Cocoa oder Cocoa Touch arbeiten, kann die gesamte NSString-API zusätzlich zu den in diesem Kapitel beschriebenen String-Funktionen jeden von Ihnen erstellten String-Wert aufrufen. Sie können einen String-Wert auch für jede API verwenden, für die eine NSString-Instanz erforderlich ist.

Es scheint jedoch nicht so zu funktionieren.

Wenn Sie versuchen, zu verwenden someString.containsString(anotherString), wird ein Fehler bei der Kompilierung angezeigt, der besagt 'String' does not contain a member named 'containsString'.

Sie haben also nur noch einige Optionen, von denen eine darin besteht, Ihre Verbindung Stringzu Objective-C explizit zu überbrücken , indem Sie bridgeToObjectiveC()zwei andere verwenden. Dabei wird explizit eine verwendet, NSStringund bei der letzten Option wird die Option Stringin eine umgewandeltNSString

Durch Überbrücken erhalten Sie:

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

Wenn Sie die Zeichenfolge explizit als eingeben NSString, erhalten Sie:

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

Wenn Sie einen vorhandenen haben String, können Sie einen NSString mit NSString (Zeichenfolge :) daraus initialisieren:

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

Und schließlich können Sie eine vorhandene Stringin eine NSStringwie unten umwandeln

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

Noch einer. Unterstützt Fall- 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
  }
}

Verwendungszweck

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

iOS 9+

Groß- und Kleinschreibung und diakritisch unempfindliche Funktion seit iOS 9 verfügbar.

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

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

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

Swift 4:

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

Und ein Swift 4-Beispiel ohne Berücksichtigung der Groß- und Kleinschreibung:

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

Oder verwenden Sie eine StringErweiterung ohne Berücksichtigung der Groß- und Kleinschreibung :

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

In Swift 4.2

Verwenden

func contains(_ str: String) -> Bool

Beispiel

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

> IN SWIFT 3.0

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

Ausgabe

String Contains Another String

Sie können dies in Swift sehr einfach mit dem folgenden Code tun:

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

Nur ein Nachtrag zu den Antworten hier.

Sie können auch einen lokalen Test ohne Berücksichtigung der Groß- und Kleinschreibung durchführen, indem Sie Folgendes verwenden:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Beispiel:

    import Foundation

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

AKTUALISIEREN

Dies ist Teil des Foundation Frameworks für iOS und Mac OS X 10.10.x und war zum Zeitpunkt meiner ursprünglichen Veröffentlichung Teil von 10.10.

Dokument generiert: 2014-06-05 12:26:27 -0700 OS X Versionshinweise Copyright © 2014 Apple Inc. Alle Rechte vorbehalten.

Versionshinweise zu OS X 10.10 Cocoa Foundation Framework

NSString bietet jetzt die folgenden zwei praktischen Methoden:

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

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

Hier ist mein erster Versuch auf dem schnellen Spielplatz. Ich erweitere String durch die Bereitstellung von zwei neuen Funktionen (enthält und enthältIgnoreCase)

extension String {
    func contains(other: String) -> Bool{
        var start = startIndex

        do{
            var subString = self[Range(start: start++, end: endIndex)]
            if subString.hasPrefix(other){
                return true
            }

        }while start != endIndex

        return false
    }

    func containsIgnoreCase(other: String) -> Bool{
        var start = startIndex

        do{
            var subString = self[Range(start: start++, end: endIndex)].lowercaseString
            if subString.hasPrefix(other.lowercaseString){
                return true
            }

        }while start != endIndex

        return false
    }
}

Verwenden Sie es so

var sentence = "This is a test sentence"
sentence.contains("this")  //returns false
sentence.contains("This")  //returns true
sentence.containsIgnoreCase("this")  //returns true

"This is another test sentence".contains(" test ")    //returns true

Ich würde mich über Feedback freuen :)

Von allen Antworten hier denke ich, dass sie entweder nicht funktionieren oder ein bisschen hacken (zurück zu NSString). Es ist sehr wahrscheinlich, dass sich die richtige Antwort darauf mit den verschiedenen Beta-Versionen geändert hat.

Folgendes benutze ich:

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

Das "! = Null" wurde mit Beta 5 benötigt.

Hier sind Sie ja:

let s = "hello Swift"
if let textRange = s.rangeOfString("Swift") {
    NSLog("exists")
}

Sie müssen hierfür keinen benutzerdefinierten Code schreiben. Ab der Version 1.2 verfügt Swift bereits über alle Methoden, die Sie benötigen:

• Stringlänge abrufen : count(string);
• Überprüfen, ob der String einen Teilstring enthält : contains(string, substring);
• Überprüfen, ob der String mit dem Teilstring beginnt: startsWith(string, substring)
• und ETC.

In Swift 3

if((a.range(of: b!, options: String.CompareOptions.caseInsensitive, range: nil, locale: nil)) != nil){
    print("Done")
}

Bitte schön! Bereit für Xcode 8 und Swift 3.

import UIKit

let mString = "This is a String that contains something to search."
let stringToSearchUpperCase = "String"
let stringToSearchLowerCase = "string"

mString.contains(stringToSearchUpperCase) //true
mString.contains(stringToSearchLowerCase) //false
mString.lowercased().contains(stringToSearchUpperCase) //false
mString.lowercased().contains(stringToSearchLowerCase) //true

string.containsString ist nur in 10.10 Yosemite (und wahrscheinlich iOS8) verfügbar. Auch die Überbrückung mit ObjectiveC stürzt in 10.9 ab. Sie versuchen, einen NSString an NSCFString zu übergeben. Ich kenne den Unterschied nicht, aber ich kann 10.9 barfs sagen, wenn dieser Code in einer OS X 10.9-App ausgeführt wird.

Hier sind die Unterschiede in Swift mit 10.9 und 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html enthältString ist nur in 10.10 verfügbar

Der obige String-Bereich funktioniert unter 10.9 hervorragend. Ich finde, dass die Entwicklung auf 10.9 mit Xcode Beta2 super stabil ist. Ich benutze keine Spielplätze durch oder die Kommandozeilenversion von Spielplätzen. Ich finde, wenn die richtigen Frameworks importiert werden, ist die automatische Vervollständigung sehr hilfreich.

Mit und neuer Syntax in Swift 4 können Sie einfach

string.contains("Swift 4 is the best")

Zeichenfolge ist Ihre Zeichenfolgenvariable

Xcode 8 / Swift 3 Version:

let string = "hello Swift"

if let range = string.range(of: "Swift") {
    print("exists at range \(range)")
} else {
    print("does not exist")
}

if let lowercaseRange = string.lowercased().range(of: "swift") {
    print("exists at range \(lowercaseRange)")
} else {
    print("does not exist")
}

Sie können auch verwenden contains:

string.contains("swift") // false
string.contains("Swift") // true

Überprüfen Sie, ob es "Hallo" enthält.

let s = "Hello World"

if s.rangeOfString("Hello") != nil {
    print("Yes it contains 'Hello'")
}

Schnelle 4- Wege-Suche nach Teilzeichenfolgen, einschließlich des erforderlichen Foundation(oder UIKit) Framework-Imports:

import Foundation // or UIKit

let str = "Oh Canada!"

str.contains("Can") // returns true

str.contains("can") // returns false

str.lowercased().contains("can") // case-insensitive, returns true

Wenn kein Foundation(oder UIKit) Framework importiert wird, str.contains("Can")wird ein Compilerfehler ausgegeben.

Diese Antwort spuckt die Antwort von manojlds wieder aus , was völlig richtig ist. Ich habe keine Ahnung , warum so viele Antworten so viel Mühe neu durchlaufen Foundation‚s - String.contains(subString: String)Methode.

// Search string exist in employee name finding.
var empName:NSString! = employeeDetails[filterKeyString] as NSString

Case sensitve search.
let rangeOfSearchString:NSRange! = empName.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch)

// Not found.
if rangeOfSearchString.location != Foundation.NSNotFound
{
    // search string not found in employee name.
}
// Found
else
{
    // search string found in employee name.
}

Swift 3: Hier sehen Sie meine intelligente Sucherweiterung für Zeichenfolgen, mit der Sie nach Zeichenfolgen suchen können, um festzustellen, ob sie enthalten sind, oder um eine Sammlung basierend auf einem Suchtext zu filtern.

https://github.com/magonicolas/Swift-Smart-String-Search

In iOS 8 und höher können Sie diese beiden NSStringMethoden verwenden:

@availability(iOS, introduced=8.0)
func containsString(aString: String) -> Bool

@availability(iOS, introduced=8.0)
func localizedCaseInsensitiveContainsString(aString: String) -> Bool

Ich habe einige interessante Anwendungsfälle gefunden. Diese Varianten verwenden die rangeOfString-Methode, und ich füge das Gleichheitsbeispiel hinzu, um zu zeigen, wie die Such- und Vergleichsfunktionen von Strings in Swift 2.0 am besten verwendet werden können

//In viewDidLoad() I assign the current object description (A Swift String) to self.loadedObjectDescription
self.loadedObjectDescription = self.myObject!.description

Später, nachdem ich Änderungen an self.myObject vorgenommen habe, kann ich auf die folgenden Zeichenfolgenvergleichsroutinen verweisen (Setup als Lazy-Variablen, die einen Bool zurückgeben). Dadurch kann man den Zustand jederzeit überprüfen.

lazy var objectHasChanges : Bool = {
        guard self.myObject != nil else { return false }
        return !(self.loadedObjectDescription == self.myObject!.description)
    }()

Eine Variante davon tritt auf, wenn ich manchmal eine fehlende Eigenschaft für dieses Objekt analysieren muss. Bei einer Zeichenfolgensuche kann ich einen bestimmten Teilstring finden, der auf Null gesetzt ist (die Standardeinstellung beim Erstellen eines Objekts).

    lazy var isMissingProperty : Bool = {
        guard self.myObject != nil else { return true }
        let emptyPropertyValue = "myProperty = nil"
        return (self.myObject!.description.rangeOfString(emptyPropertyValue) != nil) ? true : false
    }()

Wenn Sie überprüfen möchten, ob ein String einen anderen Sub-String enthält oder nicht, können Sie dies auch so überprüfen:

var name = String()  
name = "John has two apples." 

Wenn Sie in dieser speziellen Zeichenfolge wissen möchten, ob sie den Fruchtnamen "Apfel" enthält oder nicht, können Sie Folgendes tun:

if name.contains("apple")      
{  
print("Yes , it contains fruit name")    
}    
else      
{    
 print(it does not contain any fruit name)    
}    

Hoffe das funktioniert bei dir.

Sie können einfach das tun, was Sie erwähnt haben:

import Foundation
...
string.contains("Swift");

Aus den Dokumenten:

Swifts StringTyp ist nahtlos mit der NSString Klasse der Foundation verbunden . Wenn Sie mit dem Foundation-Framework in Cocoa oder Cocoa Touch arbeiten, NSStringsteht Stringzusätzlich zu den in diesem Kapitel beschriebenen String-Funktionen die gesamte API zur Verfügung, um jeden von Ihnen erstellten Wert aufzurufen . Sie können einen String-Wert auch für jede API verwenden, für die eine NSString-Instanz erforderlich ist.

Sie müssen import Foundationdie NSStringMethoden überbrücken und sie der String-Klasse von Swift zur Verfügung stellen.

SWIFT 4 ist sehr einfach !!

if (yourString.contains("anyThing")) {
   Print("Exist")
}