(মাস / দিন / ঘন্টা / মিনিট / সেকেন্ড) এ দুটি এনএসডিটের মধ্যে পার্থক্য পাওয়া

Question

আমি বর্তমান তারিখ মধ্যে পার্থক্য পেতে চেষ্টা করছি NSDate()এবং পিএইচপি থেকে একটি তারিখ time();উদাহরণস্বরূপ কল: NSDate(timeIntervalSinceReferenceDate: 1417147270)। আমি কীভাবে দুটি তারিখের মধ্যে সময়ের পার্থক্য পেতে চলেছি। আমি একটি ফাংশন রাখতে চাই যা দুটি তারিখের সাথে তুলনা করে এবং if(seconds > 60)তারপরে এটি কয়েক মিনিট, if(minutes > 60)রিটার্ন ঘন্টা এবং if(hours > 24)ফিরতি দিন এবং আরও কিছু করে।

আমি এই সম্পর্কে কিভাবে যেতে হবে?

সম্পাদনা: বর্তমান গ্রহণযোগ্য উত্তর আমি যা করতে চেয়েছিলাম ঠিক তা করেছে। পিএইচপি time()ফাংশনটি যে ফর্মটি ব্যবহার করে সেটিতে দুটি তারিখের মধ্যে সময় পাওয়ার জন্য আমি এটি সহজ ব্যবহারের জন্য প্রস্তাব দিই । আপনি যদি পিএইচপি-র সাথে বিশেষভাবে পরিচিত না হন তবে এটি পহেলা জানুয়ারি, 1970 থেকে সেকেন্ডের সময় PH সম্ভবত আপনি যদি নোডজেএস এর মতো ব্যাকএন্ড ব্যবহার করছেন তবে নীচে পাবেন এমন কয়েকটি বিকল্প বিবেচনা করতে পারেন।

Comments

আমি বুঝতে পারি যে এটি একপ্রকার পুরানো, তবে আপনি কী পার্থক্যটি করতে চান? উদাহরণস্বরূপ, আপনি যদি ব্যবহারকারীর জন্য একটি স্ট্রিং ফর্ম্যাট করতে চান তবে আপনার ব্যবহার করা উচিত NSDateComponentsFormatter। এটি খুব কনফিগারযোগ্য, আপনাকে যথাযথভাবে সংখ্যক ফলাফল পেতে দেয় (উদাঃ .maximumUnitCount = 1)।

— কেন থমাসেস

সত্যিই, আপনি কী করতে চান এই প্রশ্নটি একেবারে প্রয়োজনীয়। বিবেচনা করুন যে এক মাস 28 দিনের কম বা 31 দিনের বেশি এক ঘন্টা পর্যন্ত হতে পারে plus

— gnasher729

stackoverflow.com/a/54452429/3908884

— দোশি

Answer 1

এক্সকোড 8.3 • সুইফট 3.1 বা তারপরে

আপনি নিম্নলিখিত হিসাবে আপনার তারিখ গণনা করতে এক্সটেনশন তৈরি করতে সহায়তা করতে আপনি ক্যালেন্ডার ব্যবহার করতে পারেন:

extension Date {
    /// Returns the amount of years from another date
    func years(from date: Date) -> Int {
        return Calendar.current.dateComponents([.year], from: date, to: self).year ?? 0
    }
    /// Returns the amount of months from another date
    func months(from date: Date) -> Int {
        return Calendar.current.dateComponents([.month], from: date, to: self).month ?? 0
    }
    /// Returns the amount of weeks from another date
    func weeks(from date: Date) -> Int {
        return Calendar.current.dateComponents([.weekOfMonth], from: date, to: self).weekOfMonth ?? 0
    }
    /// Returns the amount of days from another date
    func days(from date: Date) -> Int {
        return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
    }
    /// Returns the amount of hours from another date
    func hours(from date: Date) -> Int {
        return Calendar.current.dateComponents([.hour], from: date, to: self).hour ?? 0
    }
    /// Returns the amount of minutes from another date
    func minutes(from date: Date) -> Int {
        return Calendar.current.dateComponents([.minute], from: date, to: self).minute ?? 0
    }
    /// Returns the amount of seconds from another date
    func seconds(from date: Date) -> Int {
        return Calendar.current.dateComponents([.second], from: date, to: self).second ?? 0
    }
    /// Returns the a custom time interval description from another date
    func offset(from date: Date) -> String {
        if years(from: date)   > 0 { return "\(years(from: date))y"   }
        if months(from: date)  > 0 { return "\(months(from: date))M"  }
        if weeks(from: date)   > 0 { return "\(weeks(from: date))w"   }
        if days(from: date)    > 0 { return "\(days(from: date))d"    }
        if hours(from: date)   > 0 { return "\(hours(from: date))h"   }
        if minutes(from: date) > 0 { return "\(minutes(from: date))m" }
        if seconds(from: date) > 0 { return "\(seconds(from: date))s" }
        return ""
    }
}

---

তারিখ উপাদান বিন্যাস ব্যবহার করে

let dateComponentsFormatter = DateComponentsFormatter()
dateComponentsFormatter.allowedUnits = [.year,.month,.weekOfMonth,.day,.hour,.minute,.second]
dateComponentsFormatter.maximumUnitCount = 1
dateComponentsFormatter.unitsStyle = .full
dateComponentsFormatter.string(from: Date(), to: Date(timeIntervalSinceNow: 4000000))  // "1 month"

---

let date1 = DateComponents(calendar: .current, year: 2014, month: 11, day: 28, hour: 5, minute: 9).date!
let date2 = DateComponents(calendar: .current, year: 2015, month: 8, day: 28, hour: 5, minute: 9).date!

let years = date2.years(from: date1)     // 0
let months = date2.months(from: date1)   // 9
let weeks = date2.weeks(from: date1)     // 39
let days = date2.days(from: date1)       // 273
let hours = date2.hours(from: date1)     // 6,553
let minutes = date2.minutes(from: date1) // 393,180
let seconds = date2.seconds(from: date1) // 23,590,800

let timeOffset = date2.offset(from: date1) // "9M"

let date3 = DateComponents(calendar: .current, year: 2014, month: 11, day: 28, hour: 5, minute: 9).date!
let date4 = DateComponents(calendar: .current, year: 2015, month: 11, day: 28, hour: 5, minute: 9).date!

let timeOffset2 = date4.offset(from: date3) // "1y"

let date5 = DateComponents(calendar: .current, year: 2017, month: 4, day: 28).date!
let now = Date()
let timeOffset3 = now.offset(from: date5) // "1w"

Comments

সুইফট ২.০ এ .CalendarUnitSecondত্রুটি দেয় 'NSCalendarUnit.Type' does not have a member named 'CalendarUnitSecond', আপনি কীভাবে এটি সমাধান করবেন জানেন?

— ম্যাট.ক্যার

@ ম্যাট.কার আপনাকে আপনার ব্যবহার করতে হবে .সেকেন্ড এবং পরিবর্তে বিকল্পগুলির: আপনার প্রয়োজন বিকল্পগুলি ব্যবহার করতে হবে: []। আপনি আমার সম্পাদনাটি একবার দেখে নিতে পারেন।

— লিও ডাবাস

আমি এই উত্তরে সদৃশগুলিকে ঘৃণা করি, আমি (আইওএস> 8) এর উপর ভিত্তি করে NSCalendarUnitবাস্তবায়িত একটি পদ্ধতি ব্যবহার করব return Calendar.current().components(unit, from: date, to: self, options: [])?. valueForComponent(unit)।

— সুলতান

যেহেতু উত্তরটি ব্যবহার DateComponentsFormatterকরা অনেক দীর্ঘ কাজ করার চেয়ে অনেক ভাল, তাই এটি উত্তরটির শীর্ষে থাকা উচিত।

— rmaddy

আপনি একেবারে আশ্চর্য! এই এক্সটেনশনটি আমাকে অনেক সাহায্য করেছে!

— মারিয়ান পেট্রিসর

Answer 2

কারও যদি সর্বকালের ইউনিটগুলি প্রদর্শনের প্রয়োজন হয় যেমন "ঘন্টা কয়েক মিনিট সেকেন্ড" কেবল "ঘন্টা" নয়। ধরা যাক দুটি তারিখের মধ্যে সময়ের পার্থক্য হল 1 ঘন্টা 59 মিনিট 20 সেকেন্ড। এই ফাংশনটি "1h 59m 20s" প্রদর্শন করবে।

এখানে আমার উদ্দেশ্য-সি কোডটি রয়েছে:

extension NSDate {

    func offsetFrom(date: NSDate) -> String {

        let dayHourMinuteSecond: NSCalendarUnit = [.Day, .Hour, .Minute, .Second]
        let difference = NSCalendar.currentCalendar().components(dayHourMinuteSecond, fromDate: date, toDate: self, options: [])

        let seconds = "\(difference.second)s"
        let minutes = "\(difference.minute)m" + " " + seconds
        let hours = "\(difference.hour)h" + " " + minutes
        let days = "\(difference.day)d" + " " + hours

        if difference.day    > 0 { return days }
        if difference.hour   > 0 { return hours }
        if difference.minute > 0 { return minutes }
        if difference.second > 0 { return seconds }
        return ""
    }

}

---

সুইফ্ট 3+ এ:

extension Date {

    func offsetFrom(date: Date) -> String {

        let dayHourMinuteSecond: Set<Calendar.Component> = [.day, .hour, .minute, .second]
        let difference = NSCalendar.current.dateComponents(dayHourMinuteSecond, from: date, to: self)

        let seconds = "\(difference.second ?? 0)s"
        let minutes = "\(difference.minute ?? 0)m" + " " + seconds
        let hours = "\(difference.hour ?? 0)h" + " " + minutes
        let days = "\(difference.day ?? 0)d" + " " + hours

        if let day = difference.day, day          > 0 { return days }
        if let hour = difference.hour, hour       > 0 { return hours }
        if let minute = difference.minute, minute > 0 { return minutes }
        if let second = difference.second, second > 0 { return seconds }
        return ""
    }

}

Comments

এটাই আমার দরকার। সহজ, এবং কাজ সম্পন্ন হয়।

— চেন লি

Answer 3

আপনি জিজ্ঞাসা:

আমি একটি ফাংশন রাখতে চাই যা দুটি তারিখের সাথে তুলনা করে এবং যদি (সেকেন্ড> 60) তবে এটি কয়েক মিনিট, যদি (মিনিট> 60) রিটার্ন ঘন্টা এবং যদি (ঘন্টা> 24) ফিরে আসে এবং ইত্যাদি so

আমি ধরে নিচ্ছি যে আপনি দুটি তারিখের মধ্যে অতিবাহিত সময়ের একটি স্ট্রিং উপস্থাপনা তৈরি করার চেষ্টা করছেন। এটি করার জন্য আপনার নিজের কোড লেখার পরিবর্তে, অ্যাপল ইতিমধ্যে একটি ক্লাস তৈরি করেছে যা সুনির্দিষ্টভাবে করার জন্য। যথা, ব্যবহার করুন DateComponentsFormatter, allowedUnitsআপনার অ্যাপ্লিকেশনটিতে যা মান রয়েছে তা সেট করুন, unitsStyleআপনি যা চান সেট করুন (যেমন .full) এবং তারপরে কল করুন string(from:to:)।

যেমন সুইফ্ট 3:

let previousDate = ...
let now = Date()

let formatter = DateComponentsFormatter()
formatter.unitsStyle = .full
formatter.allowedUnits = [.month, .day, .hour, .minute, .second]
formatter.maximumUnitCount = 2   // often, you don't care about seconds if the elapsed time is in months, so you'll set max unit to whatever is appropriate in your case

let string = formatter.string(from: previousDate, to: now)

এটি প্রশ্নযুক্ত ডিভাইসের জন্য উপযুক্ত স্ট্রিংটিকে স্থানীয়করণ করবে।

বা, সুইফট ২.৩ এ:

let previousDate = ...
let now = NSDate()

let formatter = NSDateComponentsFormatter()
formatter.unitsStyle = .Full
formatter.allowedUnits = [.Month, .Day, .Hour, .Minute, .Second]
formatter.maximumUnitCount = 2

let string = formatter.stringFromDate(previousDate, toDate: now)

---

আপনি যদি আসল সংখ্যাসূচক মানগুলি সন্ধান করেন তবে কেবল ব্যবহার করুন dateComponents। যেমন সুইফ্ট 3:

let components = Calendar.current.dateComponents([.month, .day, .hour, .minute, .second], from: previousDate, to: now)

বা, সুইফট ২.৩ এ:

let components = NSCalendar.currentCalendar().components([.Month, .Day, .Hour, .Minute, .Second], fromDate: previousDate, toDate: now, options: [])

Answer 4

@ লিও-ডাবসের উত্তর থেকে সম্মিলিত এক্সটেনশন + তারিখের উপাদানগুলি ফর্ম্যাটর

এক্সকোড 8.3 • সুইফট 3.1

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

let dateComponentsFormatter = DateComponentsFormatter()
dateComponentsFormatter.difference(from: Date(), to: Date(timeIntervalSinceNow: 4000000)) // "1 month"

Answer 5

   func dateDiff(dateStr:String) -> String {
            var f:NSDateFormatter = NSDateFormatter()
            f.timeZone = NSTimeZone.localTimeZone()
            f.dateFormat = "yyyy-M-dd'T'HH:mm:ss.SSSZZZ"

            var now = f.stringFromDate(NSDate())
            var startDate = f.dateFromString(dateStr)
            var endDate = f.dateFromString(now)
            var calendar: NSCalendar = NSCalendar.currentCalendar()

            let calendarUnits = NSCalendarUnit.CalendarUnitWeekOfMonth | NSCalendarUnit.CalendarUnitDay | NSCalendarUnit.CalendarUnitHour | NSCalendarUnit.CalendarUnitMinute | NSCalendarUnit.CalendarUnitSecond
            let dateComponents = calendar.components(calendarUnits, fromDate: startDate!, toDate: endDate!, options: nil)

            let weeks = abs(dateComponents.weekOfMonth)
            let days = abs(dateComponents.day)
            let hours = abs(dateComponents.hour)
            let min = abs(dateComponents.minute)
            let sec = abs(dateComponents.second)

            var timeAgo = ""

            if (sec > 0){
                if (sec > 1) {
                    timeAgo = "\(sec) Seconds Ago"
                } else {
                    timeAgo = "\(sec) Second Ago"
                }
            }

            if (min > 0){
                if (min > 1) {
                    timeAgo = "\(min) Minutes Ago"
                } else {
                    timeAgo = "\(min) Minute Ago"
                }
            }

            if(hours > 0){
                if (hours > 1) {
                    timeAgo = "\(hours) Hours Ago"
                } else {
                    timeAgo = "\(hours) Hour Ago"
                }
            }

            if (days > 0) {
                if (days > 1) {
                    timeAgo = "\(days) Days Ago"
                } else {
                    timeAgo = "\(days) Day Ago"
                }
            }

            if(weeks > 0){
                if (weeks > 1) {
                    timeAgo = "\(weeks) Weeks Ago"
                } else {
                    timeAgo = "\(weeks) Week Ago"
                }
            }

            print("timeAgo is===> \(timeAgo)")
            return timeAgo;
        }

Comments

তারিখের ফর্ম্যাটারটি লোড করার চেষ্টা করুন এবং আরও স্থির বিকল্পটি এটি স্থির করে তোলা হবে

— Thesummersign

Answer 6

লিও ডাবাসের অ্যাঞ্জারটিতে আমি একটি "দীর্ঘ" সংস্করণ যুক্ত করেছি যদি আপনি এমন স্ট্রিং পেতে চান যা "2 সপ্তাহ" এর পরিবর্তে "2 সপ্তাহ আগে" এর মতো কিছু বলে ...

extension Date {
    /// Returns the amount of years from another date
    func years(from date: Date) -> Int {
        return Calendar.current.dateComponents([.year], from: date, to: self).year ?? 0
    }
    /// Returns the amount of months from another date
    func months(from date: Date) -> Int {
        return Calendar.current.dateComponents([.month], from: date, to: self).month ?? 0
    }
    /// Returns the amount of weeks from another date
    func weeks(from date: Date) -> Int {
        return Calendar.current.dateComponents([.weekOfYear], from: date, to: self).weekOfYear ?? 0
    }
    /// Returns the amount of days from another date
    func days(from date: Date) -> Int {
        return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
    }
    /// Returns the amount of hours from another date
    func hours(from date: Date) -> Int {
        return Calendar.current.dateComponents([.hour], from: date, to: self).hour ?? 0
    }
    /// Returns the amount of minutes from another date
    func minutes(from date: Date) -> Int {
        return Calendar.current.dateComponents([.minute], from: date, to: self).minute ?? 0
    }
    /// Returns the amount of seconds from another date
    func seconds(from date: Date) -> Int {
        return Calendar.current.dateComponents([.second], from: date, to: self).second ?? 0
    }
    /// Returns the a custom time interval description from another date
    func offset(from date: Date) -> String {
        if years(from: date)   > 0 { return "\(years(from: date))y"   }
        if months(from: date)  > 0 { return "\(months(from: date))M"  }
        if weeks(from: date)   > 0 { return "\(weeks(from: date))w"   }
        if days(from: date)    > 0 { return "\(days(from: date))d"    }
        if hours(from: date)   > 0 { return "\(hours(from: date))h"   }
        if minutes(from: date) > 0 { return "\(minutes(from: date))m" }
        if seconds(from: date) > 0 { return "\(seconds(from: date))s" }
        return ""
    }

    func offsetLong(from date: Date) -> String {
        if years(from: date)   > 0 { return years(from: date) > 1 ? "\(years(from: date)) years ago" : "\(years(from: date)) year ago" }
        if months(from: date)  > 0 { return months(from: date) > 1 ? "\(months(from: date)) months ago" : "\(months(from: date)) month ago" }
        if weeks(from: date)   > 0 { return weeks(from: date) > 1 ? "\(weeks(from: date)) weeks ago" : "\(weeks(from: date)) week ago"   }
        if days(from: date)    > 0 { return days(from: date) > 1 ? "\(days(from: date)) days ago" : "\(days(from: date)) day ago" }
        if hours(from: date)   > 0 { return hours(from: date) > 1 ? "\(hours(from: date)) hours ago" : "\(hours(from: date)) hour ago"   }
        if minutes(from: date) > 0 { return minutes(from: date) > 1 ? "\(minutes(from: date)) minutes ago" : "\(minutes(from: date)) minute ago" }
        if seconds(from: date) > 0 { return seconds(from: date) > 1 ? "\(seconds(from: date)) seconds ago" : "\(seconds(from: date)) second ago" }
        return ""
    }

}

Answer 7

-> এই ব্যবহারের দুইটি তারিখের মধ্যে সময় ফাঁক খুঁজে পেতে সুইফট (দুই স্ট্রিং সঙ্গে)।

func timeGapBetweenDates(previousDate : String,currentDate : String)
{
    let dateString1 = previousDate
    let dateString2 = currentDate

    let Dateformatter = DateFormatter()
    Dateformatter.dateFormat = "yyyy-MM-dd HH:mm:ss"


    let date1 = Dateformatter.date(from: dateString1)
    let date2 = Dateformatter.date(from: dateString2)


    let distanceBetweenDates: TimeInterval? = date2?.timeIntervalSince(date1!)
    let secondsInAnHour: Double = 3600
    let minsInAnHour: Double = 60
    let secondsInDays: Double = 86400
    let secondsInWeek: Double = 604800
    let secondsInMonths : Double = 2592000
    let secondsInYears : Double = 31104000

    let minBetweenDates = Int((distanceBetweenDates! / minsInAnHour))
    let hoursBetweenDates = Int((distanceBetweenDates! / secondsInAnHour))
    let daysBetweenDates = Int((distanceBetweenDates! / secondsInDays))
    let weekBetweenDates = Int((distanceBetweenDates! / secondsInWeek))
    let monthsbetweenDates = Int((distanceBetweenDates! / secondsInMonths))
    let yearbetweenDates = Int((distanceBetweenDates! / secondsInYears))
    let secbetweenDates = Int(distanceBetweenDates!)




    if yearbetweenDates > 0
    {
        print(yearbetweenDates,"years")//0 years
    }
    else if monthsbetweenDates > 0
    {
        print(monthsbetweenDates,"months")//0 months
    }
    else if weekBetweenDates > 0
    {
        print(weekBetweenDates,"weeks")//0 weeks
    }
    else if daysBetweenDates > 0
    {
        print(daysBetweenDates,"days")//5 days
    }
    else if hoursBetweenDates > 0
    {
        print(hoursBetweenDates,"hours")//120 hours
    }
    else if minBetweenDates > 0
    {
        print(minBetweenDates,"minutes")//7200 minutes
    }
    else if secbetweenDates > 0
    {
        print(secbetweenDates,"seconds")//seconds
    }
}

Answer 8

সুইফট ৩.০ এর জন্য কিছুটা সংশোধিত কোড

let calendar = NSCalendar.current as NSCalendar

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

let flags = NSCalendar.Unit.day
let components = calendar.components(flags, from: date1, to: date2, options: [])

return components.day!

Answer 9

সুইফ্ট 5.1 • আইওএস 13

অ্যাপল আইওএস 13 এ প্রবর্তিত আপনি রিলেটিভডেট ফরমেটার ব্যবহার করতে পারেন ।

let exampleDate = Date().addingTimeInterval(-15000)

let formatter = RelativeDateTimeFormatter()
formatter.unitsStyle = .full
let relativeDate = formatter.localizedString(for: exampleDate, relativeTo: Date())

print(relativeDate) // 4 hours ago

RelativeDateTime Formatter ব্যবহার করে কীভাবে আপেক্ষিক তারিখ এবং সময় দেখানো যায় তা দেখুন ।

Answer 10

আপনার উদ্দেশ্য যদি দুটি তারিখের মধ্যে সঠিক দিনের নম্বর পাওয়া যায় তবে আপনি এই সমস্যাটি নিয়ে এইভাবে কাজ করতে পারেন:

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

var calendar: NSCalendar = 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.DayCalendarUnit
let components = calendar.components(flags, fromDate: date1, toDate: date2, options: nil)

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

Answer 11

আপনার প্রয়োজন অনুসারে সুইফট 3 এর সাহায্যে আপনি আপনার সমস্যা সমাধানের জন্য নিম্নলিখিত দুটি উপায়ের একটি বেছে নিতে পারেন।

---

1. ব্যবহারকারীর কাছে দুটি তারিখের মধ্যে পার্থক্য প্রদর্শন করুন

আপনি DateComponentsFormatterআপনার অ্যাপ্লিকেশনটির ইন্টারফেসের জন্য স্ট্রিং তৈরি করতে একটি ব্যবহার করতে পারেন । নিম্নলিখিত ঘোষণা সহ DateComponentsFormatterএকটি maximumUnitCountসম্পত্তি আছে :

var maximumUnitCount: Int { get set }

ফলাফলটি স্ট্রিংয়ে প্রদর্শিত ইউনিটগুলির সংখ্যা সীমাবদ্ধ করতে এই সম্পত্তিটি ব্যবহার করুন। উদাহরণস্বরূপ, এই সম্পত্তিটি "1h 10m, 30s" এর পরিবর্তে 2 এ সেট করা হলেও ফলাফলটি স্ট্রিংটি "1h 10m" হবে। আপনি যখন জায়গার জন্য সীমাবদ্ধ থাকেন বা নিকটতম বৃহত্তর ইউনিটটিতে মানগুলি পেতে চান তখন এই সম্পত্তিটি ব্যবহার করুন।

maximumUnitCountএর মান সেট করে 1, আপনি কেবলমাত্র একটি DateComponentsFormatterইউনিটে (বছর, মাস, দিন, ঘন্টা বা মিনিট) পার্থক্য প্রদর্শনের গ্যারান্টিযুক্ত ।

নীচের খেলার মাঠের কোডটি দেখায় যে কীভাবে দুটি তারিখের মধ্যে পার্থক্য প্রদর্শিত হবে:

import Foundation

let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
let newDate = Date(timeIntervalSinceReferenceDate: 0)

let dateComponentsFormatter = DateComponentsFormatter()
dateComponentsFormatter.allowedUnits = [NSCalendar.Unit.year, .month, .day, .hour, .minute]
dateComponentsFormatter.maximumUnitCount = 1
dateComponentsFormatter.unitsStyle = DateComponentsFormatter.UnitsStyle.full
let timeDifference = dateComponentsFormatter.string(from: oldDate, to: newDate)

print(String(reflecting: timeDifference)) // prints Optional("5 hours")

মনে রাখবেন যে DateComponentsFormatterফলাফলটি চারদিকে রয়েছে। সুতরাং, 4 ঘন্টা এবং 30 মিনিটের পার্থক্যটি 5 ঘন্টা হিসাবে প্রদর্শিত হবে ।

আপনার যদি এই অপারেশনটি পুনরাবৃত্তি করতে হয় তবে আপনি নিজের কোডটি রিফেক্টর করতে পারেন:

import Foundation

struct Formatters {

    static let dateComponentsFormatter: DateComponentsFormatter = {
        let dateComponentsFormatter = DateComponentsFormatter()
        dateComponentsFormatter.allowedUnits = [NSCalendar.Unit.year, .month, .day, .hour, .minute]
        dateComponentsFormatter.maximumUnitCount = 1
        dateComponentsFormatter.unitsStyle = DateComponentsFormatter.UnitsStyle.full
        return dateComponentsFormatter
    }()

}

extension Date {
    
    func offset(from: Date) -> String? {
        return Formatters.dateComponentsFormatter.string(from: oldDate, to: self)
    }
    
}

let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
let newDate = Date(timeIntervalSinceReferenceDate: 0)

let timeDifference = newDate.offset(from: oldDate)
print(String(reflecting: timeDifference)) // prints Optional("5 hours")

---

2. বিন্যাস ছাড়াই দুটি তারিখের মধ্যে পার্থক্য পান

যদি আপনার ব্যবহারকারীর কাছে দুটি তারিখের মধ্যে পার্থক্য বিন্যাসের সাথে প্রদর্শন করার প্রয়োজন না হয় তবে আপনি এটি ব্যবহার করতে পারেন Calendar। Calendarএকটি পদ্ধতি dateComponents(_:from:to:)রয়েছে যার নিম্নলিখিত ঘোষণা রয়েছে:

func dateComponents(_ components: Set<Calendar.Component>, from start: Date, to end: Date) -> DateComponents

দুটি তারিখের মধ্যে পার্থক্য প্রদান করে।

নীচের প্লেগ্রাউন্ড কোডটি dateComponents(_:from:to:)দেখায় যে মাত্র এক ধরণের Calendar.Component(বছর, মাস, দিন, ঘন্টা বা মিনিট) পার্থক্যটি ফিরিয়ে কীভাবে দুটি তারিখের মধ্যে পার্থক্যটি পুনরুদ্ধার করতে হয় ।

import Foundation

let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
let newDate = Date(timeIntervalSinceReferenceDate: 0)

let descendingOrderedComponents = [Calendar.Component.year, .month, .day, .hour, .minute]
let dateComponents = Calendar.current.dateComponents(Set(descendingOrderedComponents), from: oldDate, to: newDate)
let arrayOfTuples = descendingOrderedComponents.map { ($0, dateComponents.value(for: $0)) }

for (component, value) in arrayOfTuples {
    if let value = value, value > 0 {
        print(component, value) // prints hour 4
        break
    }
}

আপনার যদি এই অপারেশনটি পুনরাবৃত্তি করতে হয় তবে আপনি নিজের কোডটি রিফেক্টর করতে পারেন:

import Foundation

extension Date {
    
    func offset(from: Date) -> (Calendar.Component, Int)? {
        let descendingOrderedComponents = [Calendar.Component.year, .month, .day, .hour, .minute]
        let dateComponents = Calendar.current.dateComponents(Set(descendingOrderedComponents), from: from, to: self)
        let arrayOfTuples = descendingOrderedComponents.map { ($0, dateComponents.value(for: $0)) }
        
        for (component, value) in arrayOfTuples {
            if let value = value, value > 0 {
                return (component, value)
            }
        }
        
        return nil
    }

}

let oldDate = Date(timeIntervalSinceReferenceDate: -16200)
let newDate = Date(timeIntervalSinceReferenceDate: 0)

if let (component, value) = newDate.offset(from: oldDate) {
    print(component, value) // prints hour 4
}

Answer 12

সুইফটে ২.২

    /// Returns the amount of years from another date
func years(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components([.Year], fromDate: fromdate, toDate: NSDate(), options: []).year ?? 0
}
/// Returns the amount of months from another date
func months(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components([.Month], fromDate: fromdate, toDate: NSDate(), options: []).month ?? 0
}
/// Returns the amount of weeks from another date
func weeks(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components([.WeekOfYear], fromDate: fromdate, toDate: NSDate(), options: []).weekOfYear ?? 0
}
/// Returns the amount of days from another date
func days(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components([.Day], fromDate: fromdate, toDate: NSDate(), options: []).day ?? 0
}
/// Returns the amount of hours from another date
func hours(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components([.Hour], fromDate: fromdate, toDate: NSDate(), options: []).hour ?? 0
}
/// Returns the amount of minutes from another date
func minutes(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components([.Minute], fromDate: fromdate, toDate: NSDate(), options: []).minute ?? 0
}
/// Returns the amount of seconds from another date
func seconds(fromdate: NSDate) -> Int {
    return NSCalendar.currentCalendar().components(.Second, fromDate: fromdate, toDate: NSDate(), options: []).second ?? 0
}

Answer 13

বহুবচন সংস্করণ সরবরাহ করতে এবং আরও বেশি মানব পাঠযোগ্য হতে লিও ডাবাসের উত্তরে একটি ছোট সংযোজন।

সুইফট 3

extension Date {
    /// Returns the amount of years from another date
    func years(from date: Date) -> Int {
        return Calendar.current.dateComponents([.year], from: date, to: self).year ?? 0
    }
    /// Returns the amount of months from another date
    func months(from date: Date) -> Int {
        return Calendar.current.dateComponents([.month], from: date, to: self).month ?? 0
    }
    /// Returns the amount of weeks from another date
    func weeks(from date: Date) -> Int {
        return Calendar.current.dateComponents([.weekOfMonth], from: date, to: self).weekOfMonth ?? 0
    }
    /// Returns the amount of days from another date
    func days(from date: Date) -> Int {
        return Calendar.current.dateComponents([.day], from: date, to: self).day ?? 0
    }
    /// Returns the amount of hours from another date
    func hours(from date: Date) -> Int {
        return Calendar.current.dateComponents([.hour], from: date, to: self).hour ?? 0
    }
    /// Returns the amount of minutes from another date
    func minutes(from date: Date) -> Int {
        return Calendar.current.dateComponents([.minute], from: date, to: self).minute ?? 0
    }
    /// Returns the amount of seconds from another date
    func seconds(from date: Date) -> Int {
        return Calendar.current.dateComponents([.second], from: date, to: self).second ?? 0
    }
    /// Returns the a custom time interval description from another date
    func offset(from date: Date) -> String {
        if years(from: date)   == 1 { return "\(years(from: date)) year"   } else if years(from: date)   > 1 { return "\(years(from: date)) years"   }
        if months(from: date)  == 1 { return "\(months(from: date)) month"  } else if months(from: date)  > 1 { return "\(months(from: date)) month"  }
        if weeks(from: date)   == 1 { return "\(weeks(from: date)) week"   } else if weeks(from: date)   > 1 { return "\(weeks(from: date)) weeks"   }
        if days(from: date)    == 1 { return "\(days(from: date)) day"    } else if days(from: date)    > 1 { return "\(days(from: date)) days"    }
        if hours(from: date)   == 1 { return "\(hours(from: date)) hour"   } else if hours(from: date)   > 1 { return "\(hours(from: date)) hours"   }
        if minutes(from: date) == 1 { return "\(minutes(from: date)) minute" } else if minutes(from: date) > 1 { return "\(minutes(from: date)) minutes" }
        return ""
    }
}

Answer 14

এটি সংক্ষিপ্ত সংস্করণ: মূলত আমি Date()এখনকার সাথে পোস্ট টাইমস্ট্যাম্পের মধ্যে পার্থক্য পাওয়ার চেষ্টা করি ।

// MARK: - UPDATE Time Stamp
static func updateTimeStampPost(postTimeStamp: Date?, _ completion: (_ finalString: String?) -> Void) {
    // date in the current state
    let date = Date()
    let dateComponentFormatter = DateComponentsFormatter()

    // change the styling date, wether second minute or hour
    dateComponentFormatter.unitsStyle = .abbreviated
    dateComponentFormatter.allowedUnits = [.second, .minute, .hour, .day, .weekOfMonth]
    dateComponentFormatter.maximumUnitCount = 1

    // return the date new format as a string in the completion
    completion(dateComponentFormatter.string(from: postTimeStamp!, to: date))
}

Answer 15

উপরের সুইফট 3 উত্তরের জন্য আমার উত্তর এখানে। এটি নভেম্বর ২০১ of সালের মতো বর্তমান, এক্সকোডের প্রকাশটি ছিল 8.2 বিটা (8 সি 23)। উপরের সাগর এবং এমিন উভয়ের কয়েকটি পরামর্শ ব্যবহার করেছেন এবং মাঝে মাঝে সিনট্যাক্সের পরামর্শ দেওয়ার জন্য এক্সকোডকে স্বতঃপূরণ দিতে হয়েছিল। দেখে মনে হয়েছিল সিনট্যাক্সটি সত্যই এই বিটা সংস্করণে পরিবর্তিত হয়েছে। buyDateআমি একটি ডেটপিকার থেকে পেয়েছি:

let calendar = NSCalendar.current as NSCalendar
let currentDate = Date()
let date1 = calendar.startOfDay(for: buyDate!)
let date2 = calendar.startOfDay(for: currentDate)      
let flags = NSCalendar.Unit.day
let components = calendar.components(flags, from: date1, to: date2)
NSLog(" day= \(components.day)")

Comments

দুঃখিত, আমি এখন এটি দেখছি, এটি সাগরের সমাধান। আমি অনেকগুলি পুনরাবৃত্তি করেছি এবং অনেকগুলি চেষ্টা করেছিলাম আমার মনে হয়েছিল এটি পরিবর্তিত হয়েছে। এমিন এর সমাধান সর্বশেষ সুইফট 3. জন্য কাজ করে না

— renaissanceMan

আপনার সত্যই NSCalendarসুইফট 3 ব্যবহার করা উচিত নয় Use ব্যবহার করুন Calendar। সুতরাং এটি সহজ করা হয় let calendar = Calendar.current। এবং তারপর componentsঅনুরূপ হবে: let components = calendar.dateComponents([.day], from: date1, to: date2)।

— রব

Answer 16

এক্সকোড সংস্করণ 8.3.3 এবং সুইফট 3.0 এর জন্য:

    let dateFormatter = DateFormatter()
    dateFormatter.dateStyle = .medium
    dateFormatter.timeStyle = .short

    var beginDate = "2017-08-24 12:00:00"
    var endDate = "2017-09-07 12:00:00"


    let startDateTime = dateFormatter.date(from: beginDate) //according to date format your date string
    print(startDateTime ?? "") //Convert String to Date

    let endDateTime = dateFormatter.date(from: endDate) //according to date format your date string
    print(endDateTime ?? "") //Convert String to Date

    let dateComponentsFormatter = DateComponentsFormatter()
    dateComponentsFormatter.allowedUnits = [NSCalendar.Unit.minute,NSCalendar.Unit.hour,NSCalendar.Unit.day]


   let interval = endDateTime!.timeIntervalSince(startDateTime!)
   var diff = dateComponentsFormatter.string(from: interval)!

   print(diff)

   var day_i  = 0
   var hour_i = 0
   var min_i = 0


     if (diff.contains("d"))
       {
              let day = diff.substring(to: (diff.range(of: "d")?.lowerBound)!)

               day_i  = Int(day)!
               print ("day --> \(day_i)")

               diff = diff.substring(from:(diff.range(of : " ")?.upperBound )!)
               print(diff)
       }


       let hour = diff.substring(to: (diff.range(of : ":")?.lowerBound )!)
       hour_i  = Int(hour)!
       print ("hour --> \(hour_i)")

       let min = diff.substring(from: (diff.range(of : ":")?.upperBound )!)
       min_i  = Int(min)!
       print ("min --> \(min_i)")

Answer 17

এটি সুইফট ৩.০ এবং তারপরের সাথে সামঞ্জস্য করতে জোসে920405 উত্তরে কিছু সংযোজন

func getDateTimeDiff(dateStr:String) -> String {

    let formatter : DateFormatter = DateFormatter()
    formatter.timeZone = NSTimeZone.local
    formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"

    let now = formatter.string(from: NSDate() as Date)
    let startDate = formatter.date(from: dateStr)
    let endDate = formatter.date(from: now)

    // *** create calendar object ***
    var calendar = NSCalendar.current

    // *** Get components using current Local & Timezone ***
    print(calendar.dateComponents([.year, .month, .day, .hour, .minute, .second], from: startDate!))

    // *** define calendar components to use as well Timezone to UTC ***
    let unitFlags = Set<Calendar.Component>([.year, .month, .day, .hour, .minute, .second])
    calendar.timeZone = TimeZone(identifier: "UTC")!
    let dateComponents = calendar.dateComponents(unitFlags, from: startDate!, to: endDate!)

    // *** Get Individual components from date ***
    let years = dateComponents.year!
    let months = dateComponents.month!
    let days = dateComponents.day!
    let hours = dateComponents.hour!
    let minutes = dateComponents.minute!
    let seconds = dateComponents.second!

    var timeAgo = ""

    if (seconds > 0){
        if seconds < 2 {
            timeAgo = "Second Ago"
        }
        else{
            timeAgo = "\(seconds) Second Ago"
        }
    }

    if (minutes > 0){
        if minutes < 2 {
            timeAgo = "Minute Ago"
        }
        else{
            timeAgo = "\(minutes) Minutes Ago"
        }
    }

    if(hours > 0){
        if minutes < 2 {
            timeAgo = "Hour Ago"
        }
        else{
            timeAgo = "\(hours) Hours Ago"
        }
    }

    if (days > 0) {
        if minutes < 2 {
            timeAgo = "Day Ago"
        }
        else{
            timeAgo = "\(days) Days Ago"
        }
    }

    if(months > 0){
        if minutes < 2 {
            timeAgo = "Month Ago"
        }
        else{
            timeAgo = "\(months) Months Ago"
        }
    }

    if(years > 0){
        if minutes < 2 {
            timeAgo = "Year Ago"
        }
        else{
            timeAgo = "\(years) Years Ago"
        }
    }

    DLog("timeAgo is ===> \(timeAgo)")
    return timeAgo;
}

Answer 18

এই কোডটি ব্যবহার করুন:

let registrationDateString = "2008-10-06 00:00:00"
    let dateFormatter = DateFormatter()
    dateFormatter.dateFormat = "yyyy-MM-dd hh:mm:ss"
    if let registrationDate = dateFormatter.date(from: registrationDateString) {
        let currentDate = Date()
        let dateDifference = Calendar.current.dateComponents([.day, .month, .year],
                                                               from: registrationDate,
                                                               to: currentDate)
        print("--------------------- Result: \(dateDifference.year ?? 0) years \(dateDifference.month ?? 0) months and \(dateDifference.day ?? 0) days")
    } else {
        print("--------------------- No result")
    }

আউটপুট: ফলাফল: 10 বছর 1 মাস এবং 18 দিন

Answer 19

import Foundation

extension DateComponents {

    func dateComponentsToTimeString() -> String {

        var hour = "\(self.hour!)"
        var minute = "\(self.minute!)"
        var second = "\(self.second!)"

        if self.hour! < 10 { hour = "0" + hour }
        if self.minute! < 10 { minute = "0" + minute }
        if self.second! < 10 { second = "0" + second }

        let str = "\(hour):\(minute):\(second)"
        return str
    }

}

extension Date {

    func offset(from date: Date)-> DateComponents {
        let components = Set<Calendar.Component>([.second, .minute, .hour, .day, .month, .year])
        let differenceOfDate = Calendar.current.dateComponents(components, from: date, to: self)
        return differenceOfDate
    }
}

ব্যবহার করুন:

var durationString: String {
        return self.endTime.offset(from: self.startTime).dateComponentsToTimeString()
    }