Jak sprawdzić, czy ciąg znaków zawiera inny ciąg znaków w języku Swift?

Sposób rozszerzenia

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

Ogólnie Swift 4 mA zawiera metodę Jednak jest dostępny od iOS 8.0 +

Swift 3.1

Możesz zapisać rozszerzenie contains: i containsIgnoringCase dla 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 
   }
 }

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

przykład:

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

Z dokumentów wynika, że wywołanie containsString() na łańcuchu powinno działać:

Typ strun Swifta jest bezproblemowo łączony z Nsstringiem Fundacji klasy. Jeśli pracujesz z frameworkiem Fundacji w Cocoa lub Cocoa Touch, cały API NSString jest dostępny do wywołania na dowolnym Wartość łańcuchowa, którą tworzysz, oprócz opisanych funkcji łańcuchowych w tym rozdziale. Możesz również użyć wartości łańcuchowej z dowolnym API, które wymaga NSString przykład.

To jednak nie działa w ten sposób.

Jeśli spróbujesz użyć someString.containsString(anotherString), otrzymasz błąd czasu kompilacji, który stwierdza 'String' does not contain a member named 'containsString'.

Zostaje Ci więc kilka opcji, z których jedną jest jawne połączenie {[7] } z Objective-C poprzez użycie bridgeToObjectiveC() pozostałe dwie obejmują jawne użycie NSString, a ostatnia polega na rzuceniu String na NSString

Poprzez pomost otrzymałbyś:

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

Poprzez jawne wpisanie ciągu znaków jako NSString, dostałbyś:

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

Jeśli masz istniejącą String, możesz zainicjować NSString używając NSString(string:):

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

I na koniec możesz rzucić istniejące {[7] } na NSString jak poniżej

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

Kolejny. Obsługuje opcje case i diakrytyczne.

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

Użycie

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

IOS 9 +

Funkcja niewrażliwa na wielkość liter i znaki diakrytyczne dostępna od iOS 9.

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

Od Xcode 7.1 i Swift 2.1 containsString() działa dobrze dla mnie.

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

Swift 4:

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

Oraz niewrażliwy na wielkość liter przykład Swift 4:

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

Lub użycie rozszerzenia niewrażliwego na wielkość liter String:

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

W Swift 4.2

Użyj

func contains(_ str: String) -> Bool

Przykład

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

> W SWIFT 3.0

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

Wyjście

String Contains Another String

Możesz to zrobić bardzo łatwo w Swift używając kodu:

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

To tylko dodatek do odpowiedzi tutaj.

Możesz również wykonać lokalny test bez rozróżniania wielkości liter używając:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Przykład:

    import Foundation

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

UPDATE

Dokument wygenerowany: 2014-06-05 12: 26: 27 -0700 OS X Release Notes Copyright © 2014 Apple Inc. Wszelkie Prawa Zastrzeżone.

OS X 10.10 Release Uwagi Cocoa Foundation Framework

NSString ma teraz następujące dwie metody wygody:

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

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

Oto mój pierwszy cios na placu zabaw swift. I extend String by providing two new functions (contains and containsIgnoreCase)

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

Użyj go w ten sposób

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

Z zadowoleniem przyjmę wszelkie opinie:)

Ze wszystkich odpowiedzi tutaj, myślę, że albo nie działają, albo są trochę hack (rzucanie z powrotem do NSString). Jest bardzo prawdopodobne, że poprawna odpowiedź na to pytanie zmieniła się wraz z różnymi wydaniami beta.

Oto czego używam:

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

"!= nil " stało się Wymagane z Beta 5.

Tu jesteś:

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

Nie musisz pisać żadnego niestandardowego kodu do tego. Począwszy od wersji 1.2 Swift ma już wszystkie potrzebne metody:

• uzyskanie długości łańcucha: count(string);
• sprawdzanie, czy łańcuch zawiera podłańcuch: contains(string, substring);
• sprawdzanie, czy łańcuch zaczyna się od podłańcucha: startsWith(string, substring)
• i itp.

W Swift 3

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

Proszę bardzo! Gotowy na Xcode 8 i 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 jest dostępny tylko w wersji 10.10 Yosemite (i prawdopodobnie iOS8). Również pomostowanie go do ObjectiveC crashes w 10.9. Próbujesz przekazać NSString do NSCFString. Nie znam różnicy, ale mogę powiedzieć 10.9 barfs, gdy wykonuje ten kod w aplikacji OS X 10.9.

Oto różnice w Swift z 10.9 i 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html containsString jest dostępny tylko w wersji 10.10

Range of String above działa świetnie na 10.9. Uważam, że rozwój na 10.9 jest super stabilny z Xcode beta2. Nie używam placów zabaw za pośrednictwem lub wersji wiersza poleceń place zabaw. Uważam, że jeśli importowane są odpowiednie frameworki, autocomplete jest bardzo pomocne.

Z nową składnią w swift 4 możesz po prostu

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

String jest twoją zmienną string

Xcode 8/Swift 3 wersja:

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

Możesz również użyć contains:

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

Sprawdź czy zawiera "Hello"

let s = "Hello World"

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

Swift 4 sposób sprawdzania podciągów, w tym niezbędnych Foundation (lub UIKit) Framework import:

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

O ile Foundation (lub UIKit) framework nie zostanie zaimportowany, str.contains("Can") spowoduje błąd kompilatora.

Ta odpowiedź jest zwracająca odpowiedź manojldsa , która jest całkowicie poprawna. Nie mam pojęcia, dlaczego tak wiele odpowiedzi zadaje sobie tyle trudu, aby odtworzyć metodę Foundation String.contains(subString: String).

// 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: Tutaj możesz zobaczyć moje Inteligentne rozszerzenie wyszukiwania ciągów, które pozwala na wyszukiwanie na ciągach, aby sprawdzić, czy Zawiera, a może filtrować kolekcję na podstawie szukanego tekstu.

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

W iOS 8 i nowszych możesz użyć tych dwóch metod NSString:

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

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

Znalazłem kilka ciekawych przypadków użycia. Warianty te wykorzystują metodę rangeOfString i załączam przykład równości, aby pokazać, w jaki sposób można najlepiej wykorzystać funkcje wyszukiwania i porównywania łańcuchów w Swift 2.0

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

Później, gdy dokonam zmian w sobie.myObject, mogę odnieść się do następujące procedury porównywania łańcuchów (konfiguracja jako zmienne leniwe, które return a Bool). Pozwala to na sprawdzenie stanu w dowolnym momencie.

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

A wariant tego dzieje się, gdy czasami muszę przeanalizować brakujące własność tego obiektu. Wyszukiwanie ciągów pozwala mi znaleźć określony podłańcuch jest ustawiony na nil (domyślne przy wytworzeniu obiektu).

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

Jeśli chcesz sprawdzić, czy jeden łańcuch zawiera inny pod-Łańcuch wewnątrz niego, czy nie, możesz to sprawdzić również w ten sposób,

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

Teraz, w tym konkretnym ciągu, jeśli chcesz wiedzieć, czy zawiera nazwę owocu "jabłko", czy nie możesz zrobić,

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

Możesz po prostu zrobić to, o czym wspomniałeś:

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

From the docs:

Typ Swifta String jest bezproblemowo łączony z typem Fundacji NSString klasy. Jeśli pracujesz z frameworkiem Fundacji w Cocoa lub Cocoa Touch, cały API NSString jest dostępny do wywołania na dowolnym String wartość, którą tworzysz, oprócz opisanych funkcji łańcuchowych w tym rozdziale. Możesz również użyć wartości łańcuchowej z dowolnym API, które wymaga wystąpienia NSString.

Potrzebujesz aby import Foundation pomostować metody NSString i udostępnić je klasie String Swifta.

SWIFT 4 jest bardzo prosty!!

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