Dátum és idő a mobilfejlesztésben: mi ez, milyen formátumok és hogyan dolgozzunk

Szerző: IT Sectr Megjelenés: 2026-07-22 Olvasási idő: 11 perc

Dátum és idő a mobilfejlesztésben — a mobilmérnökség egyik kulcsfontosságú témája. Az iOS a DateFormatter és ISO8601DateFormatter használja, az Android a java.time-ból a DateTimeFormatter és LocalDate használja. A Android Developer Docs szerint a dátum és idő formázásához használt megfelelő mobil API kiválasztása közvetlenül befolyásolja a teljesítményt és a helyes megjelenítést a különböző időzónákban.

Főbb pontok

  • DateFormatter iOS-en — erőteljes, de lassú gyakori létrehozáskor. Gyorsítótárazza a példányokat vagy használja az ISO8601DateFormatter-t az ISO 8601 formátumhoz.
  • DateTimeFormatter Androidon — szálbiztos formázó a java.time-ból. Az API 26-tól kezdve felváltotta az elavult SimpleDateFormat-ot.
  • ThreeTenABP — a java.time backport-ja Android API 26 alá. LocalDate, ZonedDateTime és DateTimeFormatter hozzáadása régi eszközökön.
  • TimeZone — kritikus fontosságú az UTC helyi időre történő konvertálásához. Tárolja az időt UTC-ben, jelenítse meg a felhasználó időzónájában.
  • Unix Timestamp — az időtárolás szabványos formátuma. Az NTP-n keresztüli szinkronizálás ezredmásodperces pontosságot garantál.

Dátum és idő iOS-en: DateFormatter és ISO8601DateFormatter

IOS-en a dátum és idő hagyományosan a Foundation DateFormatter osztályán keresztül van formázva. Ez az osztály a Date-et stringé alakítja és vissza egy meghatározott minta, locale és időzóna segítségével. A DateFormatter fő problémája — nem szálbiztos és lassan jön létre, ezért a mobil kódban a példányokat kötelező gyorsítótárazni. A dátum a mobilfejlesztésben iOS-en megköveteli a megfelelő formázót.

DateFormatter és teljesítmény

Egy DateFormatter létrehozása körülbelül 1 ezredmásodpercet vesz igénybe a dateFormat minta elemzése, a locale betöltése és az időzóna meghatározása miatt. Több száz dátumból álló lista formázásakor az ismételt létrehozás észrevehető késleltetést okoz a felhasználói felületen. A megoldás — hozza létre a formázót egyszer a teljes képernyőhöz, és használja újra. Többszálú hozzáféréshez használjon szinkronizálást a DispatchQueue-on keresztül.

swift
import Foundation

// Gyorsítótárazott DateFormatter — egyszer jön létre
private let dateFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateFormat = "dd.MM.yyyy HH:mm"
    formatter.locale = Locale(identifier: "ru_RU")
    formatter.timeZone = TimeZone(identifier: "Europe/Moscow")
    return formatter
}()

// ISO8601DateFormatter — könnyű alternatíva
private let isoFormatter: ISO8601DateFormatter = {
    let formatter = ISO8601DateFormatter()
    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
    return formatter
}()

let now = Date()
let formattedDate = dateFormatter.string(from: now)
// "01.07.2026 14:30"
let isoDate = isoFormatter.string(from: now)
// "2026-07-01T14:30:00.000Z"

Az ISO 8601 formátumhoz használja az ISO8601DateFormatter-t — nem igényel minta megadását és gyorsabban működik, mint a DateFormatter. IOS 10+ esetén ez az osztály előnyösebb a szerver dátumokkal való munkához. Régi formátumokhoz tartsa meg a DateFormatter-t, de feltétlenül gyorsítótárazza a példányt statikus tulajdonságként vagy singleton-ként.

Dátum és idő Androidon: java.time és DateTimeFormatter

Androidon a dátum és idő a java.time csomagon keresztül kerül feldolgozásra, amely az API 26-tól érhető el. Fő osztályok: LocalDate (csak dátum), LocalTime (csak idő), LocalDateTime (dátum és idő időzóna nélkül) és ZonedDateTime (időzónával). DateTimeFormatter — egy szálbiztos formázó az Android mobil platformhoz. A dátum a mobilalkalmazásokban a DateTimeFormatter és LocalDate segítségével van formázva teljesítményveszteség nélkül.

LocalDate, ZonedDateTime és formázás

LocalDate dátumot tárol idő nélkül — ideális születésnapokhoz. A ZonedDateTime teljes információt tárol időzónával. A DateTimeFormatter támogatja az előre definiált mintákat (ISO_LOCAL_DATE, ISO_DATE_TIME) és az egyéni mintákat az ofPattern segítségével. Az összes java.time osztály megváltoztathatatlan és szálbiztos, ami kiküszöböli a versenyhelyzeteket több szálon történő munka során.

kotlin
import java.time.LocalDate
import java.time.LocalDateTime
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
import java.time.ZoneId

// Aktuális dátum létrehozása és formázása
val today = LocalDate.now()
val formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy")
val formatted = today.format(formatter)

// Munka időzónákkal
val utcTime = ZonedDateTime.now(ZoneId.of("UTC"))
val moscowTime = utcTime.withZoneSameInstant(ZoneId.of("Europe/Moscow"))

DateTimeFormatter jelentősen hatékonyabb, mint a SimpleDateFormat, mert nem elemzi a mintát minden híváskor. Javasolt a formázó konstansok létrehozása osztály vagy kísérő objektum szinten. Unix Timestamp konvertálásához használja az Instant.ofEpochSecond-t, majd konvertálja LocalDateTime vagy ZonedDateTime típusúvá az időzónán keresztül.

Időzónák: dátum és idő mobilalkalmazásokban és TimeZone

A helyes dátum és idő a felhasználó képernyőjén az időzónák megfelelő kezelésétől függ. A dátum és idő a mobilfejlesztésben Android esetében megköveteli az eszköz időzónájának figyelembevételét. Az aranyszabály: tárolja az időt UTC-ben, csak megjelenítéshez konvertálja helyi időzónába. Az iOS a Foundation TimeZone osztályát, az Android a java.time ZoneId osztályát biztosítja. Mindkét API a mobil platformokhoz támogatja az eszköz aktuális időzónájának automatikus észlelését. A dátum egy mobilalkalmazásban a ZoneId-től és a TimeZone-tól függ.

Nyári időszámítás és IANA azonosítók

Nyári időszámítás kétértelműséget teremt: egy időpillanatot két különböző helyi idő képviselhet. A java.time és a Foundation automatikusan kezeli a DST-t. Használjon IANA azonosítókat (Europe/Moscow, America/New_York), ne rövidítéseket (MSK, EST) — a rövidítések kétértelműek és figyelmen kívül hagyják a nyári időszámításra való átállást.

swift
import Foundation

// UTC konvertálása helyi időre iOS-en
func formatToLocalTime(utcDate: Date, timeZoneId: String) -> String {
    let formatter = DateFormatter()
    formatter.dateFormat = "dd.MM.yyyy HH:mm"
    formatter.timeZone = TimeZone(identifier: timeZoneId)
    return formatter.string(from: utcDate)
}

// Az eszköz időzónájának meghatározása
let localTimeZone = TimeZone.current
let isDST = localTimeZone.isDaylightSavingTime()
let secondsFromGMT = localTimeZone.secondsFromGMT()

Androidon használja a ZoneId.systemDefault() parancsot az eszköz időzónájának lekéréséhez. Az UTC helyi időre konvertálásakor hozzon létre egy ZonedDateTime-t ZoneOffset.UTC-vel, és alkalmazza a withZoneSameInstant függvényt. Java.time nélküli régi API-khoz használja a TimeZone.getDefault() és Calendar osztályokat — de jobb, ha közvetlenül hozzáadja a ThreeTenABP-t.

kotlin
import java.time.Instant
import java.time.ZonedDateTime
import java.time.ZoneId

// Unix Timestamp konvertálása helyi időre
fun toLocalDisplay(unixSeconds: Long): String {
    val instant = Instant.ofEpochSecond(unixSeconds)
    val local = instant.atZone(ZoneId.systemDefault())
    return local.format(DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm"))
}

ThreeTenABP — dátum és idő régi Android verziókhoz

ThreeTenABP — egy adapter könyvtár, amely a java.time-t Android API 26 alá portolja. Ugyanazokat az osztályokat biztosítja: LocalDate, LocalTime, ZonedDateTime, DateTimeFormatter, Instant. Ha az alkalmazás támogatja az Android 5 vagy 6 (API 21-25) verziót, a ThreeTenABP az egyetlen módja a modern mobil API használatának anélkül, hogy át kellene váltani az elavult Calendar osztályra. A dátum és idő a mobilfejlesztésben régi eszközökhöz ezen a könyvtáron keresztül van implementálva. Régi eszközök esetén a dátum és idő a ThreeTenABP-n keresztül van implementálva.

A ThreeTenABP hozzáadása és konfigurálása

A könyvtár inicializálást igényel az Application.onCreate() metódusban az AndroidThreeTen.init() meghívásával. Ez betölti az időzóna adatokat az assets mappából. Az inicializálás után az API teljesen azonos a java.time-dal — az API 26+ és API 21+ kódja ugyanaz lesz. A könyvtár mérete körülbelül 400 KB, ami a legtöbb mobilalkalmazás számára elfogadható.

kotlin
import org.threeten.bp.LocalDate
import org.threeten.bp.format.DateTimeFormatter

// Inicializálás az Application-ben
class App : Application() {
    override fun onCreate() {
        super.onCreate()
        AndroidThreeTen.init(this)
    }
}

// Az API azonos a java.time-dal
val today = LocalDate.now()
val formatted = today.format(DateTimeFormatter.ISO_LOCAL_DATE)

A ThreeTenABP teljesítménye modern eszközökön összehasonlítható az eredeti java.time-dal. Régi eszközökön késleltetés lehetséges az első híváskor az időzóna adatok betöltése miatt. Migrálja a meglévő kódot a Calendar osztályról a ThreeTenABP-re fokozatosan: cserélje ki a Date és Calendar osztályokat Instant és LocalDate osztályokra az új modulokban, a régi kódot hagyja változatlanul.

Unix Timestamp és idők szinkronizálása NTP-n keresztül

Unix Timestamp — az 1970. január 1. 00:00 UTC óta eltelt másodpercek száma. Ez egy univerzális formátum az idő tárolására és cseréjére a szerver és a kliens között. Az eszközön lévő idő azonban eltérhet a valós időtől a felhasználói beállítások miatt. A szinkronizáláshoz NTP-t használnak — egy pontos idő protokollt UDP-n keresztül. A Unix Timestamp az a formátum, amelyben a dátum és idő a szerveren tárolódik.

Unix Timestamp lekérése és NTP szinkronizálás

Date().timeIntervalSince1970 iOS-en másodperceket ad vissza 1970 óta. Androidon a System.currentTimeMillis() ezredmásodperceket ad vissza. Pontosságért használjon NTP-t: a TrueTime könyvtár iOS-hez és az AndroidNtp Androidhoz kérést küld egy NTP szervernek, és kiszámítja az időeltolódást. Az NTP pontossága helyi hálózaton 1-10 ms, interneten keresztül 10-100 ms.

swift
import Foundation

// Unix Timestamp lekérése iOS-en
let seconds = Date().timeIntervalSince1970
let milliseconds = Int64(seconds * 1000)

// NTP szinkronizálás TrueTime-mal
TrueTime.shared.start { result in
    switch result {
    case .success:
        let ntpTime = TrueTime.shared.now()
        print("Pontos idő: \(ntpTime)")
    case .failure(let error):
        print("NTP hiba: \(error)")
    }
}

Szinkronizálás nélkül egy mobilalkalmazásban hibák lehetségesek: helytelen esemény időbélyegek, deszinkronizáció a szerverrel. Az idő a mobilfejlesztésben egyszer, az alkalmazás indításakor szinkronizálódik NTP-n keresztül, majd a kiszámított eltolódás kerül felhasználásra. Pontosság-kritikus mobilalkalmazások (pénzügy, logisztika) esetén az NTP protokoll kötelező az adatok szerverre küldése előtt.

Gyakran ismételt kérdések

Miért lassú a DateFormatter iOS-en?

DateFormatter minden egyes példány létrehozásakor elemzi a formázási mintát, betölti a locale-t és meghatározza az időzónát. Gyorsítótárazza a formázót statikus konstansként, vagy használja az ISO8601DateFormatter-t az ISO 8601 formátumhoz — könnyebb és gyorsabb.

Mit használjunk a SimpleDateFormat helyett Androidon?

DateTimeFormatter a java.time csomagból — szálbiztos és hatékony. Az API 26-tól érhető el. Régebbi verziókhoz használja a ThreeTenABP-t, amely azonos API-t biztosít.

Hogyan dolgozzunk Java 8 előtti dátumokkal Androidon?

Adja hozzá a ThreeTenABP-t — a java.time backport-ját Android API 21+-hoz. Inicializálás az AndroidThreeTen.init() segítségével az Application.onCreate()-ben. Az API teljesen azonos az eredeti java.time-dal.

Szükséges UTC-ben tárolni az időt?

Igen, tárolja az időt UTC-ben a szerveren és a helyi adatbázisban. Csak a megjelenítés szakaszában konvertálja a felhasználó helyi időzónájába. Ez kiküszöböli a hibákat időzóna váltáskor vagy utazáskor.

Hogyan lehet Unix Timestamp-t lekérni iOS-en?

Date().timeIntervalSince1970 visszaadja az 1970. január 1. óta eltelt másodpercek számát. Ezredmásodpercekhez szorozza meg 1000-rel és konvertálja Int64-re. Pontos szinkronizáláshoz használja a TrueTime könyvtárat egy NTP szerverrel.

Összefoglalás

  • DateFormatter iOS-en — a dátum és idő formázásának fő eszköze, kötelező példány gyorsítótárazást igényel. Az ISO8601DateFormatter egy könnyebb alternatíva az ISO 8601 formátumhoz.
  • DateTimeFormatter Androidon — szálbiztos formázó a java.time-ból API 26+-hoz. A LocalDate és a ZonedDateTime a fő osztályok a dátumokkal való munkához.
  • ThreeTenABP — egységes API az összes Android verzióhoz. Adja hozzá a visszafelé kompatibilitáshoz API 21-25-tel. A kód nem különbözik a java.time-tól.
  • TimeZone és UTC — tárolja az időt UTC-ben, csak megjelenítéshez konvertálja helyi időzónába. Használjon IANA azonosítókat.
  • Unix Timestamp — univerzális formátum az idő cseréjére szerver és kliens között. Kérje le a Date().timeIntervalSince1970 segítségével iOS-en.
  • NTP szinkronizálás — ezredmásodperces időpontosságot garantál. A TrueTime (iOS) és az AndroidNtp (Android) a szabványos könyvtárak.

Kulcsrakész mobilalkalmazást fejlesztünk

Az IT Sectr 2017 óta készít iOS és Android alkalmazásokat induló vállalkozásoknak és vállalkozásoknak. Tanácsot adunk, és a legjobb megoldást javasoljuk.

Projekt megbeszélése