Bagaimana cara saya memeriksa apakah sebuah string berisi string lain di Swift?

Dalam Objective-Ckode untuk memeriksa substring di NSStringis:

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

Tetapi bagaimana saya melakukan ini di Swift?

Anda dapat melakukan panggilan yang persis sama dengan Swift:

Swift 4 & Swift 5

Dalam Swift 4 String adalah kumpulan Characternilai, tidak seperti ini di Swift 2 dan 3, jadi Anda dapat menggunakan kode ^{1 yang} lebih ringkas ini :

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

Swift Tua

var string = "hello Swift"

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

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

Saya harap ini adalah solusi yang membantu karena beberapa orang, termasuk saya, mengalami beberapa masalah aneh dengan menelepon containsString(). ¹

PS. Jangan lupaimport Foundation

Catatan kaki

1. Ingatlah bahwa menggunakan fungsi koleksi pada Strings memiliki beberapa case tepi yang dapat memberikan Anda hasil yang tidak terduga, misalnya ketika berhadapan dengan emoji atau kelompok grafem lainnya seperti huruf beraksen.

Cara ekstensi

Cepat 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

Umumnya Swift 4 memiliki mengandung metode namun tersedia dari iOS 8.0+

Cepat 3.1

Anda dapat menulis ekstensi contains:dan containsIgnoringCaseuntukString

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

Versi Swift yang lebih lama

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

Contoh:

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

Dari dokumen, tampaknya memanggil containsString()String seharusnya berfungsi:

Tipe String Swift dijembatani dengan mulus ke kelas NSString Foundation. Jika Anda bekerja dengan kerangka kerja Foundation di Cocoa atau Cocoa Touch, seluruh NSString API tersedia untuk memanggil nilai String apa pun yang Anda buat, selain fitur String yang dijelaskan dalam bab ini. Anda juga dapat menggunakan nilai String dengan API apa pun yang membutuhkan instance NSString.

Namun, sepertinya tidak bekerja seperti itu.

Jika Anda mencoba menggunakan someString.containsString(anotherString), Anda akan mendapatkan kesalahan waktu kompilasi yang menyatakan 'String' does not contain a member named 'containsString'.

Jadi, Anda memiliki beberapa opsi, salah satunya adalah secara eksplisit menjembatani Anda Stringke Objective-C dengan menggunakan bridgeToObjectiveC()dua lainnya melibatkan secara eksplisit menggunakan NSStringdan yang terakhir melibatkan casting StringkeNSString

Dengan menjembatani, Anda akan mendapatkan:

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

Dengan mengetik string secara eksplisit sebagai NSString, Anda akan mendapatkan:

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

Jika Anda sudah ada String, Anda dapat menginisialisasi NSString dari itu dengan menggunakan NSString (string :):

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

Dan akhirnya, Anda bisa melemparkan yang sudah ada Stringke NSStringseperti di bawah ini

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

Yang lainnya. Mendukung opsi case dan diakritik.

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

Pemakaian

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

iOS 9+

Fungsi case dan diacritic insensitive tersedia sejak iOS 9.

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

Pada Xcode 7.1 dan Swift 2.1 containsString()bekerja dengan baik untuk saya.

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

Swift 4:

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

Dan case Swift 4 yang tidak sensitif contoh:

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

Atau menggunakan Stringekstensi case sensitif :

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

Dalam Swift 4.2

Menggunakan

func contains(_ str: String) -> Bool

Contoh

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

> DALAM SWIFT 3.0

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

Keluaran

String Contains Another String

Anda dapat melakukannya dengan sangat mudah di Swift menggunakan kode:

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

Hanya tambahan untuk jawaban di sini.

Anda juga dapat melakukan tes tidak sensitif case lokal menggunakan:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Contoh:

    import Foundation

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

MEMPERBARUI

Ini adalah bagian dari Foundation Framework untuk iOS & Mac OS X 10.10.x dan merupakan bagian dari 10.10 pada Saat Posting asli saya.

Document Generated: 2014-06-05 12:26:27 -0700 Catatan Rilis OS X Hak Cipta © 2014 Apple Inc. Semua Hak Dilindungi Undang-Undang.

OS X 10.10 Catatan Rilis Kerangka Kerja Cocoa Foundation

NSString sekarang memiliki dua metode kenyamanan berikut:

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

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

Ini adalah tikaman pertamaku di taman bermain cepat ini. Saya memperluas String dengan menyediakan dua fungsi baru (berisi dan berisiIgnoreCase)

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

Gunakan seperti ini

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

Saya akan menyambut umpan balik :)

Dari semua jawaban di sini, saya pikir mereka tidak bekerja, atau mereka sedikit peretasan (kembali ke NSString). Sangat mungkin bahwa jawaban yang benar untuk ini telah berubah dengan rilis beta yang berbeda.

Inilah yang saya gunakan:

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

"! = Nil" menjadi wajib dengan Beta 5.

Anda disini:

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

Anda tidak perlu menulis kode khusus untuk ini. Mulai dari versi 1.2 Swift telah memiliki semua metode yang Anda butuhkan:

• mendapatkan panjang string: count(string);
• memeriksa apakah string berisi substring: contains(string, substring);
• memeriksa apakah string dimulai dengan substring: startsWith(string, substring)
• dan sebagainya.

Dalam Swift 3

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

Ini dia! Siap untuk Xcode 8 dan 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 hanya tersedia di 10.10 Yosemite (dan mungkin iOS8). Juga menjembatani ke crash ObjectiveC di 10.9. Anda mencoba meneruskan NSString ke NSCFString. Saya tidak tahu bedanya, tapi saya bisa mengatakan 10,9 barfs ketika mengeksekusi kode ini dalam aplikasi OS X 10.9.

Berikut perbedaan di Swift dengan 10.9 dan 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html contentString hanya tersedia di 10.10

Range of String di atas berfungsi dengan baik pada 10.9. Saya menemukan pengembangan pada 10.9 sangat stabil dengan Xcode beta2. Saya tidak menggunakan taman bermain melalui atau versi baris perintah dari taman bermain. Saya menemukan jika kerangka kerja yang tepat diimpor autocomplete sangat membantu.

Dengan dan sintaks baru di swift 4 Anda bisa saja

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

string adalah variabel string Anda

Versi Xcode 8 / Swift 3:

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

Anda juga dapat menggunakan contains:

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

Periksa apakah mengandung 'Hello'

let s = "Hello World"

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

Swift 4 cara untuk memeriksa substring, termasuk impor kerangka kerja yang diperlukan Foundation(atau 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

Kecuali Foundation(atau UIKit) framework diimpor, str.contains("Can")akan memberikan kesalahan kompiler.

Jawaban ini adalah memuntahkan jawaban manojlds , yang sepenuhnya benar. Saya tidak tahu mengapa begitu banyak jawaban melalui begitu banyak masalah untuk buat ulang Foundation's String.contains(subString: String)metode.

// 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: Di sini Anda dapat melihat ekstensi pencarian pintar saya dari string yang memungkinkan Anda melakukan pencarian pada string untuk melihat apakah mengandung, atau mungkin untuk memfilter koleksi berdasarkan pada teks pencarian.

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

Di iOS 8 dan yang lebih baru, Anda dapat menggunakan dua NSStringmetode ini:

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

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

Saya telah menemukan beberapa kasus penggunaan yang menarik. Varian ini menggunakan metode rangeOfString dan saya menyertakan contoh kesetaraan untuk menunjukkan cara terbaik menggunakan fitur pencarian dan perbandingan Strings in Swift 2.0

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

Kemudian setelah saya membuat perubahan pada self.myObject, saya bisa merujuk ke rutin perbandingan string berikut (setup sebagai variabel malas yang mengembalikan Bool). Ini memungkinkan seseorang untuk memeriksa keadaan kapan saja.

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

Varian ini terjadi ketika kadang-kadang saya perlu menganalisis properti yang hilang pada objek itu. Pencarian string memungkinkan saya menemukan substring tertentu yang disetel ke nil (default saat objek dibuat).

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

Jika Anda ingin memeriksa bahwa satu String berisi Sub-String lain di dalamnya atau tidak, Anda dapat memeriksanya seperti ini juga,

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

Sekarang, dalam string khusus ini jika Anda ingin tahu apakah itu mengandung nama buah 'apel' atau tidak,

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

Semoga ini berhasil untuk Anda.

Anda bisa melakukan apa yang telah Anda sebutkan:

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

Dari dokumen:

StringTipe Swift dijembatani dengan mulus ke NSString kelas Foundation . Jika Anda bekerja dengan kerangka kerja Foundation di Cocoa atau Cocoa Touch, seluruh NSStringAPI tersedia untuk meminta Stringnilai apa pun yang Anda buat, selain fitur String yang dijelaskan dalam bab ini. Anda juga dapat menggunakan nilai String dengan API apa pun yang membutuhkan instance NSString.

Anda perlu import Foundationmenjembatani NSStringmetode dan membuatnya tersedia untuk kelas String Swift.

SWIFT 4 sangat mudah !!

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