दो एनएसडी के बीच स्विफ्ट दिन

Question

मुझे आश्चर्य हो रहा है कि क्या स्विफ्ट / "नई" कोको में दो एनएसडी के बीच दिनों की राशि प्राप्त करने के लिए कुछ नया और भयानक संभावना है?

जैसे मैं रूबी में करूँगा:

(end_date - start_date).to_i

Comments

मुझे लगता है कि आपको अभी भी NSCalendar और NSDateCompords का उपयोग करना होगा (जिसके लिए SO पर सैकड़ों उत्तर होने चाहिए)। - यदि आप "नई और भयानक संभावना" की तलाश कर रहे हैं, तो तुलना के लिए अपना वर्तमान समाधान दिखाना मददगार होगा।

— मार्टिन आर।

यह अब बहुत आसान है, और आपको "एनएस" कुछ भी उपयोग करने की आवश्यकता नहीं है। मैंने कॉपी और पेस्ट करने के लिए 2017 के उत्तर में टाइप किया।

— फेटी जूल

Answer 1

आपको समय के अंतर पर भी विचार करना होगा। उदाहरण के लिए यदि आप तारीखों की तुलना करते हैं2015-01-01 10:00 और 2015-01-02 09:00, उन तारीखों के बीच के दिन 0 (शून्य) के रूप में वापस आ जाएंगे क्योंकि उन तारीखों के बीच का अंतर 24 घंटे से कम है (यह 23 घंटे है)।

यदि आपका उद्देश्य दो तिथियों के बीच सटीक दिन संख्या प्राप्त करना है, तो आप इस तरह से इस मुद्दे पर काम कर सकते हैं:

// Assuming that firstDate and secondDate are defined
// ...

let calendar = NSCalendar.currentCalendar()

// Replace the hour (time) of both dates with 00:00
let date1 = calendar.startOfDayForDate(firstDate)
let date2 = calendar.startOfDayForDate(secondDate)

let flags = NSCalendarUnit.Day
let components = calendar.components(flags, fromDate: date1, toDate: date2, options: [])

components.day  // This will return the number of day(s) between dates

स्विफ्ट 3 और स्विफ्ट 4 संस्करण

let calendar = Calendar.current

// Replace the hour (time) of both dates with 00:00
let date1 = calendar.startOfDay(for: firstDate)
let date2 = calendar.startOfDay(for: secondDate)

let components = calendar.dateComponents([.day], from: date1, to: date2)

Comments

आप वास्तव में startOfDayForDate के बजाय 12pm (दोपहर) की जांच करना चाहते हैं - टाइमज़ोन और DST को समायोजित करने के कारण बोर्क की संभावना कम होनी चाहिए।

— ब्रैंडनस्क्रिप्ट

दोपहर के लिए तिथियां निर्धारित करना इस तरह किया जा सकता है:calendar.date(bySettingHour: 12, minute: 00, second: 00, of: calendar.startOfDay(for: firstDate))

— महाशय

दोपहर सेट करने के लिए छोटा संस्करण ( startOfDay()अनावश्यक प्रतीत होता है) calendar.date(bySettingHour: 12, minute: 0, second: 0, of: firstDate):।

— जामिक्स

Answer 2

यहाँ स्विफ्ट 2 के लिए मेरा जवाब है:

func daysBetweenDates(startDate: NSDate, endDate: NSDate) -> Int
{
    let calendar = NSCalendar.currentCalendar()

    let components = calendar.components([.Day], fromDate: startDate, toDate: endDate, options: [])

    return components.day
}

Comments

मैंने ऊपर @vikingosegundo पोस्ट के घटकों के साथ सफलतापूर्वक इसका उपयोग किया। यह दो तारीखों के बीच दिनों की सही संख्या का प्रतिनिधित्व करने वाला पूर्णांक देता है। <अंगूठे ऊपर>

— मेरा खाता

मुझे यह पसंद है लेकिन फ़ंक्शन का नाम "दिनबेटवॉनेट्स" होना चाहिए

— मबनेस

अगर हम तुलना कर रहे हैं तो यह 0 रिटर्न देता है todayऔरtomorrow

— tawheed

Answer 3

मैं एक जोड़ी Swift3 जवाब देखता हूं तो मैं अपना खुद का जोड़ दूंगा:

public static func daysBetween(start: Date, end: Date) -> Int {
   Calendar.current.dateComponents([.day], from: start, to: end).day!
}

नामकरण अधिक स्विफ्टी महसूस करता है, यह एक पंक्ति है, और नवीनतम dateComponents()विधि का उपयोग कर रहा है ।

Answer 4

मैंने अपने उद्देश्य-सी उत्तर का अनुवाद किया

let start = "2010-09-01"
let end = "2010-09-05"

let dateFormatter = NSDateFormatter()
dateFormatter.dateFormat = "yyyy-MM-dd"

let startDate:NSDate = dateFormatter.dateFromString(start)
let endDate:NSDate = dateFormatter.dateFromString(end)

let cal = NSCalendar.currentCalendar()


let unit:NSCalendarUnit = .Day

let components = cal.components(unit, fromDate: startDate, toDate: endDate, options: nil)


println(components)

परिणाम

<NSDateComponents: 0x10280a8a0>
     Day: 4

सबसे कठिन हिस्सा यह था कि ऑटोकंप्लीशन डीटेट और टॉड से प्रेरित है NSDate?, लेकिन वास्तव में उन्हें NSDate!संदर्भ में दिखाया जाना चाहिए ।

मैं नहीं देखता कि एक ऑपरेटर के साथ एक अच्छा समाधान कैसा दिखेगा, जैसा कि आप प्रत्येक मामले में इकाई को अलग-अलग निर्दिष्ट करना चाहते हैं। आप समय अंतराल को वापस कर सकते हैं, लेकिन इससे ज्यादा आप हासिल नहीं करेंगे।

Comments

लगता है जैसे .DayCalendarUnitपदावनत कर दिया गया है। मेरा मानना ​​है कि अब आपको .CalendarUnitDayइसके बजाय उपयोग करना चाहिए ।

— टेलरऑल्रेड

विकल्प अब एक अपेक्षित पैरामीटर है

— डिपार्टमेन्ट B

: रनिंग स्विफ्ट 2 यह मेरे लिए काम करता हैlet components = cal.components(.Day, fromDate: startDate, toDate: endDate, options: [])

— Andrej

@TaylorAllred .Dayअभी

— विलियम जीपी

Answer 5

यहाँ बहुत अच्छा है, Dateसाल, महीने, दिन, घंटे, मिनट, सेकंड में तारीखों के बीच अंतर पाने के लिए विस्तार

extension Date {

    func years(sinceDate: Date) -> Int? {
        return Calendar.current.dateComponents([.year], from: sinceDate, to: self).year
    }

    func months(sinceDate: Date) -> Int? {
        return Calendar.current.dateComponents([.month], from: sinceDate, to: self).month
    }

    func days(sinceDate: Date) -> Int? {
        return Calendar.current.dateComponents([.day], from: sinceDate, to: self).day
    }

    func hours(sinceDate: Date) -> Int? {
        return Calendar.current.dateComponents([.hour], from: sinceDate, to: self).hour
    }

    func minutes(sinceDate: Date) -> Int? {
        return Calendar.current.dateComponents([.minute], from: sinceDate, to: self).minute
    }

    func seconds(sinceDate: Date) -> Int? {
        return Calendar.current.dateComponents([.second], from: sinceDate, to: self).second
    }

}

Comments

datesinceDateफ़ंक्शन मापदंडों में होना चाहिए ।

— द टाइगर

@ TheTiger - इस उत्तर की सबसे बड़ी गलती को उजागर करने के लिए आपका बहुत-बहुत धन्यवाद .. मैं जल्द ही व्यावहारिक रूप से परीक्षण करूंगा और उत्तर को अपडेट करूंगा।

— क्रुणाल

मेरा सौभाग्य! मैंने इसके लिए परीक्षण किया है daysऔर यह ठीक काम करता है।

— द टाइगर

अच्छा उत्तर। मैं केवल सुझाव देता हूं func years(since date: Date) -> Int? { return Calendar.current.dateComponents[.year], from: date, to: self).years }, और आप इसे कॉल कर सकते हैं let y = date1.years(since: date2)। यह आधुनिक नामकरण सम्मेलनों के साथ अधिक सुसंगत हो सकता है।

— रोब

Answer 6

स्विफ्ट 3 iOS 10 बीटा 4 के लिए अपडेट

func daysBetweenDates(startDate: Date, endDate: Date) -> Int {
    let calendar = Calendar.current
    let components = calendar.dateComponents([Calendar.Component.day], from: startDate, to: endDate)
    return components.day!
}

Answer 7

यहाँ स्विफ्ट 3 के लिए जवाब है (IOS 10 बीटा के लिए परीक्षण)

func daysBetweenDates(startDate: Date, endDate: Date) -> Int
{
    let calendar = Calendar.current
    let components = calendar.components([.day], from: startDate, to: endDate, options: [])
    return components.day!
}

तब आप इसे इस तरह कह सकते हैं

let pickedDate: Date = sender.date
let NumOfDays: Int = daysBetweenDates(startDate: pickedDate, endDate: Date())
    print("Num of Days: \(NumOfDays)")

Answer 8

स्विफ्ट 3. सुझाव के लिए ऊपर एमिन बुआरा सारल को धन्यवाद startOfDay।

extension Date {

    func daysBetween(date: Date) -> Int {
        return Date.daysBetween(start: self, end: date)
    }

    static func daysBetween(start: Date, end: Date) -> Int {
        let calendar = Calendar.current

        // Replace the hour (time) of both dates with 00:00
        let date1 = calendar.startOfDay(for: start)
        let date2 = calendar.startOfDay(for: end)

        let a = calendar.dateComponents([.day], from: date1, to: date2)
        return a.value(for: .day)!
    }
}

उपयोग:

let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "yyyy-MM-dd"
let start = dateFormatter.date(from: "2017-01-01")!
let end = dateFormatter.date(from: "2018-01-01")!

let diff = Date.daysBetween(start: start, end: end) // 365

Comments

कई समस्याओं से बचने के लिए निश्चित रूप से 00:00 के बजाय उन दोनों को दोपहर तक स्थानांतरित करना बेहतर होगा ।

— फेटी

Answer 9

स्विफ्ट में निर्मित चीजें अभी भी बहुत बुनियादी हैं। जैसा कि वे इस प्रारंभिक चरण में होना चाहिए। लेकिन आप ओवरलोडिंग ऑपरेटरों और वैश्विक डोमेन कार्यों के साथ आने वाले जोखिम के साथ अपना खुद का सामान जोड़ सकते हैं। वे हालांकि आपके मॉड्यूल के लिए स्थानीय होंगे।

let now = NSDate()
let seventies = NSDate(timeIntervalSince1970: 0)

// Standard solution still works
let days = NSCalendar.currentCalendar().components(.CalendarUnitDay, 
           fromDate: seventies, toDate: now, options: nil).day

// Flashy swift... maybe...
func -(lhs:NSDate, rhs:NSDate) -> DateRange {
    return DateRange(startDate: rhs, endDate: lhs)
}

class DateRange {
    let startDate:NSDate
    let endDate:NSDate
    var calendar = NSCalendar.currentCalendar()
    var days: Int {
        return calendar.components(.CalendarUnitDay, 
               fromDate: startDate, toDate: endDate, options: nil).day
    }
    var months: Int {
        return calendar.components(.CalendarUnitMonth, 
               fromDate: startDate, toDate: endDate, options: nil).month
    }
    init(startDate:NSDate, endDate:NSDate) {
        self.startDate = startDate
        self.endDate = endDate
    }
}

// Now you can do this...
(now - seventies).months
(now - seventies).days

Comments

एक दिन की लंबाई के लिए (24 * 60 * 60) का उपयोग न करें। यह डेलाइट सेविंग टाइम ट्रांजेक्शन को ध्यान में नहीं रखता है।

— मार्टिन आर

मुझे लगता है कि NSDate इसके लिए समायोजित होगा क्योंकि यह हमेशा GMT और दिन के उजाले का उपयोग करता है बचत उस पर केवल एक प्रारूपण या स्थानीयकरण है। यह सुनिश्चित करने के लिए कि यह महीनों, वर्षों या वास्तव में परिवर्तनीय लंबाई के कुछ भी हो सकता है।

— डैनियल श्लॉग जुग

@MartinR मुझे यह विश्वास करने की कोशिश करनी थी, लेकिन वास्तव में, अब जब मैंने किया तो मैंने यह भी देखा कि विकिपीडिया इसका उल्लेख करता है। तुम सही हो। मेरे साथ जिद्दी होने के लिए धन्यवाद।

— डैनियल श्लाग

वहां, सही होने के लिए संपादित किया गया। लेकिन फ्लैश की तरह दूर चला गया।

— डैनियल श्लाग

यह स्थान, समय के बिंदु और कैलेंडर प्रणाली द्वारा परिभाषित किया गया है। हेबरेव कैलेंडर में एक लीप महीना होता है। एक बेहतरीन wwdc वीडियो है: कैलेंडर गणना करना - प्रत्येक कोको कोडर के लिए एक अवश्य देखें।

— vikingosegundo

Answer 10

यहाँ स्विफ्ट 3 के लिए मेरा जवाब है:

func daysBetweenDates(startDate: NSDate, endDate: NSDate, inTimeZone timeZone: TimeZone? = nil) -> Int {
    var calendar = Calendar.current
    if let timeZone = timeZone {
        calendar.timeZone = timeZone
    }
    let dateComponents = calendar.dateComponents([.day], from: startDate.startOfDay, to: endDate.startOfDay)
    return dateComponents.day!
}

Answer 11

अभी तक शायद ही कोई स्विफ्ट-विशिष्ट मानक पुस्तकालय है; सिर्फ दुबला बुनियादी संख्यात्मक, स्ट्रिंग, और संग्रह प्रकार।

एक्सटेंशन का उपयोग करके ऐसे शॉर्टहैंड्स को परिभाषित करना पूरी तरह से संभव है, लेकिन जहां तक ​​वास्तविक आउट-ऑफ-द-बॉक्स एपीआई जाने का है, तो कोई "नया" कोको नहीं है; स्विफ्ट को सीधे उसी पुरानी क्रिया कोको एपीआई में मैप करें जैसे वे पहले से मौजूद हैं।

Answer 12

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

    var name = txtName.stringValue // Get the users name

    // Get the date components from the window controls
    var dateComponents = NSDateComponents()
    dateComponents.day = txtDOBDay.integerValue
    dateComponents.month = txtDOBMonth.integerValue
    dateComponents.year = txtDOBYear.integerValue

    // Make a Gregorian calendar
    let calendar = NSCalendar(identifier: NSCalendarIdentifierGregorian)

    // Get the two dates we need
    var birthdate = calendar?.dateFromComponents(dateComponents)
    let currentDate = NSDate()

    var durationDateComponents = calendar?.components(NSCalendarUnit.CalendarUnitDay, fromDate: birthdate!, toDate: currentDate, options: nil)

    let numberOfDaysAlive = durationDateComponents?.day

    println("\(numberOfDaysAlive!)")

    txtGreeting.stringValue = "Hello \(name), You have been alive for \(numberOfDaysAlive!) days."

मुझे उम्मीद है कि यह किसी की मदद करता है।

चीयर्स,

Answer 13

आयलैंड की विधि स्विफ्ट 3 में अपडेट की गई, यह आज से दिन दिखाता है (दिन के समय की उपेक्षा)

func daysBetweenDates( endDate: Date) -> Int 
    let calendar: Calendar = Calendar.current 
    let date1 = calendar.startOfDay(for: Date()) 
    let date2 = calendar.startOfDay(for: secondDate) 
    return calendar.dateComponents([.day], from: date1, to: date2).day! 
}

Answer 14

यह कुछ Dateऔर आज के बीच के दिनों में एक पूर्ण अंतर देता है:

extension Date {
  func daysFromToday() -> Int {
    return abs(Calendar.current.dateComponents([.day], from: self, to: Date()).day!)
  }
}

और फिर इसका उपयोग करें:

if someDate.daysFromToday() >= 7 {
  // at least a week from today
}

Answer 15

आप निम्नलिखित एक्सटेंशन का उपयोग कर सकते हैं:

public extension Date {
    func daysTo(_ date: Date) -> Int? {
        let calendar = Calendar.current

        // Replace the hour (time) of both dates with 00:00
        let date1 = calendar.startOfDay(for: self)
        let date2 = calendar.startOfDay(for: date)

        let components = calendar.dateComponents([.day], from: date1, to: date2)
        return components.day  // This will return the number of day(s) between dates
    }
}

फिर, आप इसे इस तरह से कॉल कर सकते हैं:

startDate.daysTo(endDate)

Answer 16

स्विफ्ट 3.2

extension DateComponentsFormatter {
    func difference(from fromDate: Date, to toDate: Date) -> String? {
        self.allowedUnits = [.year,.month,.weekOfMonth,.day]
        self.maximumUnitCount = 1
        self.unitsStyle = .full
        return self.string(from: fromDate, to: toDate)
    }
}

Answer 17

सभी का जवाब अच्छा है। लेकिन स्थानीयकरणों के लिए हमें दो तिथियों के बीच कई दशमलव दिनों की गणना करनी होगी। इसलिए हम स्थायी दशमलव प्रारूप प्रदान कर सकते हैं।

// This method returns the fractional number of days between to dates
func getFractionalDaysBetweenDates(date1: Date, date2: Date) -> Double {

    let components = Calendar.current.dateComponents([.day, .hour], from: date1, to: date2)

    var decimalDays = Double(components.day!)
    decimalDays += Double(components.hour!) / 24.0

    return decimalDays
}

Answer 18

extension Date {
    func daysFromToday() -> Int {
        return Calendar.current.dateComponents([.day], from: self, to: Date()).day!
    }
}

फिर इसका उपयोग करें

    func dayCount(dateString: String) -> String{
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "MMM dd,yyyy hh:mm a"
        let fetchedDate = dateFormatter.date(from: dateString)


        let day = fetchedDate?.daysFromToday()
        if day! > -1{
            return "\(day!) days passed."
        }else{
        return "\(day! * -1) days left."
        }
    }

Answer 19

स्विफ्ट 3 - आज से आज तक दिन

func daysUntilDate(endDateComponents: DateComponents) -> Int
    {
        let cal = Calendar.current
        var components = cal.dateComponents([.era, .year, .month, .day], from: NSDate() as Date)
        let today = cal.date(from: components)
        let otherDate = cal.date(from: endDateComponents)

        components = cal.dateComponents([Calendar.Component.day], from: (today! as Date), to: otherDate!)
        return components.day!
    }

इस तरह कॉल फंक्शन

// Days from today until date
   var examnDate = DateComponents()
   examnDate.year = 2016
   examnDate.month = 12
   examnDate.day = 15
   let daysCount = daysUntilDate(endDateComponents: examnDate)

Answer 20

डेट पर एक्सटेंशन बनाना आसान विकल्प होगा

public extension Date {

        public var currentCalendar: Calendar {
            return Calendar.autoupdatingCurrent
        }

        public func daysBetween(_ date: Date) -> Int {
            let components = currentCalendar.dateComponents([.day], from: self, to: date)
            return components.day!
        }
    }

Answer 21

  func completeOffset(from date:Date) -> String? {

    let formatter = DateComponentsFormatter()
    formatter.unitsStyle = .brief

    return  formatter.string(from: Calendar.current.dateComponents([.year,.month,.day,.hour,.minute,.second], from: date, to: self))




}

यदि आपको वर्ष के दिनों और घंटों की आवश्यकता है, तो स्ट्रिंग का उपयोग करें

var कल = Calendar.current.date (byAdding: .day, value: 1, to: Date ())!

let dc = काल .comOffset (से: दिनांक)

Answer 22

अच्छा काम एक लाइनर:

extension Date {
  var daysFromNow: Int {
    return Calendar.current.dateComponents([.day], from: Date(), to: self).day!
  }
}

Answer 23

स्विफ्ट 4

 func getDateHeader(indexPath: Int) -> String {
    let formatter2 = DateFormatter()
    formatter2.dateFormat = "MM-dd-yyyy"
    var dateDeadline : Date?

    dateDeadline = formatter2.date(from: arrCompletedDate[indexPath] as! String)

    let currentTime = dateDeadline?.unixTimestamp
    let calendar = NSCalendar.current

    let date = NSDate(timeIntervalSince1970: Double(currentTime!))
    if calendar.isDateInYesterday(date as Date) { return "Yesterday" }
    else if calendar.isDateInToday(date as Date) { return "Today" }
    else if calendar.isDateInTomorrow(date as Date) { return "Tomorrow" }
    else {
        let startOfNow = calendar.startOfDay(for: NSDate() as Date)
        let startOfTimeStamp = calendar.startOfDay(for: date as Date)
        let components = calendar.dateComponents([.day], from: startOfNow, to: startOfTimeStamp)
        let day = components.day!
        if day < 1 { return "\(abs(day)) days ago" }
        else { return "In \(day) days" }
    }
}

Answer 24

यह स्विफ्ट 5 के लिए एमिन के जवाब का एक अद्यतन संस्करण है जिसमें दिनों की तुलना करने के लिए निश्चित समय के रूप में आधी रात के बजाय दोपहर का उपयोग करने का सुझाव शामिल है। यह वैकल्पिक लौटकर विभिन्न तिथि कार्यों की संभावित विफलता को भी संभालता है।

    ///
    /// This is an approximation; it does not account for time differences. It will set the time to 1200 (noon) and provide the absolute number
    /// of days between now and the given date. If the result is negative, it should be read as "days ago" instead of "days from today."
    /// Returns nil if something goes wrong initializing or adjusting dates.
    ///

    func daysFromToday() -> Int?
    {
        let calendar = NSCalendar.current

        // Replace the hour (time) of both dates with noon. (Noon is less likely to be affected by DST changes, timezones, etc. than midnight.)
        guard let date1 = calendar.date(bySettingHour: 12, minute: 00, second: 00, of: calendar.startOfDay(for: Date())),
              let date2 = calendar.date(bySettingHour: 12, minute: 00, second: 00, of: calendar.startOfDay(for: self)) else
        {
            return nil
        }

        return calendar.dateComponents([.day], from: date1, to: date2).day
    }

Comments

आपको स्विफ्ट देशी कैलेंडर (एनएस ड्रॉप) का उपयोग करना चाहिए। घंटे को 12pm पर सेट करते समय गार्ड का उपयोग व्यर्थ है। यह कभी असफल नहीं होगा।

— सिंह दबस

घंटे शुरू करने से पहले दोपहर तक कॉल करना यह व्यर्थ है।

— सिंह दबस

Answer 25

स्विफ्ट 5.2.4 समाधान:

import UIKit

let calendar = Calendar.current

let start = "2010-09-01"
let end = "2010-09-05"

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

let firstDate = dateFormatter.date(from: start)!
let secondDate = dateFormatter.date(from: end)!

// Replace the hour (time) of both dates with 00:00
let date1 = calendar.startOfDay(for: firstDate)
let date2 = calendar.startOfDay(for: secondDate)

let components = calendar.dateComponents([Calendar.Component.day], from: date1, to: date2)

components.day  // This will return the number of day(s) between dates

Answer 26

2017 संस्करण, कॉपी और पेस्ट

func simpleIndex(ofDate: Date) -> Int {
    
    // index here just means today 0, yesterday -1, tomorrow 1 etc.
    
    let c = Calendar.current
    let todayRightNow = Date()
    
    let d = c.date(bySetting: .hour, value: 13, of: ofDate)
    let t = c.date(bySetting: .hour, value: 13, of: todayRightNow)
    
    if d == nil || today == nil {
    
        print("weird problem simpleIndex#ofDate")
        return 0
    }
    
    let r = c.dateComponents([.day], from: today!, to: d!)
    // yesterday is negative one, tomorrow is one
    
    if let o = r.value(for: .day) {
        
        return o
    }
    else {
    
        print("another weird problem simpleIndex#ofDate")
        return 0
    }
}

Answer 27

let calendar = NSCalendar.currentCalendar();
let component1 = calendar.component(.Day, fromDate: fromDate)
let component2 = calendar.component(.Day, fromDate: toDate)
let difference  = component1 - component2

Comments

कि तारीखों के संख्या भाग के बीच के अंतर को मापता है- यानी 21 जनवरी से 22 फरवरी तक 1 दिन देगा, 32 दिन नहीं, जैसा कि होना चाहिए

— पीटर जॉनसन