Variable

Datentypen: Kisten haben Formen. In eine Eier-Kiste passen keine Melonen.

• Integer (Ganzzahl): 1, 42, -5.
• String (Text): "Hallo".
• Boolean (Wahrheit): true / false.

Deklaration:

• Python: name = "Max" (Kistentyp wird automatisch erkannt -> Dynamic Typing).
• Java: String name = "Max"; (Du musst den Typ auf die Kiste schreiben -> Static Typing).

1. Scope (Gültigkeitsbereich)

Wo ist die Kiste sichtbar?

• Local Scope: Variable in einer Funktion (def func(): x=5). Nur in der Funktion bekannt. Danach wird die Kiste verbrannt (Garbage Collection).
• Global Scope: Ganz oben im Programm. Überall sichtbar.
• Closure: Eine Funktion merkt sich Variablen aus ihrer Umgebung, auch wenn diese Umgebung schon weg ist (Magic!).

2. Stack vs. Heap

• Stack: Für kleine, schnelle Variablen (Zahlen, Booleans). Werden extrem effizient verwaltet (LIFO).
• Heap: Für große Objekte (User-Listen, Bilder). Langsamer, braucht Garbage Collector zum Aufräumen.
• Pointer/Referenz: Die Variable enthält nicht das Objekt selbst, sondern nur einen Zettel mit der Adresse im Heap ("Das Bild liegt in Regal 500").

3. Environment Variables

Variablen, die nicht im Code stehen, sondern vom Betriebssystem kommen. DB_PASSWORD=secret123 ./my-app Wichtigste Regel in DevOps (12-Factor App): Speichere niemals Passwörter im Code (Variable), sondern injiziere sie von außen als Environment Variable.

1. Pass-by-Value vs. Pass-by-Reference

Was passiert, wenn du eine Variable an eine Funktion übergibst?

• Pass-by-Value: Der Computer macht eine echte Kopie der Kiste. Wenn die Funktion den Wert ändert, bleibt das Original draußen unverändert. (Meistens bei Zahlen/Booleans).
• Pass-by-Reference: Du übergibst nur den Schlüssel zur Kiste. Wenn die Funktion den Inhalt ändert, merken es alle anderen auch. (Meistens bei Listen/Objekten). Das ist die häufigste Quelle für schwer zu findende Bugs (Seiteneffekte), wenn man vergisst, dass man gerade das Original-Objekt manipuliert hat.

2. Der Speicher-Lebenszyklus (Stack vs. Heap)

Variablen leben an unterschiedlichen Orten im RAM.

• Stack (Der Kurzzeit-Stapel): Hier liegen lokale Variablen. Wenn die Funktion fertig ist, wird der "Stack Pointer" einfach verschoben – der Speicher ist sofort wieder frei. Das ist extrem schnell, aber der Stapel ist klein.
• Heap (Der große Haufen): Hier liegen große Datenmengen. Der Computer muss mühsam eine freie Lücke suchen. Wenn du die Variable nicht mehr brauchst, muss der Garbage Collector kommen und aufräumen. Wenn das nicht klappt, entsteht ein Memory Leak: Dein Programm belegt immer mehr RAM, bis der PC abstürzt.

3. Immutability (Unveränderlichkeit)

In modernen Sprachen (wie Rust oder funktionaler Programmierung) sind Variablen standardmäßig "eingefroren" (Immutable). Wenn du eine Variable x = 5 hast, darfst du sie nie wieder ändern. Wenn du 6 brauchst, musst du eine neue Variable y erstellen. Warum dieser Aufwand? In Programmen, die viele Dinge gleichzeitig tun (Parallelisierung/Threads), sind veränderbare globale Variablen die Hölle. Wenn zwei Programmteile gleichzeitig an derselben Kiste rütteln, kracht es (Race Condition). Unveränderliche Variablen eliminieren dieses Problem komplett.