Làm cách nào để kiểm tra xem một chuỗi có chứa chuỗi khác trong Swift không?

Trong Objective-Cmã để kiểm tra một chuỗi con trong một NSStringlà:

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

Nhưng làm thế nào để tôi làm điều này trong Swift?

Bạn có thể thực hiện chính xác cùng một cuộc gọi với Swift:

Swift 4 & Swift 5

Trong Swift 4 String là một tập hợp các Charactergiá trị, nó không giống như trong Swift 2 và 3, vì vậy bạn có thể sử dụng mã ¹ ngắn gọn hơn này :

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 cũ hơn

var string = "hello Swift"

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

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

Tôi hy vọng đây là một giải pháp hữu ích vì một số người, bao gồm cả tôi, đã gặp phải một số vấn đề lạ bằng cách gọi containsString(). ¹

Tái bút Đừng quênimport Foundation

Chú thích

1. Chỉ cần nhớ rằng việc sử dụng các hàm bộ sưu tập trên Chuỗi có một số trường hợp cạnh có thể mang lại cho bạn kết quả không mong muốn, ví dụ như khi xử lý biểu tượng cảm xúc hoặc các cụm biểu đồ khác như các chữ cái có dấu.

Cách mở rộng

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

Nói chung Swift 4 có chứa phương thức tuy nhiên nó có sẵn từ iOS 8.0 trở lên

Swift 3.1

Bạn có thể viết phần mở rộng contains:và containsIgnoringCasechoString

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

Phiên bản Swift cũ hơn

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

Thí dụ:

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

Từ các tài liệu, có vẻ như việc gọi containsString()Chuỗi sẽ hoạt động:

Kiểu Chuỗi của Swift được kết nối liền mạch với lớp NSString của Foundation. Nếu bạn đang làm việc với khung Foundation trong Ca cao hoặc Ca cao cảm ứng, toàn bộ API NSString có sẵn để gọi bất kỳ giá trị Chuỗi nào bạn tạo, ngoài các tính năng Chuỗi được mô tả trong chương này. Bạn cũng có thể sử dụng giá trị Chuỗi với bất kỳ API nào yêu cầu phiên bản NSString.

Tuy nhiên, nó dường như không hoạt động theo cách đó.

Nếu bạn cố gắng sử dụng someString.containsString(anotherString), bạn sẽ nhận được một lỗi thời gian biên dịch 'String' does not contain a member named 'containsString'.

Vì vậy, bạn còn lại một vài lựa chọn, một trong số đó là kết nối rõ ràng Stringvới Objective-C bằng cách sử dụng bridgeToObjectiveC()hai tùy chọn khác liên quan đến việc sử dụng một cách rõ ràng NSStringvà lựa chọn cuối cùng liên quan đến việc truyền StringtớiNSString

Bằng cách bắc cầu, bạn sẽ nhận được:

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

Bằng cách gõ rõ ràng chuỗi là một NSString, bạn sẽ nhận được:

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

Nếu bạn đã có String, bạn có thể khởi tạo NSString từ nó bằng cách sử dụng NSString (chuỗi :):

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

Và cuối cùng, bạn có thể cast một hiện Stringmột NSStringnhư sau

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

Một số khác. Hỗ trợ các tùy chọn trường hợp và dấu phụ.

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

Sử dụng

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

iOS 9+

Chức năng không nhạy cảm trường hợp và dấu phụ có sẵn kể từ iOS 9.

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

Kể từ Xcode 7.1 và Swift 2.1 containsString()đang hoạt động tốt đối với tôi.

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

Swift 4:

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

Và một ví dụ Swift 4 không nhạy cảm:

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

Hoặc sử dụng một Stringphần mở rộng không nhạy cảm trường hợp :

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

Trong Swift 4.2

Sử dụng

func contains(_ str: String) -> Bool

Thí dụ

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

> TRÊN NỀN TẢNG 3.0

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

Đầu ra

String Contains Another String

Bạn có thể làm điều này rất dễ dàng trong Swift bằng cách sử dụng mã:

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

Chỉ là một phụ lục cho các câu trả lời ở đây.

Bạn cũng có thể thực hiện một thử nghiệm không nhạy cảm trường hợp địa phương bằng cách sử dụng:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Thí dụ:

    import Foundation

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

CẬP NHẬT

Đây là một phần của Khung nền tảng cho iOS & Mac OS X 10.10.x và là một phần của 10.10 tại Thời điểm đăng bài gốc của tôi.

Tài liệu được tạo: 2014-06-05 12:26:27 -0700 Ghi chú phát hành OS X Bản quyền © 2014 Apple Inc. Mọi quyền được bảo lưu.

Ghi chú phát hành OS X 10.10 Khung nền tảng ca cao

NSString hiện có hai phương thức tiện lợi sau:

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

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

Đây là cú đâm đầu tiên của tôi vào lúc này trong sân chơi nhanh. Tôi mở rộng String bằng cách cung cấp hai hàm mới (chứa và chứaIgnoreCase)

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

Sử dụng nó như thế này

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

Tôi hoan nghênh mọi phản hồi :)

Trong tất cả các câu trả lời ở đây, tôi nghĩ rằng chúng không hoạt động, hoặc chúng là một chút hack (chuyển trở lại NSString). Rất có khả năng câu trả lời chính xác cho điều này đã thay đổi với các phiên bản beta khác nhau.

Đây là những gì tôi sử dụng:

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

"! = Nil" trở nên bắt buộc với Beta 5.

Của bạn đây:

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

Bạn không cần phải viết bất kỳ mã tùy chỉnh nào cho việc này. Bắt đầu từ phiên bản 1.2 Swift đã có tất cả các phương thức bạn cần:

• độ dài chuỗi: count(string) ;
• kiểm tra xem chuỗi có chứa chuỗi con không: contains(string, substring) ;
• kiểm tra xem chuỗi có bắt đầu bằng chuỗi con không: startsWith(string, substring)
• và vân vân.

Trong Swift 3

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

Bạn đi đây! Sẵn sàng cho Xcode 8 và 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 chỉ khả dụng trong 10.10 Yosemite (và có thể là iOS8). Đồng thời bắc cầu cho ObjectiveC gặp sự cố trong 10.9. Bạn đang cố gắng chuyển NSString sang NSCFString. Tôi không biết sự khác biệt, nhưng tôi có thể nói 10,9 barfs khi nó thực thi mã này trong ứng dụng OS X 10.9.

Dưới đây là những điểm khác biệt trong Swift với 10.9 và 10.10: https://developer.apple.com/l Library / preselease / mac / documentation / General / Reference /APIDiffsMacOSX10_10SeedDiff / index.html chứaString chỉ có sẵn trong 10.10

Phạm vi chuỗi trên hoạt động tuyệt vời vào ngày 10.9. Tôi đang tìm cách phát triển vào ngày 10.9 là siêu ổn định với Xcode beta2. Tôi không sử dụng sân chơi thông qua hoặc phiên bản dòng lệnh của sân chơi. Tôi đang tìm kiếm nếu các khung thích hợp được nhập thì tự động hoàn thành là rất hữu ích.

Với và cú pháp mới trong swift 4, bạn có thể chỉ cần

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

chuỗi là biến chuỗi của bạn

Phiên bản 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")
}

Bạn cũng có thể sử dụng contains:

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

Kiểm tra xem nó có chứa 'Xin chào' không

let s = "Hello World"

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

Swift 4 cách để kiểm tra các chuỗi con, bao gồm nhập khung Foundation(hoặc UIKit) cần thiết :

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

Trừ khi Foundation(hoặc UIKit) khung được nhập, str.contains("Can")sẽ đưa ra lỗi trình biên dịch.

Câu trả lời này đang hồi sinh câu trả lời của manojlds , điều này hoàn toàn chính xác. Tôi không có ý tưởng tại sao rất nhiều câu trả lời đi qua rất nhiều khó khăn để tái Foundation's String.contains(subString: String)phương pháp.

// 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: Tại đây bạn có thể thấy chuỗi fro tiện ích mở rộng tìm kiếm thông minh của tôi cho phép bạn thực hiện tìm kiếm trên chuỗi để xem nó có chứa hay có thể để lọc bộ sưu tập dựa trên văn bản tìm kiếm.

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

Trong iOS 8 trở lên, bạn có thể sử dụng hai NSStringphương pháp sau:

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

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

Tôi đã tìm thấy một vài trường hợp sử dụng thú vị. Các biến thể này sử dụng phương thức RangeOfString và tôi bao gồm ví dụ về đẳng thức để cho thấy cách người ta có thể sử dụng tốt nhất các tính năng tìm kiếm và so sánh của Chuỗi trong Swift 2.0

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

Sau này sau khi tôi thực hiện các thay đổi cho self.myObject, tôi có thể tham khảo các thói quen so sánh chuỗi sau (thiết lập dưới dạng các biến lười biếng trả về Bool). Điều này cho phép một người kiểm tra trạng thái bất cứ lúc nào.

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

Một biến thể của điều này xảy ra khi đôi khi tôi cần phân tích một thuộc tính bị thiếu trên đối tượng đó. Một tìm kiếm chuỗi cho phép tôi tìm một chuỗi con cụ thể được đặt thành nil (mặc định khi một đối tượng được tạo).

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

Nếu bạn muốn kiểm tra xem một Chuỗi có chứa một Chuỗi con khác trong đó hay không, bạn cũng có thể kiểm tra nó như thế này,

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

Bây giờ, trong chuỗi cụ thể này nếu bạn muốn biết liệu nó có chứa tên trái cây 'táo' hay không bạn có thể làm,

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

Hy vọng điều này làm việc cho bạn.

Bạn chỉ có thể làm những gì bạn đã đề cập:

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

Từ các tài liệu:

StringKiểu của Swift được kết nối liền mạch với NSString lớp Foundation . Nếu bạn đang làm việc với khung Foundation trong Ca cao hoặc Ca cao cảm ứng, toàn bộ NSStringAPI có sẵn để gọi bất kỳ Stringgiá trị nào bạn tạo, ngoài các tính năng Chuỗi được mô tả trong chương này. Bạn cũng có thể sử dụng giá trị Chuỗi với bất kỳ API nào yêu cầu phiên bản NSString.

Bạn cần kết import Foundationnối các NSStringphương thức và cung cấp chúng cho lớp String của Swift.

SWift 4 rất dễ dàng !!

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