webentwicklung-frage-antwort-db.com.de

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

In Objective-C lautet der zu prüfende Code in einer NSString

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

Aber wie mache ich das in Swift?

450
Rajneesh071

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

Schnell 4

In Swift 4 String handelt es sich um eine Sammlung von Character-Werten. In Swift 2 und 3 war das nicht so. Daher können Sie diesen prägnanteren Code verwenden1:

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

Ältere 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, dass dies eine hilfreiche Lösung ist, da einige Leute, darunter auch ich, auf seltsame Probleme gestoßen sind, als sie containsString() aufgerufen haben.1

PS. Vergessen Sie nicht, import Foundation

Fußnoten

  1. Denken Sie daran, dass die Verwendung von Erfassungsfunktionen für Strings einige Edge-Fälle hat, die zu unerwarteten Ergebnissen führen können. G. beim Umgang mit Emojis oder anderen Graphem-Clustern wie Buchstaben mit Akzent.
872
Jens Wirth

Erweiterungsweg

Schnell 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 hat Swift 4 enthält Methode, ist jedoch ab iOS 8.0 verfügbar


Schnell 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 = "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
182
Maxim Shoustin

Aus den Dokumenten scheint es, dass der Aufruf von containsString() für einen String funktionieren sollte:

Der String-Typ von Swift wird nahtlos mit dem NSString von Foundation verbunden Klasse. Wenn Sie mit dem Foundation-Framework in Cocoa oder .__ arbeiten. Cocoa Touch, die gesamte NSString-API kann auf jedem beliebigen .__ aufgerufen werden. Von Ihnen erstellter String-Wert zusätzlich zu den beschriebenen String-Features in diesem Kapitel. Sie können einen String-Wert auch mit einer beliebigen API verwenden, die erfordert eine NSString-Instanz.

Es scheint jedoch nicht so zu funktionieren.

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

Sie haben also noch einige Optionen. Eine davon ist die explizite Überbrückung Ihres String mit Objective-C, indem bridgeToObjectiveC() verwendet wird. Bei beiden anderen Methoden wird explizit ein NSString verwendet, und bei dem letzten wird der String in einen NSString verschoben.

Wenn Sie überbrücken, erhalten Sie:

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

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

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

Wenn Sie String besitzen, können Sie einen NSString mit NSString (string :) von dort aus initialisieren:

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

Und schließlich können Sie eine vorhandene String in eine NSString wie folgt umwandeln

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

Noch einer. Unterstützt Fälle 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+

Funktion zur Unterscheidung von Groß- und Kleinschreibung ist seit iOS 9 verfügbar.

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

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

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

Schnell 4: 

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

Und ein case-unempfindliches Swift 4-Beispiel: 

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

Oder verwenden Sie eine String-Erweiterung ohne Berücksichtigung von 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
31
Murray Sagal

In Swift 4.2

Benutzen

func contains(_ str: String) -> Bool

Beispiel

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

> 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
16
Ashok R

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

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

Nur ein Nachtrag zu den Antworten hier.

Sie können auch einen lokalen Test durchführen, bei dem die Groß- und Kleinschreibung nicht berücksichtigt wird:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Beispiel:

    import Foundation

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

[~ # ~] Update [~ # ~]

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

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

Versionshinweise zu OS X 10.1 Cocoa Foundation Framework

NSString bietet jetzt die folgenden zwei praktischen Methoden:

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

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

10
markhunte

Von all den Antworten hier, denke ich, funktionieren sie entweder nicht, oder sie sind ein bisschen hackig (werfen zurück zu NSString). Es ist sehr wahrscheinlich, dass sich die richtige Antwort mit den verschiedenen Betaversionen geändert hat.

Ich verwende Folgendes:

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

Bei Beta 5 wurde das "! = Nil" benötigt.

9
user1021430

Hier ist mein erster Versuch auf dem Swift-Spielplatz .. Ich erweitere String um zwei neue Funktionen (enthält und enthält IgnoreCase)

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 ein Feedback freuen :)

8
Ken

Hier sind Sie ja:

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

In Swift 3

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

Sie müssen dafür keinen benutzerdefinierten Code schreiben. Ab der Version 1.2 verfügte Swift bereits über alle erforderlichen Methoden:

  • stringlänge erhalten: count(string);
  • Überprüfen, ob die Zeichenfolge eine Zeichenfolge enthält: contains(string, substring);
  • Überprüfen, ob die Zeichenfolge mit der Teilzeichenfolge beginnt: startsWith(string, substring)
  • und ETC.
5
Max Ivashkevich

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
4
Carlitos

string.containsString ist nur in 10.10 Yosemite (und wahrscheinlich auch in iOS8) verfügbar. Außerdem wird es mit ObjectiveC verbunden und 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 er diesen Code in einer OS X 10.9-App ausführt. 

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 containsString ist nur in verfügbar 10.10

Der String-Bereich oben funktioniert am 10.9. Ich finde die Entwicklung auf 10.9 ist mit Xcode beta2 super stabil. Ich verwende keine Spielplätze durch oder die Kommandozeilenversion von Spielplätzen. Ich finde, wenn die richtigen Frameworks importiert werden, ist die Autovervollständigung sehr hilfreich.

3
Goodtime

Prüfen Sie, ob es "Hallo" enthält

let s = "Hello World"

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

Swift 4 Methode zur Überprüfung auf Teilzeichenfolgen, einschließlich des erforderlichen Frameworkimports Foundation (oder UIKit): 

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 das Framework Foundation (oder UIKit) nicht importiert wird, gibt str.contains("Can") einen Compiler-Fehler aus.


Diese Antwort ist die Antwort von manojlds , die völlig korrekt ist. Ich habe keine Ahnung, warum so viele Antworten so viel Mühe haben, die String.contains(subString: String)-Methode von Foundation neu zu erstellen.

2
NonCreature0714

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 contains verwenden:

string.contains("Swift") // false
string.contains("Swift") // true
2
JAL

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

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

zeichenfolge ist Ihre Zeichenfolgenvariable

2
100tomer
// 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.
}
1
abhi

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

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

Nun, in dieser bestimmten Zeichenfolge, wenn Sie wissen möchten, ob sie den Fruchtnamen 'Apple' enthält oder nicht,

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

Hoffe, das funktioniert für dich.

0
Varsha Shivhare

Ich habe ein paar interessante Anwendungsfälle gefunden. Diese Varianten verwenden die rangeOfString-Methode, und ich füge das Gleichheitsbeispiel hinzu, um zu zeigen, wie man die Such- und Vergleichsfunktionen von Strings in Swift 2.0 am besten nutzen kann

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

Später, nachdem ich self.myObject geändert habe, kann ich auf die .__ verweisen. folgende Stringvergleichsroutinen (als Lazy-Variablen einrichten, die einen Bool zurückgeben). Dadurch kann der Status jederzeit überprüft werden.

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

Eine Variante davon passiert, wenn ich manchmal ein fehlendes .__ analysieren muss. Eigenschaft für dieses Objekt. Eine Zeichenfolge-Suche ermöglicht es mir, eine .__ zu finden. bestimmte Teilzeichenfolge, die auf null gesetzt ist (der Standardwert, wenn ein Objekt erstellt wird).

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

Swift 3: Hier sehen Sie meine intelligente Sucherweiterung für Zeichenfolge, mit der Sie eine Suche nach Zeichenfolge durchführen können, um zu sehen, ob sie enthält 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 NSString-Methoden verwenden:

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

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