Comment persister les données localement dans Flutter?

Question

Accepted Answer

Les applications ont souvent besoin de **stocker des données localement** sur l'appareil — préférences utilisateur, données en cache, contenu hors ligne. Flutter offre plusieurs options — **shared_preferences** (clé-valeur), **SQLite** (relationnel), et autres — chacune adaptée à des besoins différents.

## Options de stockage local

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

## Exemple 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);
```

## Choisir la bonne option

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

## Pourquoi c'est important

Comprendre comment persister les données localement est précieux car **les applications ont couramment besoin de stocker des données sur l'appareil** — préférences utilisateur, données en cache, contenu hors ligne, jetons d'authentification — c'est donc une connaissance pratique utile pour construire des applications réelles.

La persistance locale est un besoin quasi universel (mémoriser les paramètres, mettre en cache pour une utilisation hors ligne, stocker les données de session), et Flutter offre plusieurs options adaptées à différents besoins.

Comprendre les **options** — **shared_preferences** (stockage clé-valeur simple pour les paramètres, drapeaux et petites données), **SQLite/sqflite** (une base de données relationnelle complète pour les données structurées, plus volumineuses, avec requêtes et relations), **Hive/Isar** (bases de données NoSQL natives Dart rapides et populaires pour les données locales structurées), stockage de fichiers, et **stockage sécurisé** (`flutter_secure_storage` pour les données sensibles) — et **quand utiliser chacun** est la connaissance clé.

Choisir la **bonne option** importe : shared_preferences pour les paramètres simples, SQLite ou Hive/Isar pour les données structurées/volumineuses, stockage de fichiers pour les fichiers, et crucifialement **stockage sécurisé pour les données sensibles** comme les jetons et identifiants (qui doivent être chiffrés via le trousseau/magasin de clés de la plateforme — un point de sécurité important, puisque **shared_preferences n'est pas sécurisé et ne doit pas contenir de secrets**, une erreur courante).

Adapter le stockage à la taille, la structure et la sensibilité des données reflète des décisions saines et évite les problèmes (comme utiliser le mauvais outil pour la tâche ou stocker les identifiants de manière non sécurisée).

Puisque les applications ont couramment besoin de persistance locale (paramètres, mise en cache, données hors ligne, jetons) et Flutter offre plusieurs options pour différents besoins, et puisque les comprendre et choisir de manière appropriée (en particulier utiliser le stockage sécurisé pour les données sensibles) est précieux pour construire les applications correctement, comprendre la persistance des données locales dans Flutter est une connaissance précieuse et pratiquement pertinente — un besoin courant dans les applications réelles, important à la fois pour la fonctionnalité (stocker les bonnes données de la bonne manière) et la sécurité (protéger les données sensibles avec le stockage sécurisé), et une compétence utile pour construire des applications qui mémorisent l'état et fonctionnent hors ligne.