中文文档

By admin in 亚洲必赢官网app on 2019年2月21日

SwiftDate概况

从斯威夫特宣布起,大家就从未丢弃采用Swift。

理所当然,大家希望在类型可以轻松自如地管理日期和时区,所以创设SwiftDate以此类库。有了“她”在Swift里面优雅地拍卖时间。

在iOS、macOS、watchOS、tvOS上,以及Swift包容的平台上(Linux)都能完美运营!

除此以外,这些类库是免费的,开源的!

新颖公布版本

流行版本是4.0.3(斯威夫特3)
最新更新时间:二〇一四-10-03
更新日志:Read
CHANGELOG

赢得最新版本

老版本

设若你拔取的是swift2.2恐怕swift2.3,你可以到GitHub
page

器重特点

那某个情节是swiftdate里面根本特征的一大优点。

  • 日期进行简要数学运算。例如:
    aDate + 2.weeks + 1.hour or (1.year - 2.hours + 16.minutes).fromNow()
  • 时区,地区和日历的更换。使用类DateInRegion,通过组件和操作符进行转载。
  • 算术相比运算相比较时间。例如,aDate1 >= aDate2 或者
    aDate1.isIn(anotherDate, .day)
  • 行使时间组件。比如,用你欣赏的时区格式表述 aDateInRegion.day
    hour, minutes等等,
  • 最优雅的形式展开时间和字符串之间的转移。资助自定义(可读的)和固定格式(ISO8601,
    Alt中华VSS, 瑞鹰SS, Extended, .NET和部分依照unicode标准的常规字符串)。
  • 用其余时间单位描述3个岁月段。比如120.seconds.in(.minutes) // 2 minutes
  • 高速拿到时间和时间距离。(isYesterday,isTomorrow,isBefore()…)
  • …越来越多令人激动的政工!

环境必要

脚下官方的版本是v4,一些渴求:

  • Swift 3.0+
  • iOS 8 or later
  • macOS 10.10 or later
  • watchOS 2.0 or later
  • tvOS 9.0 or later
  • …任意设置斯维夫特3以及Swift的基本库的阳台

安装

斯维夫特Date辅助两种装置格局。

CocoaPods安装方式

CocoaPods是八个Objective-C和斯维夫特的爱惜管理器。

安装CocoaPods命令:

$ gem install cocoapods

SwiftDate 4.+的本子须要拔取CocoaPods 1.0.1+。

Podfile文件

在Xcode项目中引入斯维夫特Date,编辑Podfile新增:

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '8.0'

target 'TargetName' do
pod 'SwiftDate', '~> 4.0'
end

Carthage安装格局

Carthage是一种非集成的依赖管理器,打造看重,并提供二元框架。

homebrew安装Carthage

$ brew update
$ brew install carthage

在Xcode项目中采取Carthage引入斯维夫特Date,只必要在Cartfile中新增:

github "malcommac/SwiftDate" ~> 4.0

Swift Package Manager安装

脚下还不援救!

Fork us on GitHub

SwiftDate是开源的类库,源码托管在GitHub上。

上边的姿势可以为斯威夫特Date作进献:

  • 抓到八个bug,提供详实步骤复现bug,open1个issue。
  • 指出多个功效性的请求,open贰个issue。
  • 贡献代码,提交pr。

Authors & License

SwiftDate是由Daniele
Margutti
创办并保险,其中项目的2个最首要进献者是Jeroen
Houtzager

欢迎为开源项目作出进献!

此库的源代码遵从MIT
License
,
你可以没有其它限制地在商贸类型中使用!

唯一的渴求就是增添一行表达:

Date and Time Management is provided by SwiftDate - http://www.swift-date.com
Created by Daniele Margutti and licensed under MIT License.

Your App & SwiftDate

若果您有趣味,能够整理出利用SwiftDate那一个类库的类型。可以在GitHub上开二个issue,提供您的门类名字和链接,大家将会添加到本网站上!


重大约念

Date 和 Absolute Time

Date是日期和时间拍卖的基础类。在iOS内部,时间以从 贰零零肆年六月15日00:00
UTC 的秒数,作为相对值存储,Date对此开展打包,并提供相关措施。

世界各省的在同二个时刻,你可以认为是同一个实体(除非出现了2个新的星星时间种类)。但是附加上内地不同的发挥和统计方法,时间就变得略微复杂。

相对时间一种通俗的定义:在美利哥的 A 正在跟在东京的 B
举办通话,那一个时刻就能够叫做相对时间;在同等时刻都会有这么的打电话,可是出于时区、不用的日历以及差别的字母或标志方法,区域时间就可能差别等。

基础库还支持处理不同的日历连串的 Calendar 日历实例;

在拍卖跨时区、日历项目和区域的岁月转移的时候,都会赶上有个别高难的题材。斯威夫特Date可以帮您更高速的化解这几个标题。

DateInRegion 和 Region

SwiftDate
为了提供整机的光阴和日期管理的法力,引入了三个相当紧要的新东西以及数个增添。

第2个是多少个结构体(struct),称为Region:region,正如其名称,它是对贰个地理地点在岁月系列中的描述,其中蕴藏多少个不等的特点:

那可能是不太重大的标注表达:

GMT(Greenwich Mean Time):指格林威治标准时间;

PST(Pacific Standard Time):指印度洋正式时间;

  • TimeZone:
    用来定义时区。时区在必然水平上代表了不一样地段,因而,地区的名字的可看作时区的名号,例如苏梅岛时区,巴黎时间。类似的,格林尼治时间(GMT)或美国南边时间(PST)的偏移量,
    也足以用来代表时区,例如东八区(GMT +8)

  • Calendar:
    用来代表日历体系,日历种类定义了年与月的长度与分割。斯维夫特Date
    提供了差异日历的消息,还援救不一致日历下时间的揣摸,例如给出相对时间值,SwiftDate
    能够规定她在内定日历系统下的日子。

  • local:
    用来表示当地的年月公布格局。由于内地的学识、语言、规范的差距,时间在大街小巷用差距的相间符或语法来表示。比如
    中国地区相似拔取 年-月-日 时:分:表,而United States地域多采纳 月-日-年
    时:分:秒

另三个是DateInRegion,是在一定的国家地方 Region
下,描述1个本身与具体时区和日历毫无干系的时间Date。那是由于特定的国度地区一般采纳固定的时区、日历系统与表明规范,只要评释了江山地点,就富含了以上三个因素。实际接纳中,使用DateInRegion可以方便的操作上下文中的日期。

斯维夫特Date
为您提供平等的函数和属性,以管理带有地区属性的DateInRegion时刻实例 和
单纯Date日子实例。

默认Region

当你利用普通的Date对象,你能够在Date.defaultRegion中定义的DateInRegion,这些地点蕴藏了:

  • .timeZone 以 GMT (格林wich Mean Time)格式表述的时区
  • .local 以设施的所在地设置日期表述格局
  • .Calendar 设置为设备暗中认可的日历

您可以调用 Date.setDefaultRegion(:) 以变更时间的暗许地区
Date.defaultRegion

以此可能不太重大但要么要牢记:时间的这个需求在运用运行时设置好(例如,在UIApplication的delegate中函数applicationDidFinishLaunching()中安装就行了)。


岁月的零件

概况

接纳斯维夫特Date,您能够充足方便的操控时间的机件。无论是还是不是设置地区属性,DateInRegionDate都完成了相同套属性和办法来进展时间日期的管理。

请留意:使用简易时间
Date实例时,实际上是依据了设施暗中同意的地点来初阶化了
.defaultRegionRegion.GMT()是由装备暗许的localeCalendar和目前设施所在地的时区所决定,.defaultRegion
的先河值就是Region.GMT()

万一想要修改的暗中同意的区域,调用Date的静态方法 .setDefaultRegion()
即可!

补给表明:

日子的这一个属性值需考虑上下文的地点与日历系统;若是调用者是DateInRegion,斯威夫特Date
将会采纳已经内定的.region来测算具体属性值,如果调用者是平日Date,SwiftDate
将会基于暗中同意的Date.defaultRegion来计量属性值。以下有所属性与组件都遵从此原则。

era

回到公元状态,大家平日生活中的 二〇一六 年都以公元年为源点,这么些时间的 era
都为 1 , 而公元前的年度如 -2000 年,那个时间的 era 都是
0。所以在操作近代时间时,无需考虑此属性。
声明:

public var era: Int

year

回到年份的数值
声明:

public var year: Int

month

归来月份的数值,如 5
声明:

public var month: Int

day

回来年月日中 的数值,如 30
声明:

public var day: Int

hour

回到时分秒中 的数值
声明:

public var hour: Int

nearestHour

据悉四舍五入的章程取出时间的近年时辰。不难举例:比如 8:15 会再次来到 8 ,而
8:50 会回去 9
声明:

public var nearestHour: Int

minute

回来时分秒中 的数值
声明:

public var minute: Int

second

回去时分秒中 的数值
声明:

public var second: Int

nanosecond

回到时间的 毫秒的数值
声明:

public var nanosecond: Int

注意
农历日历定义一个星期有7天,一年有356天,或闰年366天。
不过,356或366都不平均地分成7天的周,因此普通状态下,一年的最后七日在下一年的一天截至,一年的第三周从明年先河。
为了协调那点,ISO
8601概念了2个周编号年份,包涵52或53整周(364或371天),以便一年的首先周被钦定为带有一年中率先个周五的星期。

您可以将yearForWeekOfYear属性与weekOfYear和weekday属性协作使用,以取得与一年中给定星期的一定工作日对应的日子。
例如,二零零五年第⑤3周(ISO
二零零七-W53-6)的第肆天对应于公历日历上2006年八月七日周三。比如布拉格小运二〇一六-12-31 15:10:12 他的 yearForWeekOfYear2016weekOfYear
1weekday3

yearForWeekOfYear

ISO8601
的周数总括规则下,日期所属的年份。只怕是眼前日子的今年,大概下一年,大概当年。
声明:

public var yearForWeekOfYear: Int

weekOfYear

在 ISO 8601 的周数统计规则下,日期所属的周数。如奥Crane时间 2016-11-31 是第⑤9 周,贰零壹肆-12-31 是首先周。
声明:

public var weekOfYear: Int

weekday

在 ISO 8601 的周数总括规则下,在时光所属的周中, 是星期几,且规定了
1是星期三,约等于每一周的源点是周末。如布拉格时刻 二〇一四-11-31 是周四 ,其
weekday5

声明:

public var weekday: Int

weekdayOrdinal

以各种月的第壹天为当月率先周的源点,无视全年的星期统计规则,比如每一个月第陆 天就是第叁周,第 8 天就是第三周。

声明:

public var weekdayOrdinal: Int

weekdayName

某些日期的星期名称,假诺您设定是中国地区,那星期三为“周二”,日本地区就是
“火曜日” ,美利坚同盟国地域就是 “Tuesday”,注意此值取决于地区属性。

声明:

public var weekdayName: String

monthDays

岁月所在月份,该月份的小运,比如阴历中, 四月 大概有 29 天或 28 天,3月有 31天。
声明:

public var monthDays: Int

quarter

归来季度单位的数值。小心在常识中,一年分为春夏秋冬四季,但在不相同地域季度的苗头时间不一,因此此属性在并未赋值的情事下均为
0 ,当你要求利用前,请赋值。

声明:

public var quarter: Int

weekOfMonth

再次回到月份所蕴藏的周数,此处根据 IOS 8601 的专业,每一个月横跨的周数,比如
2016年八月 的 weekOfMonth 是 4 ,而 2016 年 2 月的 weekOfMonth 是 5

声明:

public var weekOfMonth: Int

shortMonthName

该时间所在月份的简称,比如U.S.地区 七月万事俱备是 February ,简称是 Feb 即
二零一五-02-01 改时间的 shortMonthName 就是 Feb
声明:

public var monthName: Int

leapMonth

重临2个布尔值,表达有些月份是或不是是闰月。
true,表示该时间所在月份是闰月,否则不是闰月。
声明:

public var leapMonth: Bool

leapYear

归来多个布尔值,表达有个别年份是还是不是是闰年。
true,表示该时间内地的年份是闰年,否则不是闰年。
声明:

public var leapYear: Bool

补充表明:
本条值将会在其应用的日历和时区的环境中表达;如果调用者是DateInRegion,系统环境将会采纳相关的.region来定义,若是调用者是经常Date,系统环境将会采取暗中认同值Date.defaultRegion来定义。

julianDay

儒略日 (Julian Day)
是天翻译家使用从Julian时期以来连年的命局。详情请见维基百科词条
儒略日
声明:

public var julianDay: Double

modifiedJulianDay

儒略日 (Julian Day)
有一对列的乘除办法,由于用途是天文领域,且与公历换算复杂,此处不开展叙述,详情请见维基百科词条
Julian
Day

声明:

public var modifiedJulianDay: Double

previousWeekend

重返该时间所在周的上个周末,这些周末以元组表示,第2个要素是下周末开首的时日,第三个是下周末的完工时间。且那多个时间都以
DateInRegion 实例。
只顾:是上个周的星期天,不是时刻自然所在周的周末

声明:

public var previousWeekend: (startDate: DateInRegion, endDate: DateInRegion)?

thisWeekend

回去该时间所在周的星期一,这几个周末以元组表示,第二个要素是本周末始于的光阴,第二个是本周末的利落时间。且那七个时刻都以
DateInRegion 实例。

声明:

public var thisWeekend: (startDate: DateInRegion, endDate: DateInRegion)?

nextWeekend

回来该时间所在周的下个星期六,那么些周末以元组表示,第四个成分是下一周末上马的时日,第二个是下一周末的扫尾时间。且那八个日子都以
DateInRegion 实例。
专注:是下个周的周末,不是岁月自然所在周的星期二
声明:

public var nextWeekend: (startDate: DateInRegion, endDate: DateInRegion)?

isToday

再次来到布尔值,重临调用此属性的时日实例是还是不是在明日。
声明:

public var isToday: Bool

isYesterday

回去布尔值,再次来到调用此属性的年华实例是还是不是在昨日。
声明:

public var isYesterday: Bool

isTomorrow

回来布尔值,再次来到调用此属性的小时实例是还是不是在前几日。
声明:

public var isTomorrow: Bool

isInWeekend

归来布尔值,重返调用此属性的日子实例是或不是在其所在周的周末日子段内。
声明:

public var isInWeekend: Bool

isInPast

正如该时间实例与近期时间,换算成时间相对值来,相比大小,尽管比目明天子小,即为过去光阴,重回
true;反之,返回 false。简言之:早于以后每一天的光阴 重回 true
声明:

public var isInPast: Bool

isInFuture

相比较该时间实例与当下岁月,换算成时间相对值来,相比大小,倘若比近年来时刻大,即为以后时刻,重返
true;反之,返回 false。简言之:晚于今后时时的日子 再次回到 true

声明:

public var isInFuture: Bool

isInSameDayOf()

比较时间实例与给定的命宫是不是为在同一天。比较时选取调用者的时区和日历设置。
声明:

public func isInSameDayOf(date: DateInRegion) -> Bool
public func isInSameDayOf(date: Date) -> Bool

startOfDay

归来当前时刻所在 的序幕时刻,比如 二零一五-11-11 23:10:00 的
startOfDay 是 二〇一六-11-11 00:00:00 。注意会结合时区和日历。
声明:

public var startOfDay: DateInRegion
public var startOfDay: Date

endOfDay

回来当前时间所在 的截止时刻,比如 2014-11-11 23:10:00 的
startOfDay 是 二零一五-11-11 23:59:59 。注意会构成时区和日历。
声明:

public var endOfDay: DateInRegion
public var endOfDay: Date

nextMonth

岁月所在月份的下八个月的当天的开头时间,比如 二〇一四-03-31 13:30:00 的
nextMonth 是 二零一五-04-30 00:00:00,注意 斯威夫特Date
会自动换算不一致月份天数区其余题材。
声明:

public var nextMonth: DateInRegion
public var nextMonth: Date

prevMonth

时光所在月份的上半年的当天的前奏时间,比如 二零一四-03-31 13:30:00 的
nextMonth 是 二零一五-02-29 00:00:00,注意 斯维夫特Date
会自动换算不一致月份天数差别的题材。
声明:

public var prevMonth: DateInRegion 
public var prevMonth: Date

startOf()

给定三个单位,重返时间在此单位的开首值,比如给定以年为单位, 2015-11-11
11:11:11 的 startOf() 是 2016-01-01 00:00:00 ;给定 时 为单位,会反回
2016-11-11 11:00:00
声明:

public func startOf(component: Calendar.Component) -> DateInRegion
public func startOf(component: Calendar.Component) -> Date

浅析与成立时间

概览


多个涉及到实际地点的岁月可以由多样办法创立;那种时刻可以由一对 Date
Region 组成,大概从自定义时间格式的字符串解析(斯维夫特Date
帮衬自定义的时光格式,诸如 ISO8601
标准格式
RSS
或AltRSS

.NET
时间
),再恐怕可以透过解析
Calendar.Component对象的聚合来创设。
理所当然你也可以通过数学运算从另五个时刻来新建时间。
本章节罗列了全体关于创立时间的格局,无论是或不是包括地域消息,DateInRegion
Date 都适用于那个方法。

基于字符串解析时间


明明,解析字时间符串并转换来时间实例很麻烦。SwiftDate
资助广大日子格式,以帮您升高效用,减弱支出。
format 参数赋值,以宣称你采用的日子格式:可以是自定义时间格式或
ISO8601 datetime、.NET datetime 等标准时间格式。

声明
func init(string: String, format: DateFormat, fromRegion region: Region? = nil) throws

参数

  • string : this is the string you want to parse
  • format : this is the format in which you expect the string is
    formatted. DateFormat is an enum: .custom (for custom format),
    .iso8601 to parse all available specs for ISO8601 DateTime Format,
    .extended to parse Extended DateTime format, .rss to parse both
    RSS and AltRSS datetime formats and .dotNET to parse .NET datetime
    strings.
  • region : is the region in which you want to express specified
    date. If nil or not specified Region.Local(( is used instead.

回去结果
重返结果是 包蕴地区音信的 DateInRegion 时间实例。
例子

let rome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italian)

// 基于自定义时间格式解析时间字符串
let date1 = try! DateInRegion(string: "1999-12-31 23:30:00", format: .custom("yyyy-MM-dd HH:mm:ss"), fromRegion: regionRome)

// 基于 AltRss 标准来解析时间字符串
let date2 = try! "3 feb 2001 15:30:00 +0100".date(format: .rss(alt: true), fromRegion: regionRome)
// 同上
let date3 = try! DateInRegion(string: "3 feb 2001 15:30:00 +0100", format: .ss(alt: true)), fromRegion: regionRome)

//  解析 ISO8601 标准互联网时间字符串
let date4 = DateInRegion(string: "2001-02-03T15:30:00+01:00", format: .iso8601(options: .withInternetDateTime), fromRegion: regionRome)

// 解析自定义时间格式字符串
let date5 = try! DateInRegion(string: "sab 3 feb 2001, 30 minutes after 15 (timezone is +0100)", format: .custom("eee d MMM YYYY, m 'minutes after' HH '(timezone is' Z')'"), fromRegion: regionRome)

得到当前无时无刻的光阴实例


行使私自认同的 init() 方法可神速的成立基于设备当前地方和每一日的
DateInRegion 时间实例。

声明
func init()

回去结果
返回的 DateInRegion
对象定义了如今每天(Date())和配备当前的街头巷尾地点,此地区属性(Region.Local())包涵了时区
.timeZone、区域时间格式 .locale、当地日历体系 .calendar
(全体相关安装都会自动更新)

补偿表达:地区 包涵了三个属性:时区(如 GMT +8)、当地时间格式(如中国以
年-月-日,U.S.以 月-日-年)、日历项目(如农历、东瀛日历、东正教日历)

例子

// Create a new DateInRegion which represent the current moment (Date()) in current device's local settings
let now = DateInRegion()

依照给定的每1十四日和所在来创设时间实例


加以时间和其所在地方,你可以创制对应的 DateInRegion 对象。创建后,使用
DateInRegion
对象开展的保有操作,都将利用对应地区的须要;DateInRegion相应的性质和方法会自动套用区域的安装;
声明
func init(absoluteDate date: Date, in region: Region)
参数

  • date: define the absolute Date you want to use to create the new
    DateInRegion. Passed date is indipendent from any geographic
    timezone/calendar or locale because it’s expressed in absolute time.
  • region: define the destination Region in which you want to
    express passed date

回来结果
回到对象是二个剖析自给定地区的 DateInRegion 时间实例。

例子

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
// Resulting object is DateInRegion which express the current moment in Rome
let dateInRome = DateInRegion(absoluteDate: Date(), in: regionRome)

依照日期要素创建时间


将日历的要素集合以 DateComponents 对象封装后成立 DateInRegion
时间是另一种好点子。DateComponents 实例化对象的TimeZone Locale
Calendar
属性都不大概不注解以保证收获的光阴有效;要是缺失任何一个,将会抛出
.MissingCalTzOrLoc 异常。

声明
func init(components: DateComponents)

参数

  • components: components used to generate the new date

回到结果
归来3个 DateInRegion 时间实例,其日期由传入的 DateComponets
来决定;

例子

var cmp = DateComponents()
cmp.timeZone = TimeZoneName.europeOslo.timeZone
cmp.calendar = CalendarName.gregorian.calendar
cmp.calendar?.locale = LocaleName.englishNorway.locale
cmp.year = 2005
cmp.month = 4
cmp.day = 15
cmp.hour = 20
cmp.minute = 30

// create a new DateInRegion on 15 Apr 2005, 20:30:00 GMT+2
let date = try! DateInRegion(components: cmp)

依据时间组件创立时间


盛传一组 Calendar.Component
与对应值组成的数组(由[Calendar.Component:Int]
样式的字典和实际的所在所定义)来创建一个新的 DateInRegion 时间实例
声明
func init(components: [Calendar.Component:Int], in region: Region)

参数

  • components: components used to generate the new date. It’s a
    dictionary where keys are Calendar.Component and values are Int
    with relative value. Supported components are:
    .day,.era,.hour,.minute,.month,.nanosecond,.quarter,.second,.weekOfMonth,.weekOfYear,.weekday,.weekdayOrdinal,.year,
    .yearForWeekOfYear
  • region: is the region in which you want to express specified date.
    If nil or not specified Region.Local(( is used instead.

回去结果
回到2个 DateInRegion 时间实例,其组件由传入的 DateComponets
来决定;

例子

let c: [Calendar.Component : Int] = [.year: 2002, .month: 3, .hour: 5, .day: 4, .minute: 6, .second: 7, .nanosecond: 87654321]
// create a new DateInRegion on 2002-03-04 at 05:06:07.87654321 (+/-10) in Region.Local()
let date = try! DateInRegion(components: c, fromRegion: nil)

修改时间

SwiftDare 普通话版表达文档 – 修改时间 – 5

@(宫丁园学习笔记)[swift, 翻译]

概览


动用 SwiftDate
来对时间开展有关修改操作十三分便捷;修改时间组件,相比多个时刻(时间的差距以他们中间的两样组件来代表)。无论是带有地区属性的
DateInRegion 时间实例依旧单一结构的 Date
时间实例,都可以拓展这个操作。

数学运算


为时间累加组件
您可以应用 Swift 中常用数学运算符,来增减时间成分的值。如+-

基于你所发表的上下文,SwiftDate 会自动判断并转移带有地区属性的
DateInRegion 时间实例或纯粹结构的 Date 时间实例。
可用的时刻组件有:
nanoseconds,seconds,minutes,hours,days,weeks,years
上边是有些数学运算的例证:

// 创建一个罗马时间 2015-01-03 @ 15:10:00
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
var date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

// 让我试试数学运算符修改时间元素值
date = date + 3.seconds + 15.minutes // -> 03 gen 2015, 15:25:03 CET
date = date - 120.seconds // minus 2 minutes -> 03 gen 2015, 15:23:03 CET
date = date + 3.weeks // 24 gen 2015, 15:23:03 CET
// 你也可以直接增加绝对秒数,SwiftDate 会自动帮你换算
date.add(interval: 10) // 24 gen 2015, 15:23:03 CET

相比较时间


概述
在 斯维夫特3 的 Foundation 库中,已经支撑相比 Date 时间实例。
斯维夫特Date 为含有地区属性的 DateInRegion
补充了一般的比较艺术,并通过丰硕新章程扩大了现有 Foundation
库对分歧粒度下的年月相比较。

相比较简单时间
您可以采用 >,>=,<,=< 运算符来比较时间,例如:

// 03 gen 2015, 15:10:00 CET
let date1 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
let date2 = try! DateInRegion(components: [.year: 2015, .month: 2, .day: 5, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

if date2 > date1 { // DateInRegion supports Equatable protocol you can use >=, <=, < or >
    print("'\(date2)' date is later than '\(date1)'")
}

if date2 == date1 {
  // simple equality
}

时刻所对应的单位先河值


概述
利用 .startOf()
方法,传入统计单位后,你可以拿到改时间于今的差值。补充表明:时间是3个点值,而时间的单位都是一段时间的差值,那里的先导值指的就是岁月点值在岁月单位的区间中的右边界值;比如,2014-11-11
20:39:50 ,以月为单位,起首值是 二〇一五-11-01 00:00:00;以时辰为单位
,伊始值是 二〇一五-11-11 20:00:00。
声明
startOf(component: Calendar.Component) -> DateInRegion
startOf(component: Calendar.Component) -> Date

参数

  • component: component to alter

返回值
回去给定时间单位距离的先河值所对应的 DateInRegion/Date 时间实例。

例子

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)

// 03 gen 2015, 15:10:00 CET
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

let startOfHour = date.startOf(component: .hour) // 03 gen 2015, 15:00:00 CET
let startOfMonth = date.startOf(component: .month) // 01 gen 2015, 00:00:00 CET
let startOfWeek = date.startOf(component: .weekOfMonth) // 28 dic 2014, 00:00:00 CET

时光所对应的单位停止值

概述
利用 .startOf() 方法,传入单位后,你可以博得现有时间对应的截至址。

声明
endOf(component: Calendar.Component) -> DateInRegion
endOf(component: Calendar.Component) -> Date

参数

  • component: component to alter

归来结果
回到给定时间单位距离的扫尾址所对应的 DateInRegion/Date 时间实例。

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)

// 03 gen 2015, 15:10:00 CET
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

let startOfHour = date.endOf(component: .hour) // 03 gen 2015, 15:59:59 CET
let startOfMonth = date.endOf(component: .month) // 31 gen 2015, 23:59:59 CET
let startOfWeek = date.endOf(component: .weekOfMonth) // 03 gen 2015, 23:59:59 CET

对时间的天天举行改动

概述
针对现有的时间实例, .atTime(hour:minute:second)
方法可以修改时刻,提供
的值,得到二个新的时日,新的实例中国和东瀛期与日期不变。
异常
比方原时间不可以生成新时间,会抛出 .FailedToCalculate 异常。

声明
func atTime(hour: Int, minute: Int, second: Int) throws -> DateInRegion
func atTime(hour: Int, minute: Int, second: Int) throws -> Date

参数

  • hour: hour(s) to set
  • minute: minute(s) to set
  • second: second(s) to set

归来结果
在原时间基础上,依据你提供的变化三个新时间实例,地区设置保险不变。别的,其他的日子组件在要求时
斯维夫特Date 会加以修改,以维持合理。

例子

// 生成一个新的罗马时间,日历格式选择公历,时间表述格式以意大利为准。
// 03 gen 2015, 15:10:00 CET
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

// 应用 `.atTime()` 方法
let newDateAtGivenTime = try! date.atTime(hour: 09, minute: 10, second: 22) // 03 gen 2015, 09:10:22 CET

对时间的钦赐组件举行改动

概述
对点名的时光组件的值举行改动,在担保其他零件值合理的意况下,重临八个新的岁月实例。

声明
func at(unit: Calendar.Component, value: Int) throws -> DateInRegion
func at(unit: Calendar.Component, value: Int) throws -> Date

参数

  • unit: calendar component unit to alter

异常
若果给定的零件赋值不成功,不恐怕生成新时间实例时,会抛出
.FailedToCalculate 异常。

回到结果
在原时间基础上,修改给定组件的值,然后生成新的时刻实例并回到。SwiftDate
在成立的前提下不会改变与给定组件相比较单位更大组件的值。补充表达:假诺改动了光阴中
的值,这拥有的等更小的组件的值都会被赋最小值 ,而

等更大单位的零部件的值会保持原样,那样做是为着保持合理,03-31,假若对月改成
2 ,这2-31 很显明不客观。比如 二〇一四-11-11 11:11:11 修改了 12
那,重临的新的小时是 二〇一六-12-01 00:00:00

例子

// 生成一个新的罗马时间,日历格式选择公历,时间表述格式以意大利为准。
// 03 gen 2015, 15:10:00 CET
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

let atGivenYear = try! date.at(unit: .year, value: 2020) // 01 gen 2020, 00:00:00 CET. day is altered

批量改动时间组件的值


概述
给定三个 [时间组件 : 值] 的字典,斯威夫特Date
会依据时间组件的单位伸张排序,并修改对应组件的值。
在 SwiftDate 中,规定时间组件的增添排序为:
.nanosecond,.second,.minute,.hour,.day,.month,.year,.yearForWeekOfYear,.weekOfYear,.weekday,.quarter,.weekdayOrdinal,.weekOfMonth.

声明
func at(unitsWithValues dict: [Calendar.Component : Int]) throws -> DateInRegion
func at(unitsWithValues dict: [Calendar.Component : Int]) throws -> Date

参数

  • unitsWithValues: calendar component units to alter

异常
对少数时刻组件赋值暴发错误时,会抛出 .FailedToCalculate 异常。

再次来到结果
对点名组件赋值后,生成二个新的年月实例,比给定时间组件更大的零部件将不会被涂改,更小的如若没有赋值将全体赋最小值;那有的的法则,在上3个艺术中有补充表明。

例子

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
// 03 gen 2015, 15:10:00 CET
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)

let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
let time = try! date.at(unitsWithValues: [.year: 2016, .month: 7]) // 01 gen 2016, 00:00:00 CET

得到多少个日子中的最靠前(时间线上最靠右的)的年华

概述
在给定的三个时辰实例集合中,重临其中最新的时间实例。相比根据相对时间值,时间实例的地域,时区,表述格式等零件不会对相比较结实爆发震慑。

声明
(DateInRegion) static func latestDate(_ list: [DateInRegion]) -> DateInRegion
(Date) static func latestDate(_ list: [DateInRegion]) -> Date

例子

// date1 = 2015-01-03 15:10:00
let date1 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
// date2 = 2014-12-30 20:10:00
let date2 = try! DateInRegion(components: [.year: 2014, .month: 12, .day: 30, .hour: 20, .minute: 10, .second: 0], fromRegion: regionRome)
// date3 = 2015-01-03 15:20:00
let date3 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 20, .second: 0], fromRegion: regionRome)

// get the latest date in a set
let latestDate = DateInRegion.latestDate([date1,date2,date3]) // is date1 (2015-01-03 14:20:00 +0000)
// or directly via Array extension
let latestDate = [date1,date2,date3].latestDate

拿到五个日子中最遥远(时间线上最靠左的)的小运

概述
在给定的多个小时实例集合中,重临其中最悠久的时刻。比较依照相对时间值,时间实例的地点,时区,表述格式等零件不会相比较较结实暴发震慑。

声明
(DateInRegion) static func earliestDate(_ list: [DateInRegion]) -> DateInRegion
(Date) static func earliestDate(_ list: [DateInRegion]) -> Date

例子

// date1 = 2015-01-03 15:10:00
let date1 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
// date2 = 2014-12-30 20:10:00
let date2 = try! DateInRegion(components: [.year: 2014, .month: 12, .day: 30, .hour: 20, .minute: 10, .second: 0], fromRegion: regionRome)
// date3 = 2015-01-03 15:20:00
let date3 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 20, .second: 0], fromRegion: regionRome)

// get the latest date in a set
let earliestDate = DateInRegion.earliestDate([date1,date2,date3]) // is date2 30 dic 2014, 20:10:00 CET
// or directly via Array extension
let earliestDate = [date1,date2,date3].earliestDate

加以单位,比较两小时实例

概述
在加以单位的前提下,比较现有时间是还是不是晚于提供的时间。

声明
func compare(to date: DateInRegion, granularity: Calendar.Component) -> ComparisonResult
func compare(to date: Date, granularity: Calendar.Component) -> ComparisonResult

参数

  • date: date to compare
  • granularity:
    你所梦想的可比粒度至少要比两岁月里面的最大差异组件之间要小,否则相比结实会突显相等。
    补给表明
    在同贰个月的七个不等时间时间,以
    为单位相比时,是出色的,比如(伪代码)
    date1 = 2016-11-11 11:11:11
    date2 = 2016-11-12 11:11:11
    抑或更小的的单位比较,重返结果就是date2 更大

是还是不是早于某时间(给定单位)

概述
在给定单位前提下,相比现有时间是否早于给定时间。

声明
func isBefore(date: DateInRegion, orEqual: Bool = false, granularity: Calendar.Component) -> Bool
func isBefore(date: Date, orEqual: Bool = false, granularity: Calendar.Component) -> Bool

参数

  • date: date to compare
  • orEqual: true to also check for equality
  • granularity: The smallest unit that must, along with all larger
    units, be less for the given dates.

是还是不是晚于某时间(给定单位)

概述
在加以单位粒度前提下,相比现有时间是或不是晚于给定时间。

声明
func isAfter(date: DateInRegion, orEqual: Bool = false, granularity: Calendar.Component) -> Bool
func compare(to date: Date, granularity: Calendar.Component) -> ComparisonResult
func isAfter(date: Date, orEqual: Bool = false, granularity: Calendar.Component) -> Bool

参数

  • date: date to compare
  • orEqual: true to also check for equality
  • granularity: The smallest unit that must, along with all larger
    units, be less for the given dates.

是或不是等于某时间

概述
正如现有时间实例是不是完全等于给定时间。

声明
func isEqual(to compareDate: DateInRegion) -> Bool

参数

  • compareDate: a date to compare against

修改时间

SwiftDare 粤语版表达文档 – 修改时间 – 5

@(宫丁园学习笔记)[swift, 翻译]

概览


接纳 SwiftDate
来对时间进行相关修改操作特别方便;修改时间组件,相比较四个日子(时间的例外以她们之间的不一致组件来代表)。无论是带有地区属性的
DateInRegion 时间实例依然单一结构的 Date
时间实例,都可以开展那个操作。

数学运算


为时间拉长组件
你可以拔取 斯威夫特 中常用数学运算符,来增减时间成分的值。如+-

基于你所发挥的上下文,SwiftDate 会自动判断并生成带有地区属性的
DateInRegion 时间实例或纯粹结构的 Date 时间实例。
可用的时日组件有:
nanoseconds,seconds,minutes,hours,days,weeks,years
上边是一对数学运算的例证:

// 创建一个罗马时间 2015-01-03 @ 15:10:00
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
var date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

// 让我试试数学运算符修改时间元素值
date = date + 3.seconds + 15.minutes // -> 03 gen 2015, 15:25:03 CET
date = date - 120.seconds // minus 2 minutes -> 03 gen 2015, 15:23:03 CET
date = date + 3.weeks // 24 gen 2015, 15:23:03 CET
// 你也可以直接增加绝对秒数,SwiftDate 会自动帮你换算
date.add(interval: 10) // 24 gen 2015, 15:23:03 CET

比较时间


概述
在 斯威夫特3 的 Foundation 库中,已经支撑相比较 Date 时间实例。
斯威夫特Date 为带有地区属性的 DateInRegion
补充了相似的可比艺术,并通过抬高新章程扩展了现有 Foundation
库对两样粒度下的年华相比。

比较简单时间
您能够行使 >,>=,<,=< 运算符来相比时间,例如:

// 03 gen 2015, 15:10:00 CET
let date1 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
let date2 = try! DateInRegion(components: [.year: 2015, .month: 2, .day: 5, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

if date2 > date1 { // DateInRegion supports Equatable protocol you can use >=, <=, < or >
    print("'\(date2)' date is later than '\(date1)'")
}

if date2 == date1 {
  // simple equality
}

时刻所对应的单位起先值


概述
利用 .startOf()
方法,传入计算单位后,你可以拿走改时间到明天的差值。补充表达:时间是三个点值,而时间的单位都是一段时间的差值,那里的起头值指的就是岁月点值在岁月单位的区间中的左侧界值;比如,二零一五-11-11
20:39:50 ,以月为单位,初阶值是 二零一六-11-01 00:00:00;以时辰为单位
,先河值是 二零一五-11-11 20:00:00。
声明
startOf(component: Calendar.Component) -> DateInRegion
startOf(component: Calendar.Component) -> Date

参数

  • component: component to alter

返回值
归来给定时间单位距离的开首值所对应的 DateInRegion/Date 时间实例。

例子

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)

// 03 gen 2015, 15:10:00 CET
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

let startOfHour = date.startOf(component: .hour) // 03 gen 2015, 15:00:00 CET
let startOfMonth = date.startOf(component: .month) // 01 gen 2015, 00:00:00 CET
let startOfWeek = date.startOf(component: .weekOfMonth) // 28 dic 2014, 00:00:00 CET

时刻所对应的单位为止值

概述
利用 .startOf() 方法,传入单位后,你可以获取现有时间对应的停止址。

声明
endOf(component: Calendar.Component) -> DateInRegion
endOf(component: Calendar.Component) -> Date

参数

  • component: component to alter

归来结果
回去给定时间单位距离的收尾址所对应的 DateInRegion/Date 时间实例。

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)

// 03 gen 2015, 15:10:00 CET
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

let startOfHour = date.endOf(component: .hour) // 03 gen 2015, 15:59:59 CET
let startOfMonth = date.endOf(component: .month) // 31 gen 2015, 23:59:59 CET
let startOfWeek = date.endOf(component: .weekOfMonth) // 03 gen 2015, 23:59:59 CET

对时间的随时进行改动

概述
本着现有的时日实例, .atTime(hour:minute:second)
方法可以修改时刻,提供
的值,拿到2个新的时间,新的实例中国和日本期与日期不变。
异常
比方原时间不能生成新时间,会抛出 .FailedToCalculate 异常。

声明
func atTime(hour: Int, minute: Int, second: Int) throws -> DateInRegion
func atTime(hour: Int, minute: Int, second: Int) throws -> Date

参数

  • hour: hour(s) to set
  • minute: minute(s) to set
  • second: second(s) to set

回去结果
在原时间基础上,依照你提供的转移一个新时间实例,地区设置保险不变。其它,其余的时辰组件在要求时
斯威夫特Date 会加以修改,以保持合理。

例子

// 生成一个新的罗马时间,日历格式选择公历,时间表述格式以意大利为准。
// 03 gen 2015, 15:10:00 CET
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

// 应用 `.atTime()` 方法
let newDateAtGivenTime = try! date.atTime(hour: 09, minute: 10, second: 22) // 03 gen 2015, 09:10:22 CET

对时间的钦命组件进行修改

概述
对点名的年月组件的值进行改动,在保管其余零件值合理的景况下,再次来到贰个新的时辰实例。

声明
func at(unit: Calendar.Component, value: Int) throws -> DateInRegion
func at(unit: Calendar.Component, value: Int) throws -> Date

参数

  • unit: calendar component unit to alter

异常
假定给定的机件赋值不成功,无法生成新时间实例时,会抛出
.FailedToCalculate 异常。

归来结果
在原时间基础上,修改给定组件的值,然后生成新的小时实例并重回。SwiftDate
在客观的前提下不会变动与给定组件相比较单位更大组件的值。补充表明:如若改动了岁月尾
的值,那拥有的等更小的机件的值都会被赋最小值 ,而

等更大单位的零件的值会保持原样,那样做是为着保全合理,03-31,假使对月改成
2 ,那2-31 很明显不客观。比如 二〇一五-11-11 11:11:11 修改了 12
那,再次来到的新的岁月是 二〇一五-12-01 00:00:00

例子

// 生成一个新的罗马时间,日历格式选择公历,时间表述格式以意大利为准。
// 03 gen 2015, 15:10:00 CET
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)
let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)

let atGivenYear = try! date.at(unit: .year, value: 2020) // 01 gen 2020, 00:00:00 CET. day is altered

批量改动时间组件的值


概述
给定3个 [时间组件 : 值] 的字典,斯维夫特Date
会根据时间组件的单位扩张排序,并修改对应组件的值。
在 SwiftDate 中,规定时间组件的增多排序为:
.nanosecond,.second,.minute,.hour,.day,.month,.year,.yearForWeekOfYear,.weekOfYear,.weekday,.quarter,.weekdayOrdinal,.weekOfMonth.

声明
func at(unitsWithValues dict: [Calendar.Component : Int]) throws -> DateInRegion
func at(unitsWithValues dict: [Calendar.Component : Int]) throws -> Date

参数

  • unitsWithValues: calendar component units to alter

异常
对一些时刻组件赋值爆发错误时,会抛出 .FailedToCalculate 异常。

回来结果
对点名组件赋值后,生成三个新的年华实例,比给定时间组件更大的零件将不会被修改,更小的比方没有赋值将全方位赋最小值;那部分的原理,在上二个措施中有补充表明。

例子

// Create a Region in Rome TimeZone with Gregorian Calendar and Italy locale settings
// 03 gen 2015, 15:10:00 CET
let regionRome = Region(tz: TimeZoneName.europeRome, cal: CalendarName.gregorian, loc: LocaleName.italianItaly)

let date = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
let time = try! date.at(unitsWithValues: [.year: 2016, .month: 7]) // 01 gen 2016, 00:00:00 CET

取得三个时刻中的最靠前(时间线上最靠右的)的时光

概述
在给定的八个时刻实例集合中,重回其中最新的时辰实例。相比根据相对时间值,时间实例的地带,时区,表述格式等零件不会对相比较结实发生潜移默化。

声明
(DateInRegion) static func latestDate(_ list: [DateInRegion]) -> DateInRegion
(Date) static func latestDate(_ list: [DateInRegion]) -> Date

例子

// date1 = 2015-01-03 15:10:00
let date1 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
// date2 = 2014-12-30 20:10:00
let date2 = try! DateInRegion(components: [.year: 2014, .month: 12, .day: 30, .hour: 20, .minute: 10, .second: 0], fromRegion: regionRome)
// date3 = 2015-01-03 15:20:00
let date3 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 20, .second: 0], fromRegion: regionRome)

// get the latest date in a set
let latestDate = DateInRegion.latestDate([date1,date2,date3]) // is date1 (2015-01-03 14:20:00 +0000)
// or directly via Array extension
let latestDate = [date1,date2,date3].latestDate

拿到八个时刻中最漫长(时间线上最靠左的)的年华

概述
在加以的多少个日子实例集合中,再次来到其中最遥远的时间。相比较依照相对时间值,时间实例的地段,时区,表述格式等零件不会对相比结实发生震慑。

声明
(DateInRegion) static func earliestDate(_ list: [DateInRegion]) -> DateInRegion
(Date) static func earliestDate(_ list: [DateInRegion]) -> Date

例子

// date1 = 2015-01-03 15:10:00
let date1 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 10, .second: 0], fromRegion: regionRome)
// date2 = 2014-12-30 20:10:00
let date2 = try! DateInRegion(components: [.year: 2014, .month: 12, .day: 30, .hour: 20, .minute: 10, .second: 0], fromRegion: regionRome)
// date3 = 2015-01-03 15:20:00
let date3 = try! DateInRegion(components: [.year: 2015, .month: 1, .day: 3, .hour: 15, .minute: 20, .second: 0], fromRegion: regionRome)

// get the latest date in a set
let earliestDate = DateInRegion.earliestDate([date1,date2,date3]) // is date2 30 dic 2014, 20:10:00 CET
// or directly via Array extension
let earliestDate = [date1,date2,date3].earliestDate

加以单位,相比较两时刻实例

概述
在加以单位的前提下,比较现有时间是还是不是晚于提供的小时。

声明
func compare(to date: DateInRegion, granularity: Calendar.Component) -> ComparisonResult
func compare(to date: Date, granularity: Calendar.Component) -> ComparisonResult

参数

  • date: date to compare
  • granularity:
    你所企望的比较粒度至少要比两时间之间的最大不一样组件之间要小,否则相比较结实会浮现相等。
    填补表达
    在同二个月的八个不等时间时间,以
    为单位比较时,是十分的,比如(伪代码)
    date1 = 2016-11-11 11:11:11
    date2 = 2016-11-12 11:11:11
    抑或更小的的单位比较,再次来到结果就是date2 更大

是否早于某时间(给定单位)

概述
在加以单位前提下,相比现有时间是还是不是早于给定时间。

声明
func isBefore(date: DateInRegion, orEqual: Bool = false, granularity: Calendar.Component) -> Bool
func isBefore(date: Date, orEqual: Bool = false, granularity: Calendar.Component) -> Bool

参数

  • date: date to compare
  • orEqual: true to also check for equality
  • granularity: The smallest unit that must, along with all larger
    units, be less for the given dates.

是不是晚于某时间(给定单位)

概述
在加以单位粒度前提下,相比较现有时间是或不是晚于给定时间。

声明
func isAfter(date: DateInRegion, orEqual: Bool = false, granularity: Calendar.Component) -> Bool
func compare(to date: Date, granularity: Calendar.Component) -> ComparisonResult
func isAfter(date: Date, orEqual: Bool = false, granularity: Calendar.Component) -> Bool

参数

  • date: date to compare
  • orEqual: true to also check for equality
  • granularity: The smallest unit that must, along with all larger
    units, be less for the given dates.

是不是等于某时间

概述
相比现有时间实例是或不是完全等于给定时间。

声明
func isEqual(to compareDate: DateInRegion) -> Bool

参数

  • compareDate: a date to compare against

时刻的格式化

概览
SwiftDate
提供七个便民的艺术来输出或分析时间和时间间隔字符串,以下为广泛时间格式举例:
使用 tr35-31
格式的时日格式字符串,例如 yyyy-MM-dd
对应 2015-01-05

专断符合 ISO8601
及其子规范的年华格式字符串

符合 .NET
的年月格式字符串

伸张化日期/时间格式,详情请参照
EDTF

声称单位的时日差,如 (date2 – date1).in(.hours)

人类可读或口语化的字符串,如 “1 hour ago”, “1m”, “now”

三个日子里面的差值,比如 “2h,5m,3s”

取得自定义格式的时刻字符串

您可以拔取 .string()
格局传入自定义格式,得到时间实例生成对应的字符串。字符串的 Unicode
规范与 Cocoa 用法一致。
声明 DateFormat
包含了 .custom
自定义格式,你能够拔取通用的// with DateFormat set to .custom([format
string])
func string(format: DateFormat) -> String

也足以直接拔取接受自定义格式的方法// shortcut to pass directly the
format of the string
func string(custom: String) -> String

参数
format
: a DateFormat
struct. To use custom strings pass .custom()
and pass the value of the formatter

例子

let date = DateInRegion()

let str = date.string(format: .custom(“yyyy-MM-dd HH:mm:ss”)) // example
output: 2016-09-28 13:48:17
// you can also use the shortcut:
let str = date.string(custom: “yyyy-MM-dd HH:mm:ss”) // same result

收获 ISO8601 格式的年华字符串
SwiftDate 支持 ISO8601
时刻标准的有所须要。你能够依照其子规范而自定义格式。
声明// with DateFormat set to .custom() func string(format:
DateFormat) -> String

参数
format
: a DateFormat
struct. To use custom strings pass .custom() and pass the value of the
formatter

例子

let date = DateInRegion()

// Here some combinations of ISO8601DateTimeFormatter.Options you can
set to format (or parse) an ISO8601 datetime
let iso8601_ex_1 = date.string(format: .iso8601(options:
[.withInternetDateTime])) // 2016-09-29T10:47:39+02:00
let iso8601_ex_2 = date.string(format: .iso8601(options:
[.withFullDate])) // 2016-09-29
let iso8601_ex_3 = date.string(format: .iso8601(options:
[.withWeekOfYear,.withYear])) // 2016W40
let iso8601_ex_4 = date.string(format: .iso8601(options:
[.withFullTime,.withFullDate,.withSpaceBetweenDateAndTime])) //
2016-09-29 10:49:42+02:00
let iso8601_ex_5 = date.string(format: .iso8601(options:
[.withMonth,.withYear,.withTime])) // 20160910:50:36

收获 Alt汉兰达ss 格式的时日字符串
斯维夫特Date 也提供对 猎豹CS6SS
和AltRSS
岁月格式的支撑。(蕴涵分析与生成字符串)
声明func string(format: DateFormat) -> String // with DateFormat
set to .rss(alt: Bool)

参数
format
: a DateFormat
struct. To get RSS/AltRSS
pass.rss(alt: Bool)
and pass true
or false
to set the alt format.

例子

let date = DateInRegion()

let altrss_string = date.string(format: .rss(alt: true)) // Alt RSS
Format: 29 Sep 2016 10:55:34 +0200
let rss_string = date.string(format: .rss(alt: false)) // RSS Format:
Thu, 29 Sep 2016 10:55:34 +0200

拿到 .NET 格式的小时字符串
斯维夫特Date 也提供对 .NET
时间格式的协理。(包含分析与生成字符串)
声明func string(format: DateFormat) -> String // with DateFormat
set to .dotNET

参数
format
: a DateFormat
struct. To get .NET
pass.dotNET
and pass true
or false
to set the alt format.

例子

let date = DateInRegion()

let donet_string = date.string(format: .dotNET) //
/Date(1475139751633+0200)/

拿到增加化(EDTF)格式的小运字符串
SwiftDate 也提供对伸张化日期/时间格式的支撑。
声明func string(format: DateFormat) -> String // with DateFormat
set to .extended

参数
format
: a DateFormat
struct. To get extended datetime formatted string pass .extended
and pass true
or false
to set the alt format.

例子

let date = DateInRegion()

let str = date.string(format: .extended) // Thu 29-Sep-2016 AD
11:31:23.886 GMT+2

赢得时间间隔的字符串表述
依傍 斯威夫特Date
,你可以很便利的将时间间隔或三个小时之间的差值,以一个或三个单位输出成字符串。如若您想要获取的中低档单位的值可以被完好进位,那低级单位所对应的值就被赋值为
0。比如 120秒 假诺转换来 分
、秒
的咬合,会被转换来 2分 0秒
; 125秒 则会收获 2分 5秒

声明四个时刻单位时public func in(_ components:
[Calendar.Component], of calendar: CalendarName? = nil) ->
[Calendar.Component : Int]
单个时间单位时public func in(_ component: Calendar.Component, of
calendar: CalendarName? = nil) -> Int?

参数
component
or components
: specify the component or an array of compone .extended
and pass true
or false
to set the alt format.

例子

let dateA = DateInRegion()

let dateB = dateA + 20.minutes + 120.seconds // create another date with
some diff
// Get difference in minutes
let diff_in_minutes = (dateB – dateA).in(.minute) // 22 minutes
// Get difference in seconds and minutes
let diff_in_min_and_secs = (dateB – dateA).in([.minute,.second])
// lower components are grouped. You will get .second=0, .minute=2
// This is another example
let another_diff: TimeInterval = 125 // 125 seconds
let diff_in_min_and_secs_2 = another_diff.in([.minute,.second])
// you will get .minute=2 and .second=5

赢得 iOS 样式的日子字符串
您可以采用 Foundation
中的时间格式来输出时间字符串。
声明func string(dateStyle: DateFormatter.Style = .medium, timeStyle:
DateFormatter.Style = .medium) -> String

参数
dateStyle
: the style used to print a date as DateFormatter.Style
. If not specified.medium
is used.

timeStyle
: the style used to print a time as DateFormatter.Style
. If not specified .medium
is used.

例子

let date = DateInRegion() // create a date from current time in local
device’s region and calendar

// Some examples of date as string formatted with different styles for
date and time
let example_1 = date.string(dateStyle: .medium, timeStyle: .long) //
Sep 29, 2015, 1:01:13 PM GMT+2
let example_2 = date.string(dateStyle: .short, timeStyle: .short) //
9/29/15, 1:00 PM
let example_3 = date.string(dateStyle: .long, timeStyle: .none) //
September 29, 2015

赢得人类可读或白话式时间字符串
你可以动用 Foundation
源于定义日期 –
时间格式来输出时间字符串;同样的,时间距离也得以选拔口语化字符串来发挥。
声明得到3个时光与当今无时无刻的差值时func colloquialSinceNow() throws
-> (date: String, time: String?)
得到三个时辰里面的差值时func colloquial(toDate date: DateInRegion)
throws -> (date: String, time: String?)
只顾:该方法再次来到的是二个日子与时光的元组。
异常设若五个时间使用不相同的日历,会抛出 .DifferentCalendar
十分;即使无法测算出多少个时间的距离,会抛出 .FailedToCalculate
异常。
参数
date
: reference date for comparisor

例子

// Returned tuples (in EN):

// “past month” for interval, “Aug, 29 2016” for relevant time
let dateA = DateInRegion() – 1.months
let (colloquial,relevantTime) = try! dateA.colloquialSinceNow()

// Returned tuples (in EN):
// “2 hours ago” for interval, “at 11:28” for relevant time
let dateB = DateInRegion() – 2.hours – 14.minutes
let (colloquial,relevantTime) = try! dateB.colloquialSinceNow()
亚洲必赢官网app,​
// Returned tuples (in EN):
// // “14 minutes ago” for interval, nil for relevant time
let dateC = DateInRegion() – 14.minutes
let (colloquial,relevantTime) = try! dateC.colloquialSinceNow()

// Returned tuples (in EN):
// “2012” for interval, “Sep 2012” for relevant time
let dateD = DateInRegion() – 4.years
let (colloquial,relevantTime) = try! dateD.colloquialSinceNow()

钦定单位下,获取五个小时之间的距离字符串
斯威夫特Date
可以在内定组件单位的前提下,获取多个时间的差值,并出口为字符串;你可以安装任意一个零件的来得地点,比如(年利用
y
或years
来表述);组件所对应的最大值以及最小值都会被妥善处理,比如日月年这一个单位最小值是
1,最大值是 12,而时分秒的最大值是 60 ,最小值是 0。
声明 获取三个时间与现时无时无刻的差值时func
timeComponentsSinceNow(options:,shared:) throws -> String
获取八个日子之内的差值时func timeComponents(to:options:shared:) throws
-> String

异常若是不能总括出可行的日子间隔,将会抛出 .FailedToCalculate
错误。
参数
to
: reference date for comparisor

options
: struct ComponentsFormatterOptions which defines a list of options used
to print time components

例子

let region = Region.GMT()

let dateB = DateInRegion(absoluteDate: Date(), in: region)
let dateC = dateB – 2.years – 4.months – 5.days

let str2 = try! dateC.timeComponents(toDate: dateB, options:
ComponentsFormatterOptions(style: .positional)) // -2y 4m 0w 5d 0:00:00

let str3 = try! dateC.timeComponents(toDate: dateB, options:
ComponentsFormatterOptions(style: .full)) // -2 years, 4 months, 0
weeks, 5 days, 0 hours, 0 minutes, 0 seconds

let str4 = try! dateC.timeComponents(toDate: dateB, options:
ComponentsFormatterOptions(zero: .dropAll)) // -2y 4m 5d
let dateD = dateB + 1.months
let str5 = try! dateD.timeComponentsSinceNow(options:
ComponentsFormatterOptions(allowedUnits: [.weekOfMonth,.day], zero:
.dropAll)) // 4w 2d

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 亚洲必赢手机官网 版权所有