स्विफ्ट शुरू होता है विधि के साथ?

Question

वहाँ एक शुरुआत () विधि या स्विफ्ट में समान कुछ के रूप में ऐसी बात है?

मैं मूल रूप से यह जांचने की कोशिश कर रहा हूं कि क्या एक निश्चित स्ट्रिंग दूसरे स्ट्रिंग से शुरू होती है। मैं यह भी चाहता हूं कि यह असंवेदनशील हो।

जैसा कि आप बता सकते हैं, मैं केवल एक सरल खोज सुविधा करने की कोशिश कर रहा हूं, लेकिन मैं इस पर बुरी तरह असफल हो रहा हूं।

यह वही है जो मुझे पसंद है:

"सा" में टाइप करने से मुझे "सैन एंटोनियो", "सांता फ़े", "स" या "सा" या "स" में टाइपिंग के लिए परिणाम देना चाहिए, यहां तक ​​कि "सैन एंटोनियो" या "सांता फ़े" भी लौटना चाहिए।

मैं उपयोग कर रहा था

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

Comments

क्या आप एक ठोस उदाहरण दे सकते हैं जहां CaseInsensitiveSearch के साथ रेंजऑफस्ट्रिंग अपेक्षा के अनुरूप काम नहीं करता है? मैंने इसे iOS 9 सिम्युलेटर में टेस्ट किया है और इसने मेरे लिए काम किया है।

— मार्टिन आर।

Answer 1

के hasPrefixबजाय का उपयोग करें startsWith।

उदाहरण:

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

Comments

ओपी केस असंवेदनशील के लिए पूछता है और आपका जवाब संवेदनशील है

— C Marur

तुलना करने से पहले स्ट्रिंग्स को कम करना बहुत आसान है"string".lowercased()

— TotoroTotoro

Answer 2

यहाँ शुरू के साथ एक स्विफ्ट विस्तार कार्यान्वयन है:

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

Answer 3

विशेष रूप से असंवेदनशील उपसर्ग मिलान का जवाब देने के लिए :

शुद्ध स्विफ्ट में (अधिकांश समय अनुशंसित)

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

और एक रेगेक्स के साथ बदसूरत हो रहा है (मैंने इसे देखा है ...)

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

Answer 4

स्विफ्ट 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"

Answer 5

संपादित करें: स्विफ्ट 3 के लिए अपडेट किया गया।

स्विफ्ट स्ट्रिंग क्लास में केस-संवेदी विधि होती है 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()स्ट्रिंग्स पर उपयोग करके प्राप्त नहीं किया जा सकता है ।

Answer 6

स्विफ्ट 3 संस्करण:

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

Comments

के साथ तेज हो सकता है .anchored। मेरा जवाब देखें या ओलिवर एटकिंसन जवाब।

— कूर

Answer 7

एक्सटेंशन के साथ स्विफ्ट 4 में

मेरे एक्सटेंशन-उदाहरण में 3 फ़ंक्शंस हैं: चेक एक स्ट्रिंग को सबस्ट्रिंग के साथ शुरू करें, एक स्ट्रिंग को एक सबस्ट्रिंग के लिए समाप्त करें और एक स्ट्रिंग में एक सबस्ट्रिंग करें।

IsCaseSensitive- पैरामीटर को असत्य पर सेट करें, यदि आप अनदेखा करना चाहते हैं तो वर्ण "A" या "a" है, अन्यथा इसे सत्य पर सेट करें।

यह कैसे काम करता है, इसकी अधिक जानकारी के लिए कोड में टिप्पणियां देखें।

कोड:

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

उपयोग करने के तरीके:

चेकिंग के लिए स्ट्रिंग "टेस्ट" से शुरू होती है:

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

चेकिंग के लिए स्ट्रिंग "परीक्षण" से शुरू होती है:

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

चेकिंग के लिए स्ट्रिंग का अंत "G123" के साथ करें:

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

चेकिंग के लिए स्ट्रिंग का अंत "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

चेकिंग के लिए स्ट्रिंग में "रिंग 12" शामिल है:

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