Date: vad är det, typ av tid och TimeInterval i Foundation

Vad är Date i Foundation?

Date — är en värdetyp från Foundation-ramverket som registrerar ett enda absolut ögonblick i tiden. Till skillnad från kalenderrepresentationer (år, månad, dag) är Date inte beroende av tidszon och kalendersystem — det är ett rent numeriskt värde av en tidsstämpel.

Den interna representationen av Date är ett TimeInterval (alias för Double) som lagrar antalet sekunder i förhållande till referensdatumet — 1 januari 2001 00:00:00 UTC. Apple valde detta datum istället för Unix epoch (1970) för kompatibilitet med gamla NeXTSTEP-system som iOS och macOS är baserade på.

Date används som standard tidstyp i alla Apple API:er: UIDatePicker, DatePicker, UserDefaults, Codable, Core Data, CloudKit. Utan Date är det omöjligt att arbeta med scheman, timers, kalenderhändelser, dataserialisering och alla tidsrelaterade operationer.

Date jämfört med andra tidstyper

Date skiljer sig från kalendertyper genom att det representerar en fysisk tidsstämpel, inte ett människoläsbart värde. Samma Date kan motsvara olika kalenderdatum i olika tidszoner. För att erhålla komponenter (år, månad, dag) omvandlas Date via Calendar och DateComponents.

Date skiljer sig även från DispatchTime, som används för sändning av uppgifter i Grand Central Dispatch. DispatchTime är relativt till ögonblicket för systemstart, medan Date är en absolut stämpel som kan sparas, överföras och återställas.

Skapa Date i Swift

Date() — är det enklaste sättet att skapa ett objekt med det aktuella tidögonblicket. Initieraren utan argument returnerar den exakta tiden för anropet. För att skapa ett datum i det förflutna eller framtiden används TimeInterval och metoden addingTimeInterval eller initiering från ett befintligt Date.

För att skapa ett godtyckligt datum från komponenter används paret Calendar och DateComponents. Calendar omvandlar människoläsbara komponenter (år, månad, dag, timme, minut) till Date. Man kan även initiera Date via ISO8601DateFormatter från en sträng i ISO 8601-format eller via DateFormatter från en godtycklig strängrepresentation.

Date.distantPast och Date.distantFuture — två statiska egenskaper som representerar oändligt avlägsna ögonblick i det förflutna och framtiden. De används som gränsvärden vid filtrering och sortering av datum i algoritmer.

import Foundation

// Skapa Date med aktuell tid
let now = Date()
print("Current time: \(now)")

// Datum om 1 timme (3600 sekunder)
let inOneHour = now.addingTimeInterval(3600)

// Datum från komponenter
var components = DateComponents()
components.year = 2025
components.month = 12
components.day = 25
let christmas = Calendar.current.date(from: components)!

I exemplet visas tre sätt att skapa Date: aktuell tid, lägga till ett intervall och skapa via DateComponents. Alla tre tillvägagångssätt returnerar ett värde av typen Date med millisekunders precision. Calendar.current använder användarens systemkalender — på Apple-enheter är detta vanligtvis den gregorianska kalendern.

TimeInterval och jämförelse av datum

TimeInterval — är ett alias för Double som representerar antalet sekunder mellan två tidögonblick. TimeIntervals precision når bråkdelar av millisekunder, vilket är tillräckligt för de flesta tillämpningsuppgifter. Ett negativt TimeInterval-värde indikerar det förflutna i förhållande till referenspunkten.

Date stöder alla standard jämförelseoperatorer: ==, <, >, <=, >=. Swift jämför automatiskt det interna TimeInterval för värden. Metoden compare returnerar ett ComparisonResult med varianterna .orderedSame, .orderedAscending, .orderedDescending för mer explicit jämförelse.

Date.distance(to:) — metod som returnerar TimeInterval till det angivna datumet. Om måldatumet är i det förflutna är resultatet negativt. advanced(by:) skapar ett nytt datum genom att lägga till det angivna TimeInterval till det aktuella datumet. Dessa metoder implementerar protokollet Strideable, vilket möjliggör användning av Date i intervall Range och ClosedRange.

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

// Jämförelse via operatorer
if start < end {
    print("start is earlier")
}

// TimeInterval mellan två datum
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")
}

TimeInterval lika med 86400 motsvarar ett dygn. För mer komplexa intervall — veckor, månader, år — använd Calendar och DateComponents, eftersom dessa enheter har variabel längd (skottår, övergång till sommartid). TimeInterval gäller endast för fasta intervall i sekunder.

Calendar och DateComponents

Calendar — är bron mellan Date och människoläsbara komponenter. Calendar omvandlar Date till DateComponents (år, månad, dag, timme, minut, sekund) med hänsyn till tidszon och locale. Utan Calendar är det omöjligt att extrahera år eller månad från Date — Date innehåller inte denna information på grund av sin absoluta natur.

Metoden Calendar.component extraherar en komponent från Date: år, månad, dag, timme, minut, sekund, weekday, quarter. Metoden Calendar.dateComponents extraherar en uppsättning komponenter i ett anrop — detta är effektivare än att anropa component för varje fält separat.

Calendar.isDateInToday, isDateInTomorrow, isDateInYesterday — bekväma metoder för att kontrollera relativa datum. Calendar.dateInterval returnerar början och slutet av den angivna perioden (dag, vecka, månad, år). Calendar.compare jämför datum med precisionen av den angivna komponenten — till exempel år utan att beakta månad och dag.

let calendar = Calendar.current

// Extrahera komponenter
let year = calendar.component(.year, from: Date())
let month = calendar.component(.month, from: Date())

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

// Början och slutet av dagen
let dayInterval = calendar.dateInterval(of: .day, for: Date())!
print("Day start: \(dayInterval.start)")
print("Day end: \(dayInterval.end)")

Calendar.current använder användarens systeminställningar — kalender, tidszon och locale. För testning eller specifika beräkningar kan man skapa en Calendar med konkreta parametrar via Calendar(identifier: .gregorian) och ställa in önskad TimeZone via egenskapen timeZone.

DateFormatter och datumvisning

DateFormatter — obligatorisk komponent om Date måste visas för användaren. DateFormatter omvandlar Date till en sträng enligt angivet format och locale. Direkt omvandling av Date till sträng via String(describing:) returnerar en teknisk representation med reference date och TimeInterval — den är inte avsedd för användaren.

Grundläggande tillvägagångssätt är att använda fördefinierade stilar dateStyle och timeStyle. iOS stöder fyra stilar: .short, .medium, .long, .full. Kombination av datum- och tidsstilar möjliggör flexibel anpassning av visningen. DateFormatter tillämpar automatiskt lokalisering: för svensk locale visas datumet i formatet \"21 juli 2026\".

ISO8601DateFormatter — en specialiserad formatterare för ISO 8601, det vanligaste formatet för API och datautbyte. Denna formatterare fungerar snabbare än DateFormatter och är oberoende av locale, vilket gör den att föredra för serialisering av datum i JSON.

// Fördefinierade stilar
let formatter = DateFormatter()
formatter.dateStyle = .medium
formatter.timeStyle = .short
let userString = formatter.string(from: Date())

// ISO 8601 för API
let isoFormatter = ISO8601DateFormatter()
let apiString = isoFormatter.string(from: Date())

// Tolkning från sträng
let parsed = isoFormatter.date(from: "2026-07-21T10:30:00Z")!

När man arbetar med DateFormatter är det viktigt att tänka på prestanda: att skapa en ny formatterare är en dyr operation. Det rekommenderas att cachelagra formatteraren eller skapa den en gång och återanvända. I formatterarens egenskaper kan timeZone ställas in — som standard används systemets tidszon, men för serverdatum krävs ofta TimeZone(identifier: \"UTC\").

Exempel på användning av Date

Låt oss titta på typiska scenarier för arbete med Date i en iOS-applikation. Första scenariot — beräkning av ålder från födelsedatum. Andra — nedräkningstimer till en händelse. Tredje — gruppering av poster efter datum för visning som tabellsektioner.

Beräkning av ålder från födelsedatum

Calendar.dateComponents med flaggan [.year] beräknar skillnaden mellan två datum. Att ställa in rätt tidszon är kritiskt — om du inte anger timeZone i Calendar kan resultatet avvika med en dag på grund av midnattspassage i en annan tidszon.

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
}

Nedräkningstimer implementeras via TimeInterval. Vi beräknar skillnaden mellan måldatumet och aktuellt datum, får resten i sekunder och omvandlar till dagar, timmar, minuter. För regelbunden uppdatering används Timer med ett intervall på 1 sekund. ObservableObject med egenskapen @Published gör att SwiftUI automatiskt kan uppdatera gränssnittet.

Gruppering efter datum implementeras via en ordbok med nyckeln Date. Calendar.dateInterval(of: .day, for:) normaliserar datumet till början av dagen, vilket möjliggör gruppering av poster som tillhör samma dag. Samma tillvägagångssätt fungerar för veckor, månader och år — det räcker att ändra komponenten i dateInterval till .weekOfYear eller .month.