Hur sparar du data lokalt i Flutter?

Question

Accepted Answer

Appar behöver ofta **lagra data lokalt** på enheten — användarinställningar, cachad data, offline-innehål. Flutter erbjuder flera alternativ — **shared_preferences** (nyckel-värde), **SQLite** (relationell) och andra — var och en lämplig för olika behov.

## Alternativ för lokal lagring

```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)
```

## Exempel med shared_preferences

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

## Att välja rätt alternativ

```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.
```

## Varför det är viktigt

Att förstå hur man sparar data lokalt är värdefullt eftersom **appar ofta behöver lagra data på enheten** — användarinställningar, cachad data, offline-innehål, autentiseringstoken — så det är praktisk kunskap som är användbar för att bygga verkliga appar.

Lokal persistens är ett nästan universellt behov (att komma ihåg inställningar, caching för offline-användning, lagring av sessiondata), och Flutter erbjuder flera alternativ lämpade för olika behov.

Att förstå **alternativen** — **shared_preferences** (enkel nyckel-värde-lagring för inställningar, flaggor och små data), **SQLite/sqflite** (en fullständig relationell databas för strukturerad, större data med frågor och relationer), **Hive/Isar** (snabba Dart-interna NoSQL-databaser populära för strukturerad lokal data), fillagring och **säker lagring** (`flutter_secure_storage` för känslig data) — och **när man ska använda varje alternativ** är nyckelpunkten.

Att välja **rätt alternativ** är viktigt: shared_preferences för enkla inställningar, SQLite eller Hive/Isar för strukturerad/stor data, fillagring för filer, och avgörande **säker lagring för känslig data** som token och autentiseringsuppgifter (som måste krypteras via plattformens keychain/keystore — en viktig säkerhetspunkt, eftersom **shared_preferences inte är säker och bör inte innehålla hemligheter**, ett vanligt misstag).

Att matcha lagringen till datas storlek, struktur och känslighet reflekterar klokt tänkande och undviker problem (som att använda fel verktyg för jobbet eller osäker lagring av autentiseringsuppgifter).

Eftersom appar ofta behöver lokal persistens (inställningar, caching, offline-data, token) och Flutter erbjuder flera alternativ för olika behov, och eftersom att förstå dem och välja lämpligt (speciellt att använda säker lagring för känslig data) är värdefullt för att bygga verkliga appar korrekt, är förståelse för lokal datapersistens i Flutter värdeful, praktiskt relevant kunskap — ett vanligt behov i verkliga appar, viktigt för både funktionalitet (lagring av rätt data på rätt sätt) och säkerhet (skydd av känslig data med säker lagring), och en användbar färdighet för att bygga appar som kommer ihåg tillstånd och fungerar offline.