स्विफ्ट 3 - डेट ऑब्जेक्ट्स की तुलना करना

Question

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

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

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

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

static func >(Date, Date)

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

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

Comments

let d1 = Date() ; let d2 = Date() ; if d1 > d2 { }मेरे Xcode 8 बीटा 6 में काम करता है

— मार्टिन आर।

हाँ। - आपको रिपोर्ट नेविगेटर में पूर्ण त्रुटि संदेश देखना चाहिए।

— मार्टिन आर

धन्यवाद @MartinR! नहीं पता था कि मैं एक त्रुटि में "गोता" लगा सकता हूं और अधिक जानकारी प्राप्त कर सकता हूं। मेरी बहुत मदद की!

— बीफ

सही उत्तर स्वीकार करें

— अंकित ठाकुर

Answer 1

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

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

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

Comments

अगर मैं समय को नजरअंदाज करना चाहता हूं। उदा 2019-05-14 12:08:14 +0000== 2019-05-14को सही लौटना चाहिए। फिर क्या ?

— आवा फयाज

@AwaisFayyaz यदि आप तारीखों की तुलना किए बिना तारीखों को खाते में लेना चाहते हैं। आपको उन घटकों को प्राप्त करने की आवश्यकता है जो आप तारीख से चाहते हैं। इसके बाद डेटकॉमर्स से डेट प्राप्त करें और उनकी तुलना करें।

— जियोर्जियो डोगानिएरो

Answer 2

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

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

स्विफ्ट 3 के बाद से Dateसंरचना (अंतर्निहित NSDateवर्ग के आधार पर ) Comparableऔर 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

Answer 3

से स्विफ्ट 3 और इसके बाद के संस्करण, दिनांक तुलनीय है तो हम सीधे तुलना दिनांकों तरह कर सकते हैं

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

let isGreater = date1 > date2
print(isGreater)

let isSmaller = date1 < date2
print(isSmaller)

let isEqual = date1 == date2
print(isEqual)

वैकल्पिक रूप से हम तिथि पर विस्तार बना सकते हैं

extension Date {

  func isEqualTo(_ date: Date) -> Bool {
    return self == date
  }
  
  func isGreaterThan(_ date: Date) -> Bool {
     return self > date
  }
  
  func isSmallerThan(_ date: Date) -> Bool {
     return self < date
  }
}

उपयोग: let isEqual = date1.isEqualTo(date2)

Comments

अगर मैं समय को नजरअंदाज करना चाहता हूं। उदा 2019-05-14 12:08:14 +0000== 2019-05-14को सही लौटना चाहिए। फिर क्या ?

— आवा फयाज

Answer 4

यह http://iswift.org/cookbook/compare-2-dates देखें

दिनांक प्राप्त करें:

// Get current date
let dateA = NSDate()

// Get a later date (after a couple of milliseconds)
let dateB = NSDate()

SWITCH स्टेटमेंट का उपयोग करना

// Compare them
switch dateA.compare(dateB) {
    case .OrderedAscending     :   print("Date A is earlier than date B")
    case .OrderedDescending    :   print("Date A is later than date B")
    case .OrderedSame          :   print("The two dates are the same")
}

IF स्टेटमेंट का उपयोग करना

 if dateA.compare(dateB) == .orderedAscending {
     datePickerTo.date = datePicker.date
 }

 //OR

 if case .orderedAcending = dateA.compare(dateB) {

 }

Answer 5

मेरे लिए समस्या यह थी कि मेरे पास डेट क्लास का अपना विस्तार था जो सभी तुलना ऑपरेटरों को परिभाषित कर रहा था। अब (स्विफ्ट 3 के बाद से) वह दिनांक तुलनीय है, इन एक्सटेंशनों की आवश्यकता नहीं है। इसलिए मैंने उन्हें टिप्पणी दी और यह काम किया।

Answer 6

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

Answer 7

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

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

Answer 8

यदि आप उदाहरण के लिए सेकंड को अनदेखा करना चाहते हैं तो आप उपयोग कर सकते हैं

funcDate (दिनांक, समतुल्य: तिथि, तिथिप्रयोग्यता: NSCalendar.Unit) -> बूल

उदाहरण तुलना करें कि क्या यह उसी दिन है:

Calendar.current.isDate(date1, equalTo: date2, toGranularity: .day)

Answer 9

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

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
}

Answer 10

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

Answer 11

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

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

        case .orderedDescending:
            break;

        case .orderedSame:
            break
    }

Answer 12

   var strDateValidate = ""
            let dateFormatter = DateFormatter()
            dateFormatter.dateFormat = "yyyy-MM-dd"

            let firstDate = dateFormatter.date(from:lblStartTime.text!)
            let secondDate = dateFormatter.date(from:lblEndTime.text!)

            if firstDate?.compare(secondDate!) == .orderedSame || firstDate?.compare(secondDate!) == .orderedAscending {
                print("Both dates are same or first is less than scecond")
                strDateValidate = "yes"
            }
            else
            {
                //second date is bigger than first
                strDateValidate = "no"
            }

            if strDateValidate == "no"
            {
                alertView(message: "Start date and end date for a booking must be equal or Start date must be smaller than the end date", controller: self)
            }

Answer 13

स्विफ्ट 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% पर काम करता है। लेकिन मैं कितना भी पहलेस्ट्रीमिंगडेट और दूसरीस्ट्रीमिंगडेट के मूल्यों को नहीं बदलूंगा परिणाम सही था।

Answer 14

स्विफ्ट 3,4 में आपको "तुलना" का उपयोग करना चाहिए। उदाहरण के लिए:

DateArray.sort { (($0)?.compare($1))! == .orderedDescending }