¿Cómo persistes datos localmente en Flutter?

Question

Accepted Answer

Las aplicaciones a menudo necesitan **almacenar datos localmente** en el dispositivo — preferencias del usuario, datos en caché, contenido sin conexión. Flutter ofrece varias opciones — **shared_preferences** (clave-valor), **SQLite** (relacional), y otras — cada una adecuada para necesidades diferentes.

## Opciones de almacenamiento 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)
```

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

## Elegir la opción correcta

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

## Por qué es importante

Comprender cómo persistir datos localmente es valioso porque **las aplicaciones comúnmente necesitan almacenar datos en el dispositivo** — preferencias del usuario, datos en caché, contenido sin conexión, tokens de autenticación — por lo que es conocimiento práctico útil para construir aplicaciones reales.

La persistencia local es una necesidad casi universal (recordar configuraciones, almacenar en caché para uso sin conexión, guardar datos de sesión), y Flutter ofrece varias opciones adecuadas para necesidades diferentes.

Comprender las **opciones** — **shared_preferences** (almacenamiento simple de clave-valor para configuraciones, banderas, y datos pequeños), **SQLite/sqflite** (una base de datos relacional completa para datos estructurados más grandes con consultas y relaciones), **Hive/Isar** (bases de datos NoSQL nativas de Dart rápidas y populares para datos locales estructurados), almacenamiento de archivos, y **almacenamiento seguro** (`flutter_secure_storage` para datos sensibles) — y **cuándo usar cada una** es el conocimiento clave.

Elegir la **opción correcta** importa: shared_preferences para configuraciones simples, SQLite o Hive/Isar para datos estructurados/grandes, almacenamiento de archivos para archivos, y crucialmente **almacenamiento seguro para datos sensibles** como tokens y credenciales (que deben estar encriptados a través del llavero/keystore de la plataforma — un punto de seguridad importante, ya que **shared_preferences no es seguro y no debe almacenar secretos**, un error común).

Alinear el almacenamiento con el tamaño, estructura y sensibilidad de los datos refleja decisiones sólidas y evita problemas (como usar la herramienta incorrecta para el trabajo o almacenar credenciales de forma insegura).

Ya que las aplicaciones comúnmente necesitan persistencia local (configuraciones, almacenamiento en caché, datos sin conexión, tokens) y Flutter ofrece varias opciones para necesidades diferentes, y ya que comprenderlas y elegir apropiadamente (especialmente usar almacenamiento seguro para datos sensibles) es valioso para construir aplicaciones reales correctamente, entender la persistencia de datos locales en Flutter es conocimiento valioso y prácticamente relevante — una necesidad común en aplicaciones reales, importante tanto para funcionalidad (almacenar los datos correctos de la forma correcta) como para seguridad (proteger datos sensibles con almacenamiento seguro), y una habilidad útil para construir aplicaciones que recuerden estado y funcionen sin conexión.