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