Swift dimulai dengan metode?

Apakah ada yang namanya metode beginWith () atau yang serupa di Swift?

Saya pada dasarnya mencoba untuk memeriksa apakah string tertentu dimulai dengan string lain. Saya juga ingin menjadi case-sensitive.

Seperti yang mungkin bisa Anda katakan, saya hanya mencoba melakukan fitur pencarian sederhana tetapi saya sepertinya gagal total dalam hal ini.

Inilah yang saya suka:

mengetik "sa" harus memberi saya hasil untuk "San Antonio", "Santa Fe", dll. mengetik "SA" atau "Sa" atau bahkan "SA" juga harus mengembalikan "San Antonio" atau "Santa Fe".

Saya menggunakan

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

sebelum iOS9 dan itu berfungsi dengan baik. Namun, setelah memutakhirkan ke iOS9, itu berhenti bekerja dan sekarang pencarian bersifat case sensitif.

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

gunakan hasPrefixsebagai ganti startsWith.

Contoh:

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

di sini adalah implementasi ekstensi Swift dari beginWith:

extension String {

  func startsWith(string: String) -> Bool {

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

    return range.startIndex == startIndex
  }

}

Contoh penggunaan:

var str = "Hello, playground"

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

Untuk secara khusus menjawab pencocokan awalan yang tidak sensitif :

dalam Swift murni (direkomendasikan sebagian besar waktu)

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

atau:

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

Catatan: untuk awalan kosong ""kedua implementasi akan kembalitrue

menggunakan Foundation range(of:options:)

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

catatan: untuk awalan kosong ""itu akan kembalifalse

dan menjadi jelek dengan regex (saya sudah melihatnya ...)

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

catatan: untuk awalan kosong ""itu akan kembalifalse

Di Swift 4 func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, String.Element == PossiblePrefix.Elementakan diperkenalkan.

Contoh Penggunaan:

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

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

Sunting: diperbarui untuk Swift 3.

Kelas Swift String memang memiliki metode case-sensitive hasPrefix(), tetapi jika Anda ingin pencarian case-sensitive Anda dapat menggunakan metode NSString range(of:options:).

Catatan: Secara default, metode NSString tidak tersedia, tetapi jika Andaimport Foundation memilikinya.

Begitu:

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

Opsi dapat diberikan sebagai .caseInsensitiveatau [.caseInsensitive]. Anda akan menggunakan yang kedua jika Anda ingin menggunakan opsi tambahan, seperti:

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

Pendekatan ini juga memiliki keuntungan karena dapat menggunakan opsi lain dengan pencarian, seperti .diacriticInsensitivepencarian. Hasil yang sama tidak dapat dicapai hanya dengan menggunakan . lowercased()string.

Versi Swift 3:

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

Di Swift 4 dengan ekstensi

Extension-example saya berisi 3 fungsi: centang do a String start with a subString, do a String end to a subString, dan do a String berisi subString.

Atur parameter isCaseSensitive ke false, jika Anda ingin mengabaikan adalah karakter "A" atau "a", jika tidak setel ke true.

Lihat komentar dalam kode untuk informasi lebih lanjut tentang cara kerjanya.

Kode:

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

Contoh cara menggunakan:

Untuk memeriksa lakukan mulai String dengan "TEST":

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

Untuk memeriksa lakukan mulai String dengan "test":

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

Untuk memeriksa lakukan akhir String dengan "G123":

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

Untuk memeriksa lakukan akhir String dengan "g123":

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

Untuk memeriksa apakah String berisi "RING12":

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

Untuk memeriksa apakah String berisi "ring12":

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