Hvordan persisterer du data lokalt i Flutter?

Question

Accepted Answer

Apps har ofte brug for at **gemme data lokalt** på enheden — brugerindstillinger, cachelagrede data, offline-indhold. Flutter tilbyder flere muligheder — **shared_preferences** (nøgle-værdi), **SQLite** (relationelt), og andre — hver egnet til forskellige behov.

## Lokale lagringsmuligheder

```text
SHARED_PREFERENCES → simple KEY-VALUE storage (settings, flags, small data):
  → store primitives (strings, ints, bools) — like a simple persistent map
  → for: user preferences, tokens, simple flags (NOT large/structured data)
SQLITE (sqflite) → a full relational DATABASE on the device:
  → tables, SQL queries — for STRUCTURED, larger data; complex queries; relationships
HIVE / ISAR → fast NoSQL local databases (key-value/object stores) — popular, fast,
  Dart-native (no SQL); good for structured local data
FILE storage → read/write files directly (path_provider for directories)
SECURE storage → flutter_secure_storage for SENSITIVE data (tokens, credentials) —
  encrypted (keychain/keystore)
```

## shared_preferences eksempel

```dart
final prefs = await SharedPreferences.getInstance();
await prefs.setString('username', 'Ann');      // store
final name = prefs.getString('username');        // retrieve
await prefs.setBool('darkMode', true);
```

## Valg af den rigtige mulighed

```text
Simple settings/flags → shared_preferences (easy key-value)
Structured/large data, queries → SQLite (sqflite) or Hive/Isar
Sensitive data (tokens, passwords) → flutter_secure_storage (ENCRYPTED — don't put
  secrets in shared_preferences, which is NOT secure)
Files → file storage (path_provider)
→ Match the storage to the data's size, structure, and sensitivity.
```

## Hvorfor det betyder noget

At forstå, hvordan man persisterer data lokalt, er værdifuldt, fordi **apps almindeligvis har brug for at gemme data på enheden** — brugerindstillinger, cachelagrede data, offline-indhold, autentificeringstokens — så det er praktisk og nyttig viden til at bygge rigtige apps.

Lokal persistering er et næsten universelt behov (at huske indstillinger, caching til offline-brug, lagring af sessionsdata), og Flutter tilbyder flere muligheder, der er egnet til forskellige behov.

At forstå **mulighederne** — **shared_preferences** (enkelt nøgle-værdi-lagring til indstillinger, flag og små data), **SQLite/sqflite** (en komplet relationel database til strukturerede, større data med queries og relationer), **Hive/Isar** (hurtige Dart-native NoSQL-databaser, der er populære til strukturerede lokale data), fillager, og **sikker lagring** (`flutter_secure_storage` til følsomme data) — og **hvornår man bruger hver enkelt** er den vigtigste viden.

Valg af **den rigtige mulighed** betyder noget: shared_preferences til enkle indstillinger, SQLite eller Hive/Isar til strukturerede/store data, fillager til filer, og især **sikker lagring til følsomme data** som tokens og credentials (som skal være krypterede via platformens nøglering/keystore — et vigtigt sikkerhedspunkt, da **shared_preferences ikke er sikker og bør ikke indeholde hemmeligheder**, en almindelig fejl).

At matche lagringen til dataenes størrelse, struktur og følsomhed afspejler fornuftige beslutninger og undgår problemer (som at bruge det forkerte værktøj til jobbet eller usikkert at gemme credentials).

Da apps almindeligvis har brug for lokal persistering (indstillinger, caching, offline data, tokens) og Flutter tilbyder flere muligheder til forskellige behov, og da det at forstå dem og vælge passende (især ved at bruge sikker lagring til følsomme data) er værdifuldt for at bygge rigtige apps korrekt, er det at forstå lokal datapersistering i Flutter værdifuld, praktisk-relevant viden — et almindeligt behov i rigtige apps, vigtig både for funktionalitet (at gemme de rigtige data på den rigtige måde) og sikkerhed (at beskytte følsomme data med sikker lagring), og en nyttig færdighed til at bygge apps, der husker tilstand og fungerer offline.