DateIntervalFormatter — grunder, formatering av datumsintervall

Vad är DateIntervalFormatter?

DateIntervalFormatter är en underklass till Formatter i Foundation som tar emot ett DateInterval-objekt (ett intervall mellan två datum) och returnerar en lokaliserad sträng med en beskrivning av detta intervall. Till exempel, för intervallet 21–25 juli 2024 blir resultatet "21–25 juli 2024" för sv_SE och "Jul 21–25, 2024" för en_US. Klassen grupperar intelligent upprepade element: om båda datumen är inom samma månad visas månadsnamnet en gång.

Huvudvärdet med DateIntervalFormatter är automatisk bearbetning av intervallgrammatik. Vid manuell formatering måste utvecklaren jämföra månad/år för början och slut, välja avgränsare (bindestreck, "från–till", "to", "bis") och övervaka böjning. DateIntervalFormatter gör detta automatiskt baserat på CLDR-data (Common Locale Data Repository), vilket minskar antalet buggar i internationella applikationer, särskilt för språk med komplex grammatik.

Enligt Unicode CLDR v44 (2024) skiljer sig reglerna för formatering av datumintervall avsevärt mellan språk. Tyska använder prepositionen "bis" (21.–25. Juli 2024), franska — "au" (du 21 au 25 juillet 2024), japanska — med bindestreck (2024 Jul 21–25). DateIntervalFormatter täcker alla dessa variationer utan extra kod från utvecklaren.

Hur fungerar DateIntervalFormatter i Foundation?

Funktionsprincip DateIntervalFormatter bygger på analys av två datum som bildar intervallet och val av optimal textrepresentation med hänsyn till locale. Klassen jämför datumkomponenter (år, månad, dag) och beslutar om gruppering: om året är detsamma — visas det en gång; om månaden är densamma — visas den en gång; om dagarna skiljer sig — visas dagintervallet.

Grupperingslogik är implementerad baserat på CLDR-mallar. Formateraren kontrollerar likheten för varje datumkomponent (Calendar.Component: year, month, day) i ordning från störst till minst. Så snart en komponent skiljer sig visas alla mindre komponenter för båda datumen. Till exempel, för 21–25 juli: året stämmer, månaden stämmer, dagen skiljer sig → månad en gång, dagar — för varje datum separat.

Viktig nyans: DateIntervalFormatter stöder inte konfiguration av avgränsare via API. Avgränsaren bestäms av locale och kan inte åsidosättas. Om en anpassad avgränsare behövs (till exempel "till" istället för "–"), måste du formatera datumen manuellt via DateFormatter och sammanfoga strängarna med en anpassad avgränsare.

Stilar för intervallformatering

DateIntervalFormatter erbjuder två uppsättningar stilar: dateStyle och timeStyle — för varje ände av intervallet. Dessa stilar fungerar liknande DateFormatter: .none döljer komponenten, .short ger kort format (21.07.2024), .medium — medel (21 jul 2024), .long — långt (21 juli 2024), .full — maximalt detaljerad (söndag, 21 juli 2024). Genom att kombinera dateStyle och timeStyle kan olika detaljnivåer uppnås.

Exempel på stilombinationer

• dateStyle = .medium, timeStyle = .none — endast datum: "21–25 juli 2024"
• dateStyle = .short, timeStyle = .short — datum och tid: "21.07.2024, 14:30 – 25.07.2024, 16:45"
• dateStyle = .none, timeStyle = .short — endast tid: "14:30–16:45" (om datumen är samma)
• dateStyle = .long, timeStyle = .none — långt datum: "21–25 juli 2024"
• dateStyle = .full, timeStyle = .short — fullständigt format: "söndag, 21 juli 2024 – torsdag, 25 juli 2024"

Viktigt: dateStyle och timeStyle tillämpas lika på båda ändarna av intervallet. Det går inte att ställa in olika stil för början och slut (till exempel .medium för början och .short för slut). Om olika stil behövs måste du formatera varje datum med en separat DateFormatter och sammanfoga resultaten.

import Foundation

let formatter = DateIntervalFormatter()

// Olika stilombinationer
let startDate = Date()
let endDate = Date().addingTimeInterval(345600) // +4 dagar
let interval = DateInterval(start: startDate, end: endDate)

// Endast datum, medium format
formatter.dateStyle = .medium
formatter.timeStyle = .none
print("Endast datum: \(formatter.string(from: interval))")

// Kort format med tid
formatter.dateStyle = .short
formatter.timeStyle = .short
print("Kort med tid: \(formatter.string(from: interval))")

// Fullständigt format
formatter.dateStyle = .full
formatter.timeStyle = .none
print("Fullständigt datum: \(formatter.string(from: interval))")

DateIntervalFormatter i Swift: exempel

Grundläggande användning av DateIntervalFormatter inkluderar att skapa en instans, konfigurera stilar och anropa string(from:). Metoden accepterar DateInterval — en struktur med egenskaperna start och end. DateInterval kan skapas från två Date, eller initieras med Duration (iOS 16+). Efter formatering är resultatet redo att visas i UI utan ytterligare bearbetning.

import Foundation

let calendar = Calendar.current
let now = Date()

// Specifika intervall exempel
let examples: [(title: String, start: Date, end: Date)] = [
    (
        "2-hour event",
        now,
        now.addingTimeInterval(7200)
    ),
    (
        "Week-long vacation",
        now,
        now.addingTimeInterval(604800)
    ),
    (
        "Cross-year period",
        calendar.date(from: DateComponents(
            year: 2024, month: 12, day: 25
        ))!,
        calendar.date(from: DateComponents(
            year: 2025, month: 1, day: 5
        ))!
    )
]

let intervalFormatter = DateIntervalFormatter()
intervalFormatter.dateStyle = .medium
intervalFormatter.timeStyle = .short

for (title, start, end) in examples {
    let interval = DateInterval(start: start, end: end)
    let result = intervalFormatter.string(from: interval)
    print("\(title): \(result)")
}

// Formatering via Calendar (iOS 16+)
if let nextWeek = calendar.date(
    byAdding: .day, value: 7, to: now
) {
    let weekInterval = DateInterval(start: now, end: nextWeek)
    print("Nästa 7 dagar: \(intervalFormatter.string(from: weekInterval))")
}

DateIntervalFormatter och Calendar Booking: i bokningsapplikationer (hotell, biljetter) är datumintervall en nyckeldel av UI. DateIntervalFormatter hanterar korrekt intervall som sträcker sig över årsskiften (till exempel från 28 december till 3 januari), genom att gruppera månad och år för varje datum separat. För sådana scenarier rekommenderas att använda dateStyle = .medium och timeStyle = .none — det mest läsliga formatet för datum utan tid.

import Foundation

let formatter = DateIntervalFormatter()
formatter.dateStyle = .long
formatter.timeStyle = .none

// Bokningsexempel
struct Booking {
    let checkIn: Date
    let checkOut: Date

    var formattedInterval: String {
        let interval = DateInterval(start: checkIn, end: checkOut)
        return formatter.string(from: interval)
    }
}

let booking = Booking(
    checkIn: calendar.date(from: DateComponents(
        year: 2024, month: 7, day: 21
    ))!,
    checkOut: calendar.date(from: DateComponents(
        year: 2024, month: 7, day: 25
    ))!
)
print("Bokning: \(booking.formattedInterval)")

// Användning med olika locale
let enFormatter = DateIntervalFormatter()
enFormatter.dateStyle = .medium
enFormatter.timeStyle = .none
enFormatter.locale = Locale(identifier: "en_US")
print("Engelska: \(enFormatter.string(from: interval))")

DateInterval vs DateIntervalFormatter: DateInterval — en struktur som representerar ett datumintervall (början och slut). DateIntervalFormatter — en formaterare som omvandlar denna struktur till en sträng. DateInterval stöder även contains(Date)- och intersection(with:)-kontroller, vilket är användbart för bokningslogik (kontroll av överlappande datum).

Lokalisering av datumsintervall

DateIntervalFormatter lokaliserar utdata via egenskapen locale. Som standard används Locale.current — enhetens locale. För att visa intervall på ett annat språk (till exempel engelskt innehåll i svenskt gränssnitt), ställ in locale explicit. Till skillnad från DateFormatter kräver DateIntervalFormatter ingen Locale-inställning för serverdata — den använder alltid sin egen interna grupperingslogik baserad på CLDR.

Språkskillnader i formatering av datumintervall är betydligt mer komplexa än för enskilda datum. Engelska använder enkelt bindestreck: Jul 21–25. Svenska — prepositionen "från–till": från 21 till 25 juli. Franska — "au": du 21 au 25 juillet. Tyska — punkt efter siffra och bindestreck: 21.–25. Juli. Japanska — med bindestreck utan preposition: Jul 21–25. DateIntervalFormatter täcker alla dessa varianter.

import Foundation

let formatter = DateIntervalFormatter()
formatter.dateStyle = .medium
formatter.timeStyle = .none

let start = Date()
let end = Date().addingTimeInterval(259200) // +3 dagar
let interval = DateInterval(start: start, end: end)

// Demonstration av olika locale
let localeIds = ["ru_RU", "en_US", "de_DE", "fr_FR", "ja_JP", "zh_CN"]
for localeId in localeIds {
    formatter.locale = Locale(identifier: localeId)
    print("\(localeId): \(formatter.string(from: interval))")
}

// Lokalisering för tidsintervall
formatter.dateStyle = .none
formatter.timeStyle = .short

let todayStart = Date()
let todayEnd = Date().addingTimeInterval(3600)
let timeInterval = DateInterval(start: todayStart, end: todayEnd)

for localeId in ["ru_RU", "en_US", "de_DE"] {
    formatter.locale = Locale(identifier: localeId)
    print("\(localeId) tid: \(formatter.string(from: timeInterval))")
}

Lokaliseringsfunktioner: för svenska använder DateIntervalFormatter prepositionerna "från" och "till" för långa datumformat. För kort (short) format — endast bindestreck: 21.07–25.07.2024. För fullständigt format (full) — med angivelse av veckodag. Valet av format beror på sammanhanget: för bokningslista använd .medium, för detaljerad visning — .long eller .full.

Jämförelse med andra datumformaterare

DateIntervalFormatter fyller nischen för formatering av datumintervall som andra Foundation-klasser inte täcker. DateFormatter formaterar enskilda datum, RelativeDateTimeFormatter — relativa datum (sedan/om), DateComponentsFormatter — varaktighet (2 timmar 30 minuter). Var och en av dessa klasser löser sin egen uppgift och kan inte ersättas av varandra.

När ska DateIntervalFormatter användas: för att visa datumintervall i UI — hotellbokning, evenemang, filtrering efter datum, operationshistorik. För att beräkna varaktigheten mellan datum, använd DateComponentsFormatter, inte DateIntervalFormatter — den senare är inte avsedd för att visa varaktighet. DateFormatter bör endast användas för enskilda datum, inte för att sammanfoga två formaterade datum via strängkonkatenering — detta leder till förlorad lokalisering av avgränsaren.

Kantfall: DateIntervalFormatter stöder inte visning av öppna intervall (utan slutdatum). Om intervallets slut är okänt (till exempel "från 21 juli"), använd DateFormatter med prepositionen "från" för svenska eller "from" för engelska. DateIntervalFormatter stöder inte heller intervall med tidsangivelse för olika dagar — tid tillämpas på varje datum separat, vilket kan verka överflödigt för korta intervall.