# Erklärung `fibonacci`-Funktion

## Wie funktioniert `fibonacci(4)`?

Bei der Rekursion verzweigt sich die Funktion wie ein Baum, weil in jedem Schritt _zwei_ neue Aufrufe gestartet werden: `fibonacci(n - 1)` und `fibonacci(n - 2)`. JavaScript arbeitet diesen Baum von **oben nach unten** und von **links nach rechts** ab.

### Der Ablauf Schritt für Schritt

Hier ist die exakte Reihenfolge, wie JavaScript die Funktionen aufruft und auflöst:

1. **`fibonacci(4)`** wird aufgerufen.

- Da $n > 1$, will die Funktion `fibonacci(3) + fibonacci(2)` rechnen. Sie muss aber **zuerst** den linken Teil (`fibonacci(3)`) komplett berechnen.

2. **`fibonacci(3)`** wird aufgerufen.

- Will `fibonacci(2) + fibonacci(1)` rechnen. Wartet auf den linken Teil (`fibonacci(2)`).

3. **`fibonacci(2)`** wird aufgerufen.

- Will `fibonacci(1) + fibonacci(0)` rechnen. Wartet auf links (`fibonacci(1)`).

4. **`fibonacci(1)`** wird aufgerufen.

- **Base Case greift!** Gibt **`1`** zurück.

5. Zurück bei `fibonacci(2)`: Der linke Teil ist bereit (`1`). Jetzt wird der rechte Teil (`fibonacci(0)`) aufgerufen.
6. **`fibonacci(0)`** wird aufgerufen.

- **Base Case greift!** Gibt **`0`** zurück.

7. **`fibonacci(2)` wird aufgelöst:** Rechnet `1 + 0` und gibt **`1`** zurück an `fibonacci(3)`.
8. Zurück bei `fibonacci(3)`: Der linke Teil ist bereit (`1`). Jetzt wird der rechte Teil (`fibonacci(1)`) aufgerufen.
9. **`fibonacci(1)`** wird aufgerufen.

- **Base Case greift!** Gibt **`1`** zurück.

10. **`fibonacci(3)` wird aufgelöst:** Rechnet `1 + 1` (Ergebnis aus Schritt 7 + Schritt 9) und gibt **`2`** zurück an `fibonacci(4)`.
11. Zurück bei `fibonacci(4)`: Der linke Teil (`fibonacci(3)`) ist endlich fertig und hat den Wert `2`. Jetzt wird der komplette rechte Ast (**`fibonacci(2)`**) berechnet.
12. **`fibonacci(2)`** wird aufgerufen (für die rechte Seite von `fibonacci(4)`).

- Ruft intern wieder `fibonacci(1)` (gibt `1`) und `fibonacci(0)` (gibt `0`) auf.
- Rechnet `1 + 0` und gibt **`1`** zurück.

13. **`fibonacci(4)` wird final aufgelöst:** \* Rechnet das Ergebnis von links (`2`) + das Ergebnis von rechts (`1`).

- **Endergebnis: `3**`.

---

## Die Schritte mit `console.log` sichtbar machen

Ja, das kann man wunderbar mit `console.log` sichtbar machen! Am besten fügt man eine Einrückung (`indent`) hinzu, die sich mit jeder Ebene vertieft. So sieht man direkt die "Baumstruktur" in der Konsole.

Hier ist der modifizierte Code:

```javascript
const fibonacciMitLog = (n, ebene = 0) => {
  // Erzeugt Leerzeichen für die visuelle Einrückung in der Konsole
  const einrückung = '  '.repeat(ebene);

  console.log(`${einrückung}▶️ Rufe fibonacci(${n}) auf`);

  // Base cases
  if (n === 0) {
    console.log(`${einrückung}↩️ Base Case: fibonacci(0) gibt 0 zurück`);
    return 0;
  }

  if (n === 1) {
    console.log(`${einrückung}↩️ Base Case: fibonacci(1) gibt 1 zurück`);
    return 1;
  }

  // Rekursive Aufrufe
  console.log(`${einrückung}⏳ Berechne links: fibonacci(${n - 1})`);
  const links = fibonacciMitLog(n - 1, ebene + 1);

  console.log(`${einrückung}⏳ Berechne rechts: fibonacci(${n - 2})`);
  const rechts = fibonacciMitLog(n - 2, ebene + 1);

  const ergebnis = links + rechts;
  console.log(`${einrückung}✅ fibonacci(${n}) fertig! ${links} + ${rechts} = ${ergebnis}`);

  return ergebnis;
};

// Testlauf
console.log('--- START DER BERECHNUNG ---');
fibonacciMitLog(4);
```

### Das Ergebnis in der Konsole:

Wenn du diesen Code ausführst, siehst du exakt, wie JavaScript durch die Ebenen wandert:

```text
--- START DER BERECHNUNG ---
▶️ Rufe fibonacci(4) auf
⏳ Berechne links: fibonacci(3)
  ▶️ Rufe fibonacci(3) auf
  ⏳ Berechne links: fibonacci(2)
    ▶️ Rufe fibonacci(2) auf
    ⏳ Berechne links: fibonacci(1)
      ▶️ Rufe fibonacci(1) auf
      ↩️ Base Case: fibonacci(1) gibt 1 zurück
    ⏳ Berechne rechts: fibonacci(0)
      ▶️ Rufe fibonacci(0) auf
      ↩️ Base Case: fibonacci(0) gibt 0 zurück
    ✅ fibonacci(2) fertig! 1 + 0 = 1
  ⏳ Berechne rechts: fibonacci(1)
    ▶️ Rufe fibonacci(1) auf
    ↩️ Base Case: fibonacci(1) gibt 1 zurück
  ✅ fibonacci(3) fertig! 1 + 1 = 2
⏳ Berechne rechts: fibonacci(2)
  ▶️ Rufe fibonacci(2) auf
  ⏳ Berechne links: fibonacci(1)
    ▶️ Rufe fibonacci(1) auf
    ↩️ Base Case: fibonacci(1) gibt 1 zurück
  ⏳ Berechne rechts: fibonacci(0)
    ▶️ Rufe fibonacci(0) auf
    ↩️ Base Case: fibonacci(0) gibt 0 zurück
  ✅ fibonacci(2) fertig! 1 + 0 = 1
✅ fibonacci(4) fertig! 2 + 1 = 3

```
