ฉันจะตรวจสอบว่าสตริงมีสตริงอื่นใน Swift ได้อย่างไร

ในObjective-Cรหัสเพื่อตรวจสอบสตริงย่อยในการNSStringคือ:

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

แต่ฉันจะทำสิ่งนี้ใน Swift ได้อย่างไร

คุณสามารถโทรได้เหมือนกันกับ Swift:

Swift 4 & Swift 5

ใน Swift 4 String คือชุดของCharacterค่ามันไม่ได้เป็นอย่างนี้ใน Swift 2 และ 3 ดังนั้นคุณสามารถใช้รหัสที่รัดกุมกว่านี้¹ :

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

เก่ากว่ารวดเร็ว

var string = "hello Swift"

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

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

containsString()ฉันหวังว่านี้เป็นวิธีการแก้ปัญหาที่เป็นประโยชน์ตั้งแต่บางคนรวมทั้งผมพบปัญหาบางอย่างแปลกโดยการเรียก ¹

PS อย่าลืมimport Foundation

เชิงอรรถ

1. เพียงจำไว้ว่าการใช้ฟังก์ชั่นการเก็บรวบรวมบน Strings มีกรณีขอบบางอย่างที่สามารถให้ผลลัพธ์ที่ไม่คาดคิดเช่นเมื่อจัดการกับอิโมจิหรือกลุ่มกราฟอื่น ๆ เช่นตัวอักษรเน้นเสียง

วิธีการขยาย

สวิฟท์ 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

โดยทั่วไป Swift 4 มีวิธีการ แต่สามารถใช้ได้จาก iOS 8.0+

สวิฟท์ 3.1

คุณสามารถเขียนส่วนขยายcontains:และcontainsIgnoringCaseสำหรับ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 
   }
 }

เวอร์ชั่นเก่าของ 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
     }
}

ตัวอย่าง:

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

จากเอกสารดูเหมือนว่าการเรียกcontainsString()ใช้สตริงควรทำงาน:

ประเภทสตริงของ Swift เชื่อมโยงอย่างราบรื่นกับคลาส NSString ของมูลนิธิ หากคุณกำลังทำงานกับเฟรมเวิร์กของมูลนิธิใน Cocoa หรือ Cocoa Touch ทั้ง NSString API จะพร้อมใช้งานเพื่อเรียกใช้ค่าสตริงใด ๆ ที่คุณสร้างนอกเหนือจากคุณสมบัติสตริงที่อธิบายไว้ในบทนี้ คุณยังสามารถใช้ค่า String กับ API ใด ๆ ที่ต้องการอินสแตนซ์ NSString

อย่างไรก็ตามดูเหมือนว่าจะไม่ได้ผลเช่นนั้น

ถ้าคุณพยายามที่จะใช้คุณจะได้รับข้อผิดพลาดรวบรวมเวลาที่ระบุsomeString.containsString(anotherString)'String' does not contain a member named 'containsString'

ดังนั้นคุณเหลือตัวเลือกไม่มากซึ่งหนึ่งในนั้นคือการเชื่อมโยงของคุณStringกับ Objective-C bridgeToObjectiveC()อย่างชัดเจนโดยการใช้อีกสองรายการที่เกี่ยวข้องอย่างชัดเจนโดยใช้NSStringและสุดท้ายที่เกี่ยวข้องกับการหล่อStringเพื่อNSString

คุณจะได้รับ:

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

โดยการพิมพ์สตริงอย่างชัดเจนNSStringคุณจะได้รับ:

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

หากคุณมีอยู่Stringแล้วคุณสามารถเริ่มต้น NSString จากมันโดยใช้ NSString (string :):

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

และในที่สุดคุณสามารถส่งที่มีอยู่Stringให้NSStringกับด้านล่าง

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

อีกอันหนึ่ง รองรับตัวเลือก case และ diacritic

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

การใช้

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

iOS 9+

ฟังก์ชั่น case และ diacritic insensitive มีให้ตั้งแต่ iOS 9

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

ตั้งแต่ Xcode 7.1 และ Swift 2.1 containsString()นั้นใช้งานได้ดีสำหรับฉัน

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

สวิฟท์ 4:

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

และตัวอย่างของ Swift 4 ที่ไม่คำนึงถึงขนาดตัวพิมพ์:

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

หรือใช้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

ใน Swift 4.2

ใช้

func contains(_ str: String) -> Bool

ตัวอย่าง

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

> ใน SWIFT 3.0

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

เอาท์พุต

String Contains Another String

คุณสามารถทำได้อย่างง่ายดายใน Swift โดยใช้รหัส:

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

เป็นเพียงแค่ภาคผนวกของคำตอบที่นี่

คุณยังสามารถทำการทดสอบแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่โดยใช้:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

ตัวอย่าง:

    import Foundation

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

UPDATE

นี่เป็นส่วนหนึ่งของ Foundation Framework สำหรับ iOS และMac OS X 10.10.x และเป็นส่วนหนึ่งของ 10.10 ณ เวลาที่โพสต์ดั้งเดิมของฉัน

สร้างเอกสาร: 2014-06-05 12:26:27 -0700 หมายเหตุการวางจำหน่าย OS X ลิขสิทธิ์© 2014 Apple Inc. สงวนลิขสิทธิ์

บันทึกประจำรุ่น OS X 10.10กรอบงานของมูลนิธิโกโก้

NSString มีวิธีอำนวยความสะดวกสองวิธีต่อไปนี้:

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

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

นี่คือแทงครั้งแรกของฉันที่นี่ในสนามเด็กเล่นที่รวดเร็ว ฉันขยาย String โดยการให้ฟังก์ชั่นใหม่สองฟังก์ชั่น (ประกอบด้วยและ containIgnoreCase)

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

ใช้มันแบบนี้

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

ฉันยินดีรับข้อเสนอแนะใด ๆ :)

จากคำตอบทั้งหมดที่นี่ฉันคิดว่าพวกเขาอาจไม่ทำงานหรือพวกเขาอาจแฮ็คเล็กน้อย (ส่งกลับไปที่ NSString) มีโอกาสมากที่คำตอบที่ถูกต้องสำหรับสิ่งนี้จะเปลี่ยนไปด้วยรุ่นเบต้าที่แตกต่าง

นี่คือสิ่งที่ฉันใช้:

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

"! = nil" จำเป็นต้องใช้กับ Beta 5

อยู่นี่ไง:

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

คุณไม่จำเป็นต้องเขียนรหัสที่กำหนดเองสำหรับสิ่งนี้ เริ่มต้นจากรุ่น 1.2 Swift มีวิธีการทั้งหมดที่คุณต้องการแล้ว:

• รับความยาวสตริง: count(string);
• การตรวจสอบว่าสตริงมีสตริงย่อย: contains(string, substring);
• การตรวจสอบว่าสตริงเริ่มต้นด้วยซับสตริงหรือไม่: startsWith(string, substring)
• และอื่น ๆ.

ใน Swift 3

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

ไปเลย! พร้อมสำหรับ Xcode 8 และ 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.containString มีให้เฉพาะใน 10.10 Yosemite (และอาจเป็น iOS8) รวมทั้งเชื่อมโยงไปยัง ObjectiveC ขัดข้องใน 10.9 คุณกำลังพยายามส่ง NSString ไปยัง NSCFString ฉันไม่ทราบความแตกต่าง แต่ฉันสามารถพูดได้ 10.9 barfs เมื่อรันโค้ดนี้ในแอป OS X 10.9

นี่คือความแตกต่างใน Swift ที่มี 10.9 และ 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html containStringมีเฉพาะใน 10.10 เท่านั้น

ช่วงของ String ด้านบนใช้งานได้ดีใน 10.9 ฉันพบว่าการพัฒนาบน 10.9 นั้นเสถียรมากกับ Xcode beta2 ฉันไม่ได้ใช้สนามเด็กเล่นหรือสนามเด็กเล่นในบรรทัดคำสั่ง ฉันพบว่าเฟรมเวิร์กที่เหมาะสมนำเข้าการเติมข้อความอัตโนมัตินั้นมีประโยชน์มากหรือไม่

ด้วยและไวยากรณ์ใหม่ใน swift 4 คุณสามารถทำได้

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

string เป็นตัวแปรสตริงของคุณ

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

คุณยังสามารถใช้contains:

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

ตรวจสอบว่ามันมี 'สวัสดี'

let s = "Hello World"

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

Swift 4วิธีในการตรวจสอบวัสดุพิมพ์รวมถึงการนำเข้ากรอบงานที่จำเป็นFoundation(หรือ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

หากไม่มีการนำเข้าเฟรมเวิร์กFoundation(หรือUIKit) str.contains("Can")จะทำให้เกิดข้อผิดพลาดของคอมไพเลอร์

คำตอบนี้เป็นการสำรอกคำตอบของ manojldsซึ่งถูกต้องสมบูรณ์ ผมมีความคิดว่าทำไมคำตอบมากมายเพื่อไปผ่านปัญหามากในการสร้างFoundation's 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: ที่นี่คุณสามารถเห็นสตริงส่วนขยายการค้นหาอัจฉริยะของฉันที่ช่วยให้คุณค้นหาสตริงเพื่อดูว่ามีหรือไม่หรืออาจกรองชุดตามข้อความค้นหา

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

ใน iOS 8 และใหม่กว่าคุณสามารถใช้สองNSStringวิธีต่อไปนี้:

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

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

ฉันพบกรณีการใช้งานที่น่าสนใจสองสามข้อ ตัวแปรเหล่านี้ใช้ประโยชน์จากวิธี rangeOfString และฉันได้รวมตัวอย่างความเท่าเทียมกันเพื่อแสดงว่าใครจะใช้คุณลักษณะการค้นหาและการเปรียบเทียบของ Strings in Swift 2.0 ได้ดีที่สุด

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

ต่อมาหลังจากที่ฉันทำการเปลี่ยนแปลงกับ self.myObject ฉันสามารถอ้างถึงรูทีนการเปรียบเทียบสตริงต่อไปนี้ (การตั้งค่าเป็นตัวแปรที่ขี้เกียจที่ส่งคืน Bool) นี้ช่วยให้หนึ่งเพื่อตรวจสอบสถานะได้ตลอดเวลา

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

ตัวแปรนี้เกิดขึ้นเมื่อบางครั้งฉันต้องการวิเคราะห์คุณสมบัติที่หายไปของวัตถุนั้น การค้นหาสตริงช่วยให้ฉันค้นหาสตริงย่อยเฉพาะที่ถูกตั้งค่าเป็นศูนย์ (ค่าเริ่มต้นเมื่อสร้างวัตถุ)

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

หากคุณต้องการตรวจสอบว่าสตริงหนึ่งมีซับสตริงอื่นอยู่ภายในหรือไม่คุณสามารถตรวจสอบได้เช่นนี้

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

ตอนนี้ในสตริงนี้โดยเฉพาะถ้าคุณต้องการที่จะรู้ว่ามันมีชื่อผลไม้ 'แอปเปิ้ล' หรือไม่ที่คุณสามารถทำได้

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

หวังว่านี่จะเป็นประโยชน์สำหรับคุณ

คุณสามารถทำสิ่งที่คุณพูดถึง:

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

จากเอกสาร:

Stringประเภทของ Swift นั้นเชื่อมโยงกับNSString ชั้นเรียนของมูลนิธิอย่างราบรื่น หากคุณกำลังทำงานกับเฟรมเวิร์กพื้นฐานใน Cocoa หรือ Cocoa Touch NSStringAPI ทั้งหมดจะพร้อมใช้งานเพื่อเรียกใช้Stringค่าใด ๆ ที่ คุณสร้างนอกเหนือจากคุณสมบัติสตริงที่อธิบายไว้ในบทนี้ คุณยังสามารถใช้ค่า String กับ API ใด ๆ ที่ต้องการอินสแตนซ์ NSString

คุณต้องimport Foundationเชื่อมNSStringวิธีต่างๆและทำให้ใช้ได้กับคลาส String ของ Swift

SWIFT 4 นั้นง่ายมาก !!

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