swift - स्विफ्ट में एक सीमा के रूप में एक एकल पूर्णांक मान का इलाज करें




casting integer (2)

ऐसा मैं कैसे कर सकता हूं। रेंज सिमेंटिक्स से निपटने के बजाय, मैं बस एक प्रासंगिक प्रारंभकर्ता के साथ एक सेट एक्सटेंशन बना रहा हूं

extension Set where Element == Int {
    init(with elements: [Int] = [], and ranges: Range<Int>...) {
        var allElements = [elements]
        ranges.forEach {
            allElements.append(Array($0.lowerBound..<$0.upperBound))
        }
        self.init(allElements.joined())
    }
}

let newSet = Set(with: [1, 3, 328], and: 6..<10, 15..<20)
newSet.contains(3)  //true
newSet.contains(4)  //false
newSet.contains(16) //true

यह आपको केवल एकल मान, केवल श्रेणियों, या दोनों को पारित करने की अनुमति देता है। केवल चेतावनी उन्हें अलग नामित पैरामीटर है

Set सिमेंटिक्स का मतलब यह भी है कि यदि वांछित हो और स्थैतिक स्थिरांक बना सकें तो भी उतना ही तेज़ होना चाहिए।

मुझे स्ट्रिंग की लंबाई को मान्य करने की आवश्यकता है वर्ण गिनती के लिए अनुमत मान हैं:

  • 6 - 9 वर्ण
  • 12 अक्षर
  • 15 अक्षर

एक भिन्न वर्ण गिनती के साथ सभी स्ट्रिंग अमान्य हैं I इस प्रकार, मैं एक स्विफ्ट फ़ंक्शन बनाना चाहता हूं जो कई श्रेणियों को स्वीकार करता है और स्ट्रिंग का मूल्यांकन करता है:

extension String {

    func evaluateLength(validCharacterCounts: Range<Int>...) -> Bool {
        // Implementation
    }

}

अब मैं एक एकल Int श्रेणी के लिए फ़ंक्शन को कॉल कर सकता हूं:

"Live long and prosper".evaluateLength(validCharacterCounts: 6..<10)

और कई Int श्रेणी:

"Live long and prosper".evaluateLength(validCharacterCounts: 6..<10, 15..<20)

लेकिन मैं फ़ंक्शन को एकल, पृथक पूर्णांक मानों के साथ कॉल नहीं कर सकता:

"Live long and prosper".evaluateLength(validCharacterCounts: 6..<10, 12, 15)

क्योंकि 12 और 15 को Int रूप में टाइप किया जाता है और Range<Int> रूप में नहीं Range<Int>

स्विफ्ट कम्पाइलल त्रुटि: अपेक्षित तर्क प्रकार 'रेंज' के प्रकार 'Int' का मान परिवर्तित नहीं किया जा सकता

स्विफ्ट में Range रूप में एकल पूर्णांक को इलाज के लिए कोई रास्ता नहीं है, जैसे कि यह स्वचालित रूप से Range<Int> कास्टिंग करना है?

(सभी 5 बाद 5 के समतुल्य है 5..<6 , तो गणितीय बोलने वाली 5 एक श्रेणी भी है।)


मैं 3 समाधानों के साथ आया था, लेकिन मैं इनमें से किसी भी तरह से प्रसन्न नहीं हूं जैसे कि विधि Int या Range<Int> स्वीकार करती है, लेकिन हम यहां जाते हैं?

1 - आपके पास प्रकार की सुरक्षा है लेकिन कुछ कामकाज का उपयोग करना है:

extension String {
    func evaluateLength(validCharacterCounts: [Range<Int>]? = nil) -> Bool {
        if let validCharCounts = validCharacterCounts {
            for validCharCount in validCharCounts {
                if validCharCount.contains(characters.count) {
                    return true
                }
            }
        }

        return false
    }
}

extension Int {
    var asRange: Range<Int> {
        return self..<self+1 as Range<Int>
    }
}

"Hello, playground".evaluateLength(validCharacterCounts: [17.asRange, 1, 25, 1..<45]) // true

2 - आपके पास प्रकार की सुरक्षा नहीं है:

extension String {
    func evaluateLength(validCharacterCounts: [Any]? = nil) -> Bool {
        if let validCharCounts = validCharacterCounts {
            for validCharCount in validCharCounts {
                if let range = validCharCount as? Range<Int> {
                    if range.contains(characters.count) {
                        return true
                    }
                } else if let range = validCharCount as? CountableRange<Int> {
                    if range.contains(characters.count) {
                        return true
                    }
                } else if let range = validCharCount as? CountableClosedRange<Int> {
                    if range.contains(characters.count) {
                        return true
                    }
                } else if let int = validCharCount as? Int {
                    if int.asRange.contains(characters.count) {
                        return true
                    }
                } else {
                    fatalError("Unexpected type: \(type(of: validCharCount))")
                }
            }
        }

        return false
    }
}

extension Int {
    var asRange: Range<Int> {
        return self..<self+1 as Range<Int>
    }
}

"Hello, playground".evaluateLength(validCharacterCounts: [12, 1, 4, 6, 14...18]) // true

3 - सबसे अच्छा अब तक, लेकिन अभी भी सही समाधान नहीं है:

extension String {
    func evaluateLength(validCharacterCounts: [Int]? = nil) -> Bool {
        guard let validCharCounts = validCharacterCounts else {
            return false
        }

        return validCharCounts.contains(characters.count)

    }
}

"Hello, playground".evaluateLength(validCharacterCounts: [12, 1, 4, 6] + Array(14...18)) // true






nsrange