Date: ano ito, uri ng oras at TimeInterval sa Foundation

Ano ang Date sa Foundation?

Date — ay isang value type mula sa framework ng Foundation na nagtatala ng isang ganap na sandali ng oras. Hindi tulad ng mga representasyon ng kalendaryo (taon, buwan, araw), ang Date ay hindi nakadepende sa time zone at sistema ng kalendaryo — ito ay isang puro numerikong halaga ng isang time stamp.

Ang panloob na representasyon ng Date ay isang TimeInterval (alias para sa Double) na nag-iimbak ng bilang ng mga segundo na may kaugnayan sa reference date — Enero 1, 2001 00:00:00 UTC. Pinili ng Apple ang petsang ito sa halip na Unix epoch (1970) para sa pagiging tugma sa mga lumang sistema ng NeXTSTEP kung saan itinayo ang iOS at macOS.

Ang Date ay ginagamit bilang karaniwang uri ng oras sa lahat ng API ng Apple: UIDatePicker, DatePicker, UserDefaults, Codable, Core Data, CloudKit. Kung walang Date, hindi posible na magtrabaho sa mga iskedyul, timer, kaganapan sa kalendaryo, serialization ng data, at anumang operasyon na may kaugnayan sa oras.

Date kumpara sa iba pang uri ng oras

Date ay naiiba sa mga uri ng kalendaryo dahil kumakatawan ito sa isang pisikal na time stamp, hindi isang halaga na nababasa ng tao. Ang parehong Date ay maaaring tumugma sa iba't ibang petsa ng kalendaryo sa iba't ibang time zone. Upang makuha ang mga bahagi (taon, buwan, araw), ang Date ay kino-convert sa pamamagitan ng Calendar at DateComponents.

Date ay naiiba rin sa DispatchTime, na ginagamit para sa pagpapadala ng mga gawain sa Grand Central Dispatch. Ang DispatchTime ay nauugnay sa sandali ng pagsisimula ng system, habang ang Date ay isang ganap na stamp na maaaring i-save, ipadala, at ibalik.

Paglikha ng Date sa Swift

Date() — ay ang pinakasimpleng paraan upang lumikha ng isang bagay na may kasalukuyang sandali ng oras. Ang initializer na walang argumento ay nagbabalik ng eksaktong oras ng pagtawag. Upang lumikha ng isang petsa sa nakaraan o hinaharap, ginagamit ang TimeInterval at ang pamamaraang addingTimeInterval o pagsisimula mula sa isang umiiral na Date.

Upang lumikha ng isang arbitrary na petsa mula sa mga bahagi, ginagamit ang pares na Calendar at DateComponents. Kino-convert ng Calendar ang mga bahagi na nababasa ng tao (taon, buwan, araw, oras, minuto) sa Date. Maaari ring simulan ang Date sa pamamagitan ng ISO8601DateFormatter mula sa isang string sa format na ISO 8601 o sa pamamagitan ng DateFormatter mula sa isang arbitrary na representasyon ng string.

Date.distantPast at Date.distantFuture — dalawang static na pag-aari na kumakatawan sa walang katapusang malalayong sandali ng nakaraan at hinaharap. Ginagamit ang mga ito bilang mga halaga ng hangganan kapag nag-filter at nag-uuri ng mga petsa sa mga algorithm.

import Foundation

// Paglikha ng Date na may kasalukuyang oras
let now = Date()
print("Current time: \(now)")

// Petsa pagkatapos ng 1 oras (3600 segundo)
let inOneHour = now.addingTimeInterval(3600)

// Petsa mula sa mga bahagi
var components = DateComponents()
components.year = 2025
components.month = 12
components.day = 25
let christmas = Calendar.current.date(from: components)!

Sa halimbawa, ipinapakita ang tatlong paraan ng paglikha ng Date: kasalukuyang oras, pagdaragdag ng agwat, at paglikha sa pamamagitan ng DateComponents. Lahat ng tatlong diskarte ay nagbabalik ng isang halaga ng uri Date na may katumpakan ng millisecond. Ang Calendar.current ay gumagamit ng system calendar ng gumagamit — sa mga device ng Apple ito ay karaniwang Gregorian calendar.

TimeInterval at paghahambing ng mga petsa

TimeInterval — ay isang alias para sa Double na kumakatawan sa bilang ng mga segundo sa pagitan ng dalawang sandali ng oras. Ang katumpakan ng TimeInterval ay umaabot sa mga bahagi ng millisecond, na sapat para sa karamihan ng mga gawain sa aplikasyon. Ang negatibong halaga ng TimeInterval ay nagpapahiwatig ng nakaraan na may kaugnayan sa reference point.

Sinusuportahan ng Date ang lahat ng karaniwang operator ng paghahambing: ==, <, >, <=, >=. Awtomatikong inihahambing ng Swift ang panloob na TimeInterval ng mga halaga. Ang pamamaraang compare ay nagbabalik ng ComparisonResult na may mga variant na .orderedSame, .orderedAscending, .orderedDescending para sa mas malinaw na paghahambing.

Date.distance(to:) — pamamaraan na nagbabalik ng TimeInterval hanggang sa tinukoy na petsa. Kung ang target na petsa ay nasa nakaraan, ang resulta ay negatibo. advanced(by:) ay lumilikha ng isang bagong petsa sa pamamagitan ng pagdaragdag ng tinukoy na TimeInterval sa kasalukuyang petsa. Ang mga pamamaraang ito ay nagpapatupad ng protokol na Strideable, na nagpapahintulot sa paggamit ng Date sa mga saklaw na Range at ClosedRange.

let start = Date()
let end = start.addingTimeInterval(86400)

// Paghahambing sa pamamagitan ng mga operator
if start < end {
    print("start is earlier")
}

// TimeInterval sa pagitan ng dalawang petsa
let interval: TimeInterval = end.timeIntervalSince(start)
print("Seconds: \(Int(interval / 60)) minutes")

// Using Date in range
let range = start...end
let mid = start.addingTimeInterval(43200)
if range.contains(mid) {
    print("mid is between start and end")
}

Ang TimeInterval na katumbas ng 86400 ay tumutugma sa isang araw. Para sa mas kumplikadong mga agwat — linggo, buwan, taon — gamitin ang Calendar at DateComponents, dahil ang mga unit na ito ay may variable na haba (taon ng leap, pagbabago ng daylight saving time). Ang TimeInterval ay nalalapat lamang para sa mga nakapirming agwat sa mga segundo.

Calendar at DateComponents

Calendar — ay ang tulay sa pagitan ng Date at mga bahagi na nababasa ng tao. Kino-convert ng Calendar ang Date sa DateComponents (taon, buwan, araw, oras, minuto, segundo) na isinasaalang-alang ang time zone at locale. Kung walang Calendar, hindi posible na makuha ang taon o buwan mula sa Date — hindi naglalaman ang Date ng impormasyong ito dahil sa kanyang ganap na kalikasan.

Ang pamamaraang Calendar.component ay kumukuha ng isang bahagi mula sa Date: taon, buwan, araw, oras, minuto, segundo, weekday, quarter. Ang pamamaraang Calendar.dateComponents ay kumukuha ng isang set ng mga bahagi sa isang tawag — ito ay mas mahusay kaysa sa pagtawag ng component para sa bawat field nang hiwalay.

Calendar.isDateInToday, isDateInTomorrow, isDateInYesterday — maginhawang pamamaraan para sa pagsuri ng mga kaugnay na petsa. Calendar.dateInterval ay nagbabalik ng simula at wakas ng tinukoy na panahon (araw, linggo, buwan, taon). Calendar.compare ay naghahambing ng mga petsa na may katumpakan ng tinukoy na bahagi — halimbawa, taon nang hindi isinasaalang-alang ang buwan at araw.

let calendar = Calendar.current

// Pagkuha ng mga bahagi
let year = calendar.component(.year, from: Date())
let month = calendar.component(.month, from: Date())

// Check relative date
if calendar.isDateInToday(someDate) {
    print("Today!")
}

// Simula at wakas ng araw
let dayInterval = calendar.dateInterval(of: .day, for: Date())!
print("Day start: \(dayInterval.start)")
print("Day end: \(dayInterval.end)")

Calendar.current ay gumagamit ng mga setting ng system ng gumagamit — kalendaryo, time zone, at locale. Para sa pagsubok o tiyak na mga kalkulasyon, maaaring lumikha ng Calendar na may kongkretong mga parameter sa pamamagitan ng Calendar(identifier: .gregorian) at itakda ang nais na TimeZone sa pamamagitan ng pag-aari na timeZone.

DateFormatter at pagpapakita ng petsa

DateFormatter — sapilitang bahagi kung ang Date ay kailangang ipakita sa gumagamit. Kino-convert ng DateFormatter ang Date sa isang string ayon sa tinukoy na format at locale. Ang direktang conversion ng Date sa string sa pamamagitan ng String(describing:) ay nagbabalik ng isang teknikal na representasyon na may reference date at TimeInterval — hindi ito para sa gumagamit.

Ang pangunahing diskarte ay ang paggamit ng mga paunang natukoy na estilo dateStyle at timeStyle. Sinusuportahan ng iOS ang apat na estilo: .short, .medium, .long, .full. Ang kumbinasyon ng mga estilo ng petsa at oras ay nagpapahintulot ng nababagong pagsasaayos ng pagpapakita. Awtomatikong naglalapat ng lokalisasyon ang DateFormatter: para sa locale ng Pilipinas, ang petsa ay ipapakita sa format na \"Hulyo 21, 2026\".

ISO8601DateFormatter — isang dalubhasang formatter para sa ISO 8601, ang pinakakaraniwang format para sa API at pagpapalitan ng data. Ang formatter na ito ay gumagana nang mas mabilis kaysa sa DateFormatter at hindi nakadepende sa locale, na ginagawa itong mas gusto para sa serialization ng mga petsa sa JSON.

// Paunang natukoy na mga estilo
let formatter = DateFormatter()
formatter.dateStyle = .medium
formatter.timeStyle = .short
let userString = formatter.string(from: Date())

// ISO 8601 para sa API
let isoFormatter = ISO8601DateFormatter()
let apiString = isoFormatter.string(from: Date())

// Pag-parse mula sa string
let parsed = isoFormatter.date(from: "2026-07-21T10:30:00Z")!

Kapag nagtatrabaho sa DateFormatter, mahalagang tandaan ang pagganap: ang paglikha ng bagong formatter ay isang mamahaling operasyon. Inirerekomenda na i-cache ang formatter o likhain ito nang isang beses at gamitin muli. Sa mga pag-aari ng formatter, maaaring itakda ang timeZone — bilang default, ginagamit ang system time zone, ngunit para sa mga petsa ng server ay madalas na kinakailangan ang TimeZone(identifier: \"UTC\").

Mga halimbawa ng paggamit ng Date

Tingnan natin ang mga tipikal na senaryo ng pagtatrabaho sa Date sa isang iOS application. Unang senaryo — pagkalkula ng edad ng gumagamit mula sa petsa ng kapanganakan. Pangalawa — timer ng countdown hanggang sa isang kaganapan. Pangatlo — pagpapangkat ng mga tala ayon sa petsa para sa pagpapakita bilang mga seksyon ng talahanayan.

Pagkalkula ng edad mula sa petsa ng kapanganakan

Calendar.dateComponents na may bandila na [.year] ay kinakalkula ang pagkakaiba sa pagitan ng dalawang petsa. Ang pagtatakda ng tamang time zone ay kritikal — kung hindi mo tinukoy ang timeZone sa Calendar, ang resulta ay maaaring mag-iba ng isang araw dahil sa pagtawid ng hatinggabi sa ibang time zone.

func calculateAge(from birthDate: Date) -> Int {
    let calendar = Calendar.current
    let now = Date()
    let components = calendar.dateComponents(
        [.year], from: birthDate, to: now
    )
    return components.year ?? 0
}

Timer ng countdown ay ipinatupad sa pamamagitan ng TimeInterval. Kinakalkula namin ang pagkakaiba sa pagitan ng target na petsa at kasalukuyang petsa, nakuha ang natitira sa mga segundo at kino-convert sa mga araw, oras, minuto. Para sa regular na pag-update, ginagamit ang Timer na may interval na 1 segundo. Ang ObservableObject na may pag-aari na @Published ay nagpapahintulot sa SwiftUI na awtomatikong i-update ang interface.

Pagpapangkat ayon sa petsa ay ipinatupad sa pamamagitan ng isang diksyunaryo na may susi na Date. Ang Calendar.dateInterval(of: .day, for:) ay nag-normalize ng petsa hanggang sa simula ng araw, na nagpapahintulot sa pagpapangkat ng mga tala na kabilang sa parehong araw. Ang parehong diskarte ay gumagana para sa mga linggo, buwan at taon — sapat na upang baguhin ang bahagi sa dateInterval sa .weekOfYear o .month.