Cum funcționează navigarea în Flutter?

Question

Accepted Answer

**Navigarea** în Flutter se referă la deplasarea între ecrane (pagini/rute) — folosind **Navigator** (o stivă de rute) pentru navigare de bază, sau pachete de rutare declarativă pentru aplicații mai complexe. Înțelegerea navigării este esențială pentru construirea aplicațiilor cu mai multe ecrane.

## Navigare de bază cu Navigator (o stivă)

```dart
// the Navigator manages a STACK of routes (screens)
// PUSH a new screen onto the stack (navigate to it)
Navigator.push(
  context,
  MaterialPageRoute(builder: (context) => SecondScreen()),
);

// POP — go back (remove the top screen, return to the previous)
Navigator.pop(context);
```

```text
Think of navigation as a STACK of screens:
  → PUSH adds a screen on top (navigate forward)
  → POP removes the top screen (go back)
  → the back button / gesture also pops
```

## Transmiterea datelor între ecrane

```dart
// pass data forward (via the constructor)
Navigator.push(context, MaterialPageRoute(
  builder: (context) => DetailScreen(itemId: 42),
));

// return data back when popping
Navigator.pop(context, result);          // return a result
final result = await Navigator.push(...); // receive it (push returns a Future)
```

## Rutele denumite și rutarea modernă

```dart
// NAMED routes — define routes by name (cleaner for many screens)
Navigator.pushNamed(context, '/details');
// configured in MaterialApp(routes: {...})

// MODERN: declarative routing packages (go_router) for complex apps:
//   → URL-based routing, deep linking, web support, nested navigation
//   → go_router is the recommended approach for non-trivial apps
```

## De ce conteaza

Înțelegerea navigării este esențială deoarece **majoritatea aplicațiilor au mai multe ecrane**, iar deplasarea între ele este fundamentală pentru funcționalitatea aplicației, deci este cunoștințe obligatorii în Flutter.

Conceptul principal — **Navigator din Flutter gestionând o stivă de rute** (ecrane), unde **push** pentru a naviga înainte (adăugând un ecran deasupra) și **pop** pentru a te întoarce (eliminând ecranul de sus) — este modelul mental fundamental pentru navigare, iar metafora stivei (corespunzând modului în care utilizatorii navighează înainte și înapoi printr-o aplicație) o face intuitivă.

Înțelegerea **navigării de bază** (push/pop) este necesară pentru orice aplicație cu mai multe ecrane.

Înțelegerea **transmiterii datelor între ecrane** (trimiterea datelor înainte prin constructori și returnarea rezultatelor la pop, deoarece push returnează un Future) este esențială deoarece ecranele au frecvent nevoie să partajeze date (transmiterea unui element la un ecran de detalii, returnarea unei selecții).

Înțelegerea **rutelor denumite** (definirea rutelor după nume pentru o organizare mai curată cu multe ecrane) și în special **rutarea declarativă modernă** (pachete precum **go_router**, care este recomandată pentru aplicații non-triviale, oferind rutare bazată pe URL, deep linking, suport web și navigare imbricată) reflectă practicile actuale — pe măsură ce aplicațiile cresc, rutarea declarativă gestionează mai bine complexitatea decât push/pop imperativ.

Deoarece practic toate aplicațiile au mai multe ecrane și navigarea între ele (cu transmiterea datelor) este fundamentală pentru funcționalitatea aplicației, și deoarece înțelegerea modelului de stivă Navigator, transmiterea datelor și rutarea modernă (go_router) este necesară pentru a construi aplicații cu mai multe ecrane, înțelegerea navigării în Flutter este cunoștințe esențiale și fundamentale — o capacitate de bază necesară în aproape fiecare aplicație Flutter și necesară pentru a construi experiențele multi-ecran pe care le necesită aplicațiile reale.