Swift 显示从 Date (NSDate) 开始的时间

Question

在一个单元格中，我想显示 Parse 服务器中 NSDate 的时间。这是代码，但它不起作用。什么都没有改变，数据也没有被解析。

    if let createdat = (object?["createdAt"] as? String){
            let pastDate = Date(timeIntervalSinceNow: TimeInterval(createdat)!)
            cell.TimeAgo.text = pastDate.timeAgoDisplay()
        }


       extension Date {
          func timeAgoDisplay() -> String {
        let secondsAgo = Int(Date().timeIntervalSince(self))

        let minute = 60
        let hour = 60 * minute
        let day = 24 * hour
        let week = 7 * day

        if secondsAgo < minute {
            return "\(secondsAgo) sec ago"
        } else if secondsAgo < hour {
            return "\(secondsAgo / minute) min ago"
        } else if secondsAgo < day {
            return "\(secondsAgo / hour) hrs ago"
        } else if secondsAgo < week {
            return "\(secondsAgo / day) days ago"
        }

        return "\(secondsAgo / week) weeks ago"
    }
}

Answer 1

If you just want a Time Ago extension for Date go to the bottom of the answer

我将向您展示一个示例，只是为了在几秒钟前和之后显示您的扩展更新。

注意：如果需要，可以直接使用Pase的日期：

if let pastDate = (object?["createdAt"] as? Date) {
    cell.TimeAgo.text = pastDate.timeAgoDisplay()
}

因为 Swift 5.1

示例如何使用 Swift 显示秒前 5.1:

自从 iOS13 Apple 推出新的 class RelativeDateTimeFormatter

extension Date {
    func timeAgoDisplay() -> String {
        let formatter = RelativeDateTimeFormatter()
        formatter.unitsStyle = .full
        return formatter.localizedString(for: self, relativeTo: Date())
    }
}

此 class 将允许您根据您的语言获取时间前的字符串。它会根据您的间隔自动 select 正确的时间单位，示例如下：

|--------------------------|------------------|
| Time interval in seconds |      Display     |
|--------------------------|------------------|
|             -6           |   6 seconds ago  |
|            -60           |   1 minute ago   |
|           -600           |  10 minutes ago  |
|          -6000           |    1 hour ago    |
|         -60000           |   16 hours ago   |
|--------------------------|------------------|

您会注意到它会自动为您处理复数形式。

Swift 3 或 Swift 4

示例如何使用 Swift 3 或 Swift 4:

首先：要获得秒数，我们需要检查是否有一分钟或更短时间，要获得当前日期减去一分钟，您可以这样写：

let minuteAgo = calendar.date(byAdding: .minute, value: -1, to: Date())!

第二：现在比较两个日期！（如果是您的扩展，我们会自行替换 yourDate）并计算这两个日期之间的差异。

if (minuteAgo < yourDate) {
    let diff = Calendar.current.dateComponents([.second], from: yourDate, to: Date()).second ?? 0
    print("\(diff) sec ago")
}

到此为止，现在您可以打印时间了！

所以你的扩展是这样的：（这是获取时间的简单扩展）

extension Date {
    func timeAgoDisplay() -> String {
 
        let calendar = Calendar.current
        let minuteAgo = calendar.date(byAdding: .minute, value: -1, to: Date())!
        let hourAgo = calendar.date(byAdding: .hour, value: -1, to: Date())!
        let dayAgo = calendar.date(byAdding: .day, value: -1, to: Date())!
        let weekAgo = calendar.date(byAdding: .day, value: -7, to: Date())!

        if minuteAgo < self {
            let diff = Calendar.current.dateComponents([.second], from: self, to: Date()).second ?? 0
            return "\(diff) sec ago"
        } else if hourAgo < self {
            let diff = Calendar.current.dateComponents([.minute], from: self, to: Date()).minute ?? 0
            return "\(diff) min ago"
        } else if dayAgo < self {
            let diff = Calendar.current.dateComponents([.hour], from: self, to: Date()).hour ?? 0
            return "\(diff) hrs ago"
        } else if weekAgo < self {
            let diff = Calendar.current.dateComponents([.day], from: self, to: Date()).day ?? 0
            return "\(diff) days ago"
        }
        let diff = Calendar.current.dateComponents([.weekOfYear], from: self, to: Date()).weekOfYear ?? 0
        return "\(diff) weeks ago"
    }
}

要使用它，这非常简单：

var now = Date()
now.timeAgoDisplay()

Answer 2

以字符串的形式传递时间，例如2019-02-25 10:20:21 在变量 dateFormat

中传递 dateformat

let dateFormat = "yyyy-MM-dd HH:mm:ss"

    func timeInterval(timeAgo:String) -> String
        {
            let df = DateFormatter()

            df.dateFormat = dateFormat
            let dateWithTime = df.date(from: timeAgo)

            let interval = Calendar.current.dateComponents([.year, .month, .day, .hour, .minute, .second], from: dateWithTime!, to: Date())

            if let year = interval.year, year > 0 {
                return year == 1 ? "\(year)" + " " + "year ago" : "\(year)" + " " + "years ago"
            } else if let month = interval.month, month > 0 {
                return month == 1 ? "\(month)" + " " + "month ago" : "\(month)" + " " + "months ago"
            } else if let day = interval.day, day > 0 {
                return day == 1 ? "\(day)" + " " + "day ago" : "\(day)" + " " + "days ago"
            }else if let hour = interval.hour, hour > 0 {
                return hour == 1 ? "\(hour)" + " " + "hour ago" : "\(hour)" + " " + "hours ago"
            }else if let minute = interval.minute, minute > 0 {
                return minute == 1 ? "\(minute)" + " " + "minute ago" : "\(minute)" + " " + "minutes ago"
            }else if let second = interval.second, second > 0 {
                return second == 1 ? "\(second)" + " " + "second ago" : "\(second)" + " " + "seconds ago"
            } else {
                return "a moment ago"

            }
        }

Answer 3

    let now = Date()
let pastDate = Date(timeIntervalSinceNow: -60 * 60 * 24)

enum DisplayTime {
    case short
    case long

    var seconds: String {
        switch self {
        case .short: return "s"
        case .long: return "seconds"
        }
    }

    var minutes: String {
        switch self {
        case .short: return "m"
        case .long: return "minutes"
        }
    }

    var hours: String {
        switch self {
        case .short: return "h"
        case .long: return "hours"
        }
    }

    var days: String {
        switch self {
        case .short: return "d"
        case .long: return "days"
        }
    }

    var weeks: String {
        switch self {
        case .short: return "w"
        case .long: return "weeks"
        }
    }
}

extension Date {

    func timeAgoDisplay(_ display: DisplayTime) -> String {

        let secondsAgo = Int(Date().timeIntervalSince(self))

        let minute = 60
        let hour = 60 * minute
        let day = 24 * hour
        let week = 7 * day

        switch secondsAgo {
        case let seconds where seconds < minute : return "\(secondsAgo) \(display.seconds) ago"
        case let seconds where seconds < hour: return "\(secondsAgo / minute) \(display.minutes) ago"
        case let seconds where seconds < day: return "\(secondsAgo / hour) \(display.hours) ago"
        case let seconds where seconds < week: return "\(secondsAgo / day) \(display.days) ago"
        default: "\(secondsAgo / week) \(display.weeks) ago"
        }
        return "\(secondsAgo / week) \(display.weeks) ago"
    }
}

pastDate.timeAgoDisplay(.short)

Answer 4

终于在swift4.2中找到了一个简单的解决方案

    let start = //Enter Start Date here....
    let end = Date()
    let formatter = DateComponentsFormatter()
    formatter.maximumUnitCount = 2
    formatter.unitsStyle = .full
    formatter.allowedUnits = [.year, .month, .day]
    let timeDifference = form.string(from: start, to: end)
    print(timeDifference)
    if timeDifference == "0 days"{
          print("Today")
    }
    else if  timeDifference == "1 days"{
           print("\(timeDifference!)day ago")
    }
    else{
           print("\(timeDifference!)days ago")
    }

Answer 5

Swift 5.1 (iOS 13)

从 iOS 13 开始，您可以使用 Apple 的 RelativeDateFormatter。优点是生成的字符串是本地化的。

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

let formatter = RelativeDateTimeFormatter()
formatter.unitsStyle = .full
let string = formatter.localizedString(for: date, relativeTo: Date())

print(string) // 4 hours ago

例如，参见此 blog post。

Answer 6

这是Swift 5 中的解决方案：

extension Date {

func timeAgo() -> String {

    let secondsAgo = Int(Date().timeIntervalSince(self))

    let minute = 60
    let hour = 60 * minute
    let day = 24 * hour
    let week = 7 * day
    let month = 4 * week

    let quotient: Int
    let unit: String
    if secondsAgo < minute {
        quotient = secondsAgo
        unit = "second"
    } else if secondsAgo < hour {
        quotient = secondsAgo / minute
        unit = "min"
    } else if secondsAgo < day {
        quotient = secondsAgo / hour
        unit = "hour"
    } else if secondsAgo < week {
        quotient = secondsAgo / day
        unit = "day"
    } else if secondsAgo < month {
        quotient = secondsAgo / week
        unit = "week"
    } else {
        quotient = secondsAgo / month
        unit = "month"
    }
    return "\(quotient) \(unit)\(quotient == 1 ? "" : "s") ago"
}
}

Answer 7

有点棘手)

基本上你需要

检查间隔
select 感兴趣的组件
检查是否需要商以及它是否适用于当前语言

iOS 提供了一些方法来做到这一点

DateComponentsFormatter

+: 无法处理本地化和其他 string-related 内容

-: 不太灵活

let formatter = DateComponentsFormatter()
formatter.allowedUnits = [.hour, .minute, .second]
formatter.unitsStyle = .brief
formatter.zeroFormattingBehavior = .dropAll

let result = formatter.string(from: Date().advanced(by: -300), to: Date())
result

结果：

"5min"

RelativeDateTimeFormatter

+: 无法处理本地化和其他 string-related 内容

-: iOS13+

let formatter = RelativeDateTimeFormatter()
formatter.unitsStyle = .full
return formatter.localizedString(for: self, relativeTo: Date())

自定义方式

+: 灵活

-: 编码一切

样本：

import Foundation

public extension Date {

  struct DetailedDateSuffix {

    let year: String
    let month: String
    let week: String
    let day: String
    let hour: String
    let min: String
    let second: String

    let quotient: String
    let suffix: String

    public init(year: String,
                week: String,
                month: String,
                day: String,
                hour: String,
                min: String,
                second: String,
                quotient: String,
                suffix: String = String.empty) {
      self.year = year
      self.month = month
      self.week = week
      self.day = day
      self.hour = hour
      self.min = min
      self.second = second
      self.quotient = quotient
      self.suffix = suffix
    }
  }

  func toDetailedReadableFormat(_ suffix: DetailedDateSuffix) -> String {

    if #available(iOS 13.0, *) {
      let formatter = RelativeDateTimeFormatter()
      formatter.unitsStyle = .full
      return formatter.localizedString(for: self, relativeTo: Date())
    } else {
      let calendar = Calendar.current
      let ageComponents = calendar.dateComponents(
        [
          .year,
          .month,
          .weekOfYear,
          .day,
          .hour,
          .minute,
          .second
        ],
        from: self,
        to: Date())

      var description: String = String.empty

      if let years = ageComponents.year,
        let months = ageComponents.month,
        let weeks = ageComponents.weekOfYear,
        let days = ageComponents.day,
        let hours = ageComponents.hour,
        let min = ageComponents.minute,
        let sec = ageComponents.second {

        var requireQuotient = false

        if years > 0 {
          description = "\(years)" + suffix.year
          requireQuotient = years == 1
        } else if months > 0 {
          description = "\(months)" + suffix.month
          requireQuotient = months == 1
        } else if weeks > 0 {
          description = "\(weeks)" + suffix.week
          requireQuotient = weeks == 1
        } else if days > 0 {
          description = "\(days)" + suffix.day
          requireQuotient = days == 1
        } else if hours > 0 {
          description = "\(hours)" + suffix.hour
          requireQuotient = hours == 1
        } else if min > 0 {
          description = "\(min)" + suffix.min
          requireQuotient = min == 1
        } else if sec > 0 {
          description = "\(sec)" + suffix.second
          requireQuotient = sec == 1
        }

        description = requireQuotient ? "\(description)\(suffix.quotient)" : description
        description = "\(description)\(suffix.suffix)"
      }

      return description
    }
  }
}

Answer 8

如果您只有 1970 年的时间戳。您可以使用此功能来 return 时间之前。

private func timestampToStringAgo(timestamp: Int64) -> String{
        let actualTime = Int64(Date().timeIntervalSince1970*1000)
        var lastSeenTime = actualTime - timestamp
        lastSeenTime /= 1000 //seconds
        var lastTimeString = ""
        if lastSeenTime < 60 {
            if lastSeenTime == 1 {
                lastTimeString = String(lastSeenTime) + " second ago"
            } else {
                lastTimeString = String(lastSeenTime) + " seconds ago"
            }
        } else {
            lastSeenTime /= 60
            if lastSeenTime < 60 {
                if lastSeenTime == 1 {
                    lastTimeString =  String(lastSeenTime) + " minute ago"
                } else {
                    lastTimeString =  String(lastSeenTime) + " minutes ago"
                }
                
            } else {
                lastSeenTime /= 60
                if lastSeenTime < 24 {
                    if lastSeenTime == 1 {
                        lastTimeString = String(lastSeenTime) + " hour ago"
                    } else {
                        lastTimeString = String(lastSeenTime) + " hours ago"
                    }
                } else {
                    lastSeenTime /= 24
                    if lastSeenTime == 1 {
                        lastTimeString = String(lastSeenTime) + " day ago"
                    } else {
                        lastTimeString = String(lastSeenTime) + " days ago"
                    }
                }
            }
        }
        return lastTimeString
    }

Swift 显示从 Date (NSDate) 开始的时间

Swift display time ago from Date (NSDate)

ios

swift

swift3

parse-server

因为 Swift 5.1

Swift 3 或 Swift 4

Swift 5.1 (iOS 13)