ios - स्विफ्ट 3-तारीख वस्तुओं की तुलना




xcode swift3 (8)

मैं अपने ऐप को स्विफ्ट 3.0 सिंटैक्स में अपडेट कर रहा हूं (मुझे पता है कि यह अभी भी बीटा में है लेकिन मैं इसे जारी करते ही तैयार रहना चाहता हूं)।

Xcode के पिछले बीटा (बीटा 5) तक मैं ऑपरेंड < , > और == का उपयोग करके दो Date ऑब्जेक्ट्स की तुलना करने में सक्षम था। लेकिन नवीनतम बीटा (बीटा 6) में यह और काम नहीं कर रहा है। यहाँ कुछ स्क्रीनशॉट हैं:

जैसा कि आप दोनों स्क्रीनशॉट में देख सकते हैं, ये दो Date ऑब्जेक्ट हैं। लेकिन मुझे निम्नलिखित त्रुटि मिलती है:

मैं क्या गलत कर रहा हूं? कार्य अभी भी Date वर्ग में घोषित किए गए हैं:

static func >(Date, Date)

सही है अगर बाएं हाथ की तारीख बाद में दाहिने हाथ की तारीख से समय में है।

क्या यह सिर्फ एक बीटा बग है या मैं कुछ गलत कर रहा हूं?


Date Comparable और Equatable (स्विफ्ट 3 के रूप में)

यह उत्तर @Ankit Thakur के उत्तर का पूरक है।

स्विफ्ट 3 के बाद से Date स्ट्रक्चर (अंतर्निहित NSDate वर्ग के आधार पर) Comparable और Equatable प्रोटोकॉल को Equatable है।

  • Comparable आवश्यकता है कि Date ऑपरेटरों को लागू करें: < , <= > , >=
  • Equatable आवश्यकता है कि Date == ऑपरेटर को लागू करें।
  • Equatable Date != ऑपरेटर के डिफ़ॉल्ट कार्यान्वयन का उपयोग करने की अनुमति देता है (जो Equatable == ऑपरेटर कार्यान्वयन का विलोम है)।

निम्न नमूना कोड इन तुलनात्मक संचालकों का उपयोग करता है और पुष्टि करता है कि print विवरणों के साथ कौन सी तुलना सही है।

तुलनात्मक कार्य

import Foundation

func describeComparison(date1: Date, date2: Date) -> String {

    var descriptionArray: [String] = []

    if date1 < date2 {
        descriptionArray.append("date1 < date2")
    }

    if date1 <= date2 {
        descriptionArray.append("date1 <= date2")
    }

    if date1 > date2 {
        descriptionArray.append("date1 > date2")
    }

    if date1 >= date2 {
        descriptionArray.append("date1 >= date2")
    }

    if date1 == date2 {
        descriptionArray.append("date1 == date2")
    }

    if date1 != date2 {
        descriptionArray.append("date1 != date2")
    }

    return descriptionArray.joined(separator: ",  ")
}

नमूना उपयोग

let now = Date()

describeComparison(date1: now, date2: now.addingTimeInterval(1))
// date1 < date2,  date1 <= date2,  date1 != date2

describeComparison(date1: now, date2: now.addingTimeInterval(-1))
// date1 > date2,  date1 >= date2,  date1 != date2

describeComparison(date1: now, date2: now)
// date1 <= date2,  date1 >= date2,  date1 == date2

इस लेखन के समय तक, स्विफ्ट सभी तुलनात्मक ऑपरेटरों (जैसे < , <= , == , >= , और > ) के साथ डेट्स की तुलना करने का समर्थन करती है। आप वैकल्पिक तिथियों की तुलना भी कर सकते हैं, लेकिन < , == , और > तक सीमित हैं। यदि आपको <= या >= , यानी का उपयोग करके दो वैकल्पिक तिथियों की तुलना करने की आवश्यकता है

let date1: Date? = ...
let date2: Date? = ...
if date1 >= date2 { ... }

आप वैकल्पिक का समर्थन करने के लिए <= और >= ऑपरेटरों को ओवरलोड कर सकते हैं:

func <= <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
    return lhs == rhs || lhs < rhs
}

func >= <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
    return lhs == rhs || lhs > rhs
}

इसे करने का दूसरा तरीका:

    switch date1.compare(date2) {
        case .orderedAscending:
            break

        case .orderedDescending:
            break;

        case .orderedSame:
            break
    }

केवल वर्ष - माह - दिन और मेरे बिना समय की तुलना करने के लिए इस तरह काम किया:

     let order = Calendar.current.compare(self.startDate, to: compareDate!, toGranularity: .day)  

                      switch order {
                        case .orderedAscending:
                            print("\(gpsDate) is after \(self.startDate)")
                        case .orderedDescending:
                            print("\(gpsDate) is before \(self.startDate)")
                        default:
                            print("\(gpsDate) is the same as \(self.startDate)")
                        }

मैंने इस स्निपेट (एक्सकोड 8 बीटा 6 में) की कोशिश की है, और यह ठीक काम कर रहा है।

let date1 = Date()
let date2 = Date().addingTimeInterval(100)

if date1 == date2 { ... }
else if date1 > date2 { ... }
else if date1 < date2 { ... }

स्विफ्ट 3: यह नहीं पता कि यह वही है जो आप खोज रहे हैं। लेकिन मैं एक स्ट्रिंग की वर्तमान टाइमस्टैम्प से यह देखने के लिए तुलना करता हूं कि क्या मेरा स्ट्रिंग अब पुराना है।

func checkTimeStamp(date: String!) -> Bool {
        let dateFormatter: DateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
        dateFormatter.locale = Locale(identifier:"en_US_POSIX")
        let datecomponents = dateFormatter.date(from: date)

        let now = Date()

        if (datecomponents! >= now) {
            return true
        } else {
            return false
        }
    }

इसके प्रयेाग के लिए:

if (checkTimeStamp(date:"2016-11-21 12:00:00") == false) {
    // Do something
}

स्विफ्ट 5:

1) यदि आप दिनांक प्रकार का उपयोग करते हैं:

let firstDate  = Date()
let secondDate = Date()

print(firstDate > secondDate)  
print(firstDate < secondDate)
print(firstDate == secondDate)

2) यदि आप स्ट्रिंग प्रकार का उपयोग करते हैं:

let firstStringDate  = "2019-05-22T09:56:00.1111111"
let secondStringDate = "2019-05-22T09:56:00.2222222"

print(firstStringDate > secondStringDate)  // false
print(firstStringDate < secondStringDate)  // true
print(firstStringDate == secondStringDate) // false 

मुझे यकीन नहीं है या दूसरा विकल्प 100% पर काम करता है। लेकिन मैं कितना भी नहीं बदलूंगा firstStringDate और SecondStringDate का मान सही था।


extension Date {
 func isBetween(_ date1: Date, and date2: Date) -> Bool {
    return (min(date1, date2) ... max(date1, date2)).contains(self)
  }
}

let resultArray = dateArray.filter { $0.dateObj!.isBetween(startDate, and: endDate) }




beta