Swift startsWith ด้วยวิธีการ?

มีสิ่งดังกล่าวเป็นวิธี opensWith () หรือสิ่งที่คล้ายกันใน Swift หรือไม่?

ฉันกำลังพยายามตรวจสอบว่าสายบางอย่างเริ่มต้นด้วยสายอื่น ฉันยังต้องการที่จะเป็นกรณีตาย

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

นี่คือสิ่งที่ฉันต้องการ:

การพิมพ์ใน "sa" ควรให้ผลลัพธ์แก่ฉันสำหรับ "San Antonio", "Santa Fe" และอื่น ๆ การพิมพ์ใน "SA" หรือ "Sa" หรือแม้แต่ "sA" ควรกลับด้วย "San Antonio" หรือ "Santa Fe"

ฉันกำลังใช้

self.rangeOfString(find, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil 

ก่อนหน้า iOS9 และมันใช้งานได้ดี อย่างไรก็ตามหลังจากอัพเกรดเป็น iOS9 แล้วก็หยุดทำงานและตอนนี้การค้นหาจะต้องตรงตามตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก

    var city = "San Antonio"
    var searchString = "san "
    if(city.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil){
        print("San Antonio starts with san ");
    }

    var myString = "Just a string with san within it"

    if(myString.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil){
        print("I don't want this string to print bc myString does not start with san ");
    }

ใช้แทนhasPrefixstartsWith

ตัวอย่าง:

"hello dolly".hasPrefix("hello")  // This will return true
"hello dolly".hasPrefix("abc")    // This will return false

นี่คือการติดตั้งส่วนขยาย Swift ของ startsWith:

extension String {

  func startsWith(string: String) -> Bool {

    guard let range = rangeOfString(string, options:[.AnchoredSearch, .CaseInsensitiveSearch]) else {
      return false
    }

    return range.startIndex == startIndex
  }

}

ตัวอย่างการใช้งาน:

var str = "Hello, playground"

let matches    = str.startsWith("hello") //true
let no_matches = str.startsWith("playground") //false

เพื่อที่จะตอบเฉพาะกรณีตายจับคู่คำนำหน้า:

ใน Pure Swift (แนะนำเป็นส่วนใหญ่)

extension String {
    func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
        return lowercased().hasPrefix(prefix.lowercased())
    }
}

หรือ:

extension String {
    func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
        return lowercased().starts(with: prefix.lowercased())
    }
}

หมายเหตุ: สำหรับคำนำหน้าว่างเปล่า ""ทั้งการใช้งานจะกลับมาtrue

ใช้มูลนิธิ range(of:options:)

extension String {
    func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
        return range(of: prefix, options: [.anchored, .caseInsensitive]) != nil
    }
}

หมายเหตุ: สำหรับคำนำหน้าว่างเปล่า ""มันจะกลับมาfalse

และน่าเกลียดด้วย regex (ฉันเห็นมัน ... )

extension String {
    func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
        guard let expression = try? NSRegularExpression(pattern: "\(prefix)", options: [.caseInsensitive, .ignoreMetacharacters]) else {
            return false
        }
        return expression.firstMatch(in: self, options: .anchored, range: NSRange(location: 0, length: characters.count)) != nil
    }
}

หมายเหตุ: สำหรับคำนำหน้าว่าง""มันจะกลับมาfalse

ในรวดเร็ว 4 func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, String.Element == PossiblePrefix.Elementจะเปิดตัว

ตัวอย่างการใช้:

let a = 1...3
let b = 1...10

print(b.starts(with: a))
// Prints "true"

แก้ไข: อัปเดตสำหรับ Swift 3

คลาส Swift String ไม่มีเมธอดhasPrefix()แบบตรงตามตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ แต่ถ้าคุณต้องการค้นหาแบบตัวเล็กและตัวเล็กคุณสามารถใช้เมธอด NSString ได้range(of:options:)ได้

หมายเหตุ: โดยค่าเริ่มต้นวิธี NSString จะไม่สามารถใช้ได้ แต่ถ้าคุณimport Foundationเป็น

ดังนั้น:

import Foundation
var city = "San Antonio"
var searchString = "san "
let range = city.range(of: searchString, options:.caseInsensitive)
if let range = range {
    print("San Antonio starts with san at \(range.startIndex)");
}

ตัวเลือกที่จะได้รับเป็นอย่างใดอย่างหนึ่งหรือ.caseInsensitive [.caseInsensitive]คุณจะใช้ตัวที่สองหากคุณต้องการใช้ตัวเลือกเพิ่มเติมเช่น:

let range = city.range(of: searchString, options:[.caseInsensitive, .backwards])

วิธีการนี้ยังมีข้อได้เปรียบในการใช้ตัวเลือกอื่นกับการค้นหาเช่น.diacriticInsensitiveการค้นหา ผลลัพธ์เดียวกันไม่สามารถทำได้อย่างง่ายดายโดยใช้. lowercased()บนสตริง

เวอร์ชั่น Swift 3:

func startsWith(string: String) -> Bool {
    guard let range = range(of: string, options:[.caseInsensitive]) else {
        return false
    }
    return range.lowerBound == startIndex
}

ใน Swift 4 ที่มีนามสกุล

ตัวอย่างนามสกุลของฉันมี 3 ฟังก์ชั่น: ตรวจสอบทำ String เริ่มต้นด้วย subString ทำ String สิ้นสุดไปที่ subString และทำ String มี subString

ตั้งค่า isCaseSensitive-parameter เป็น false หากคุณต้องการละเว้นคืออักขระ "A" หรือ "a" มิฉะนั้นให้ตั้งเป็น true

ดูความคิดเห็นในรหัสสำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงาน

รหัส:

    import Foundation

    extension String {
        // Returns true if the String starts with a substring matching to the prefix-parameter.
        // If isCaseSensitive-parameter is true, the function returns false,
        // if you search "sA" from "San Antonio", but if the isCaseSensitive-parameter is false,
        // the function returns true, if you search "sA" from "San Antonio"

        func hasPrefixCheck(prefix: String, isCaseSensitive: Bool) -> Bool {

            if isCaseSensitive == true {
                return self.hasPrefix(prefix)
            } else {
                var thePrefix: String = prefix, theString: String = self

                while thePrefix.count != 0 {
                    if theString.count == 0 { return false }
                    if theString.lowercased().first != thePrefix.lowercased().first { return false }
                    theString = String(theString.dropFirst())
                    thePrefix = String(thePrefix.dropFirst())
                }; return true
            }
        }
        // Returns true if the String ends with a substring matching to the prefix-parameter.
        // If isCaseSensitive-parameter is true, the function returns false,
        // if you search "Nio" from "San Antonio", but if the isCaseSensitive-parameter is false,
        // the function returns true, if you search "Nio" from "San Antonio"
        func hasSuffixCheck(suffix: String, isCaseSensitive: Bool) -> Bool {

            if isCaseSensitive == true {
                return self.hasSuffix(suffix)
            } else {
                var theSuffix: String = suffix, theString: String = self

                while theSuffix.count != 0 {
                    if theString.count == 0 { return false }
                    if theString.lowercased().last != theSuffix.lowercased().last { return false }
                    theString = String(theString.dropLast())
                    theSuffix = String(theSuffix.dropLast())
                }; return true
            }
        }
        // Returns true if the String contains a substring matching to the prefix-parameter.
        // If isCaseSensitive-parameter is true, the function returns false,
        // if you search "aN" from "San Antonio", but if the isCaseSensitive-parameter is false,
        // the function returns true, if you search "aN" from "San Antonio"
        func containsSubString(theSubString: String, isCaseSensitive: Bool) -> Bool {

            if isCaseSensitive == true {
                return self.range(of: theSubString) != nil
            } else {
                return self.range(of: theSubString, options: .caseInsensitive) != nil
            }
        }
    }

ตัวอย่างวิธีใช้:

สำหรับการตรวจสอบสตริงเริ่มต้นด้วย "TEST":

    "testString123".hasPrefixCheck(prefix: "TEST", isCaseSensitive: true) // Returns false
    "testString123".hasPrefixCheck(prefix: "TEST", isCaseSensitive: false) // Returns true

สำหรับการตรวจสอบเริ่มต้นด้วย "test" String:

    "testString123".hasPrefixCheck(prefix: "test", isCaseSensitive: true) // Returns true
    "testString123".hasPrefixCheck(prefix: "test", isCaseSensitive: false) // Returns true

สำหรับการตรวจสอบให้ทำ String ด้วย "G123":

    "testString123".hasSuffixCheck(suffix: "G123", isCaseSensitive: true) // Returns false
    "testString123".hasSuffixCheck(suffix: "G123", isCaseSensitive: false) // Returns true

สำหรับการตรวจสอบทำ String ด้วย "g123":

    "testString123".hasSuffixCheck(suffix: "g123", isCaseSensitive: true) // Returns true
    "testString123".hasSuffixCheck(suffix: "g123", isCaseSensitive: false) // Returns true

สำหรับการตรวจสอบสตริงมี "RING12":

    "testString123".containsSubString(theSubString: "RING12", isCaseSensitive: true) // Returns false
    "testString123".containsSubString(theSubString: "RING12", isCaseSensitive: false) // Returns true

สำหรับการตรวจสอบสตริงมี "ring12":

    "testString123".containsSubString(theSubString: "ring12", isCaseSensitive: true) // Returns true
    "testString123".containsSubString(theSubString: "ring12", isCaseSensitive: false) // Returns true