Date : qu'est-ce que c'est, type d'heure et TimeInterval dans Foundation

Qu'est-ce que Date dans Foundation ?

Date est un type valeur du framework Foundation qui capture un seul moment absolu dans le temps. Contrairement aux représentations calendaires (année, mois, jour), Date ne dépend pas du fuseau horaire ou du système de calendrier — c'est une valeur d'horodatage purement numérique.

La représentation interne de Date est TimeInterval (un alias de type pour Double), stockant le nombre de secondes relatives à la date de référence — 1er janvier 2001, 00:00:00 UTC. Apple a choisi cette date plutôt que l'époque Unix (1970) pour la compatibilité avec les systèmes legacy NeXTSTEP, sur lesquels iOS et macOS sont construits.

Date est utilisé comme le type de temps standard dans toutes les API Apple : UIDatePicker, DatePicker, UserDefaults, Codable, Core Data, CloudKit. Sans Date, il est impossible de travailler avec des plannings, des minuteries, des événements de calendrier, la sérialisation de données et toute opération liée au temps.

Date vs autres types de temps

Date diffère des types calendaires en ce qu'il représente un horodatage physique plutôt qu'une valeur lisible par l'homme. La même Date peut correspondre à différentes dates calendaires dans différents fuseaux horaires. Pour extraire des composants (année, mois, jour), Date est converti via Calendar et DateComponents.

Date diffère également de DispatchTime, qui est utilisé pour la répartition des tâches dans Grand Central Dispatch. DispatchTime est relatif au moment de démarrage du système, tandis que Date est un horodatage absolu qui peut être sauvegardé, transmis et restauré.

Créer Date en Swift

Date() est la façon la plus simple de créer un objet avec le moment actuel. L'initialiseur sans paramètre retourne l'heure exacte de l'appel. Pour créer une date dans le passé ou le futur, utilisez TimeInterval et la méthode addingTimeInterval, ou l'initialisation à partir d'une Date existante.

Pour créer une date arbitraire à partir de composants, utilisez la paire Calendar et DateComponents. Calendar convertit les composants lisibles par l'homme (année, mois, jour, heure, minute) en Date. Vous pouvez également initialiser Date via ISO8601DateFormatter à partir d'une chaîne ISO 8601, ou via DateFormatter à partir d'une représentation de chaîne arbitraire.

Date.distantPast et Date.distantFuture sont deux propriétés statiques représentant des moments infiniment éloignés dans le passé et le futur. Elles sont utilisées comme valeurs limites pour filtrer et trier les dates dans les algorithmes.

import Foundation

// Créer Date avec l'heure actuelle
let now = Date()
print("Current time: \(now)")

// Date dans 1 heure (3600 secondes)
let inOneHour = now.addingTimeInterval(3600)

// Date à partir de composants
var components = DateComponents()
components.year = 2025
components.month = 12
components.day = 25
let christmas = Calendar.current.date(from: components)!

L'exemple montre trois façons de créer une Date : heure actuelle, ajout d'un intervalle et création via DateComponents. Les trois approches retournent une valeur de type Date avec une précision à la milliseconde. Calendar.current utilise le calendrier système de l'utilisateur — sur les appareils Apple, il s'agit généralement du calendrier grégorien.

TimeInterval et comparaison de dates

TimeInterval est un alias de type pour Double représentant le nombre de secondes entre deux moments dans le temps. La précision de TimeInterval atteint des fractions de milliseconde, ce qui est suffisant pour la plupart des tâches pratiques. Un TimeInterval négatif indique le passé par rapport au point de référence.

Date prend en charge tous les opérateurs de comparaison standard : ==, <, >, <=, >=. Swift compare automatiquement les valeurs TimeInterval internes. La méthode compare retourne ComparisonResult avec les options .orderedSame, .orderedAscending, .orderedDescending pour une comparaison plus explicite.

Date.distance(to:) est une méthode qui retourne le TimeInterval jusqu'à la date spécifiée. Si la date cible est dans le passé, le résultat est négatif. advanced(by:) crée une nouvelle date en ajoutant le TimeInterval spécifié à la date actuelle. Ces méthodes implémentent le protocole Strideable, permettant d'utiliser Date dans Range et ClosedRange.

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

// Comparaison avec des opérateurs
if start < end {
    print("start is earlier")
}

// TimeInterval entre deux dates
let interval: TimeInterval = end.timeIntervalSince(start)
print("Seconds: \(Int(interval / 60)) minutes")

// Utiliser Date dans un intervalle
let range = start...end
let mid = start.addingTimeInterval(43200)
if range.contains(mid) {
    print("mid is between start and end")
}

TimeInterval de 86400 correspond à un jour. Pour des intervalles plus complexes — semaines, mois, années — utilisez Calendar et DateComponents, car ces unités ont une longueur variable (années bissextiles, heure d'été). TimeInterval est applicable uniquement pour des intervalles fixes en secondes.

Calendar et DateComponents

Calendar est le pont entre Date et les composants lisibles par l'homme. Calendar convertit Date en DateComponents (année, mois, jour, heure, minute, seconde) en tenant compte du fuseau horaire et de la locale. Sans Calendar, il est impossible d'extraire l'année ou le mois de Date — Date ne contient pas cette information en raison de sa nature absolue.

La méthode Calendar.component extrait un seul composant de Date : année, mois, jour, heure, minute, seconde, jour de la semaine, trimestre. La méthode Calendar.dateComponents extrait un ensemble de composants en un seul appel — c'est plus efficace que d'appeler component pour chaque champ séparément.

Calendar.isDateInToday, isDateInTomorrow, isDateInYesterday sont des méthodes pratiques pour vérifier les dates relatives. Calendar.dateInterval retourne le début et la fin de la période spécifiée (jour, semaine, mois, année). Calendar.compare compare les dates avec une précision allant jusqu'au composant spécifié — par exemple, l'année sans tenir compte du mois et du jour.

let calendar = Calendar.current

// Extraire des composants
let year = calendar.component(.year, from: Date())
let month = calendar.component(.month, from: Date())

// Vérifier la date relative
if calendar.isDateInToday(someDate) {
    print("Today!")
}

// Début et fin du jour
let dayInterval = calendar.dateInterval(of: .day, for: Date())!
print("Day start: \(dayInterval.start)")
print("Day end: \(dayInterval.end)")

Calendar.current utilise les paramètres système de l'utilisateur — calendrier, fuseau horaire et locale. Pour les tests ou des calculs spécifiques, vous pouvez créer un Calendar avec des paramètres spécifiques via Calendar(identifier: .gregorian) et définir le fuseau horaire souhaité via la propriété timeZone.

DateFormatter et affichage des dates

DateFormatter est un composant obligatoire si Date doit être affiché à l'utilisateur. DateFormatter convertit Date en chaîne selon le format et la locale spécifiés. Convertir Date directement en chaîne via String(describing:) retourne une représentation technique avec la date de référence et TimeInterval — elle n'est pas destinée aux utilisateurs.

L'approche de base consiste à utiliser les styles prédéfinis dateStyle et timeStyle. iOS prend en charge quatre styles : .short, .medium, .long, .full. La combinaison des styles de date et d'heure permet une configuration d'affichage flexible. DateFormatter applique automatiquement la localisation : pour la locale russe, la date sera affichée au format « 21 juillet 2026 ».

ISO8601DateFormatter est un formatteur spécialisé pour ISO 8601, le format le plus courant pour les API et l'échange de données. Ce formatteur fonctionne plus rapidement que DateFormatter et ne dépend pas de la locale, ce qui le rend préférable pour la sérialisation des dates en JSON.

// Styles prédéfinis
let formatter = DateFormatter()
formatter.dateStyle = .medium
formatter.timeStyle = .short
let userString = formatter.string(from: Date())

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

// Analyse à partir d'une chaîne
let parsed = isoFormatter.date(from: "2026-07-21T10:30:00Z")!

Lorsque vous travaillez avec DateFormatter, il est important de se souvenir de la performance : créer un nouveau formatteur est une opération coûteuse. Il est recommandé de mettre en cache le formatteur ou de le créer une fois et de le réutiliser. Les propriétés du formatteur permettent de définir timeZone — par défaut, le fuseau horaire du système est utilisé, mais pour les dates de serveur, TimeZone(identifier: « UTC ») est souvent nécessaire.

Exemples d'utilisation de Date

Considérons des scénarios typiques pour travailler avec Date dans une application iOS. Le premier scénario est le calcul de l'âge à partir de la date de naissance de l'utilisateur. Le deuxième est un compte à rebours jusqu'à un événement. Le troisième est le regroupement d'enregistrements par date pour les afficher sous forme de sections de tableau.

Calculer l'âge à partir de la date de naissance

Calendar.dateComponents avec le flag [.year] calcule la différence entre deux dates. Définir le bon fuseau horaire est critique — si vous ne spécifiez pas timeZone dans Calendar, le résultat peut différer d'un jour en raison du passage à minuit dans un autre fuseau horaire.

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
}

Compte à rebours est implémenté à l'aide de TimeInterval. Calculez la différence entre la date cible et la date actuelle, obtenez le reste en secondes et convertissez-le en jours, heures, minutes. Pour les mises à jour régulières, utilisez Timer avec un intervalle de 1 seconde. Un ObservableObject avec une propriété @Published permet à SwiftUI de mettre à jour automatiquement l'interface.

Regroupement par date est implémenté à l'aide d'un dictionnaire avec Date comme clé. Calendar.dateInterval(of: .day, for:) normalise la date au début du jour, ce qui permet de regrouper les enregistrements appartenant au même jour. La même approche fonctionne pour les semaines, les mois et les années — il suffit de changer le composant dans dateInterval en .weekOfYear ou .month.