Kapitel 4: Variablen, Konstanten, Datentypen

4.1 Variablendefinition, Namensregeln

Was sind Variablen?

Variablen sind Container für Daten. In PHP beginnen alle Variablen mit einem Dollarzeichen $.

<?php
    // Variablen definieren (mit $ beginnen)
    $name = "Max";
    $alter = 25;
    $ist_aktiv = true;
    
    // Ausgabe
    echo $name;        // Max
    echo $alter;       // 25
    echo $ist_aktiv;   // 1 (true wird als 1 ausgegeben)
?>

Namensregeln für Variablen

Regel	Beispiel	Gültig?
Muss mit $ beginnen	$name	✅
Erstes Zeichen nach $ muss Buchstabe oder _ sein	$_name, $name1	✅
Darf keine Leerzeichen enthalten	$mein name	❌
Unterscheidet Gross-/Kleinschreibung	$name vs $Name	Verschiedene Variablen
Darf keine Zahlen am Anfang haben	$1name	❌
Reservierte Wörter erlaubt (aber nicht empfohlen)	$if, $else	⚠️ Möglich, aber verwirrend

Gute Praxis:

<?php
    $name = "Max";           // Kleinschreibung für einfache Variablen
    $alter = 25;
    $_interne_variable = 10; // Unterstrich am Anfang für interne Variablen
    $berechnungErgebnis = 0; // CamelCase für längere Namen
?>

Variable Variablen (variabler Variablenname)

<?php
    $name = "hallo";
    $$name = "Welt";  // Entspricht: $hallo = "Welt";
    
    echo $hallo;  // Welt
    
    // Noch ein Beispiel
    $foo = "bar";
    $$foo = "baz";  // Entspricht: $bar = "baz";
    
    echo $bar;  // baz
?>

Vordefinierte Variablen (Superglobals)

PHP hat viele eingebaute Variablen, die überall verfügbar sind:

Variable	Beschreibung
$_GET	Daten aus URL-Parametern (GET)
$_POST	Daten aus Formularen (POST)
$_REQUEST	Daten aus GET, POST und COOKIE
$_SESSION	Session-Daten
$_COOKIE	Cookie-Daten
$_SERVER	Server-Informationen
$_FILES	Hochgeladene Dateien
$GLOBALS	Alle globalen Variablen

4.2 Konstanten: define() / const

Was sind Konstanten?

Konstanten sind Werte, die einmal definiert werden und nicht mehr geändert werden können.

define() (klassische Methode)

<?php
    // Konstante definieren mit define()
    define("SITENAME", "Meine Webseite");
    define("VERSION", "1.0.0");
    define("MAX_BENUTZER", 100);
    
    // Verwendung (ohne $!)
    echo SITENAME;      // Meine Webseite
    echo VERSION;       // 1.0.0
    echo MAX_BENUTZER; // 100
    
    // Konstante kann nicht geändert werden!
    // SITENAME = "Neuer Name";  // FEHLER!
?>

const (modernere Methode, empfohlen)

<?php
    // Konstante definieren mit const
    const SITENAME = "Meine Webseite";
    const VERSION = "1.0.0";
    const MAX_BENUTZER = 100;
    
    // Verwendung
    echo SITENAME;
    
    // Unterschied: const kann nur auf Klassenebene oder global verwendet werden
    // define() kann auch innerhalb von Funktionen verwendet werden
?>

Unterschied zwischen define() und const

Merkmal	define()	const
Kann in Funktionen verwendet werden	✅ Ja	❌ Nein
Kann bedingt definiert werden	✅ Ja	❌ Nein
Performance	Etwas langsamer	Etwas schneller
Empfehlung	⚠️ Für dynamische Definitionen	✅ Standard

Konstanten-Best Practices

<?php
    // Grosschreibung für Konstanten (Konvention)
    define("DB_HOST", "localhost");
    define("DB_USER", "root");
    define("DB_PASS", "");
    define("DB_NAME", "meine_datenbank");
    
    // Verwendung
    $conn = mysqli_connect(DB_HOST, DB_USER, DB_PASS, DB_NAME);
    
    // Vordefinierte Konstanten von PHP
    echo PHP_VERSION;    // PHP-Version
    echo PHP_OS;         // Betriebssystem
    echo PHP_EOL;        // Zeilenumbruch (plattformunabhängig)
    echo DIRECTORY_SEPARATOR; // Ordner-Trennzeichen (Windows: \, Linux: /)
?>

4.3 Datentypen: String, Integer, Float, Boolean, Array, Null

Übersicht der Datentypen

Datentyp	Beschreibung	Beispiel
String	Zeichenkette	"Hallo", 'Welt'
Integer	Ganzzahl	42, -10, 0
Float	Gleitkommazahl	3.14, -2.5, 1.5e3
Boolean	Wahrheitswert	true, false
Array	Array (Liste)	[1, 2, 3], array("a", "b")
Object	Objekt (Klasseninstanz)	new stdClass()
Null	Kein Wert	null
Resource	Ressource (z.B. Datenbankverbindung)	mysqli_connect()

String (Zeichenkette)

<?php
    // Strings mit einfachen Anführungszeichen (Single Quotes)
    $name1 = 'Max';
    $text1 = 'Hallo $name1';  // $name1 wird NICHT ersetzt!
    echo $text1;  // Hallo $name1
    
    // Strings mit doppelten Anführungszeichen (Double Quotes)
    $name2 = "Max";
    $text2 = "Hallo $name2";  // $name2 wird ersetzt!
    echo $text2;  // Hallo Max
    
    // Escape-Sequenzen
    $text3 = "Er sagte: \"Hallo!\"\nDas ist eine neue Zeile.";
    $text4 = 'Er sagte: "Hallo!"\nDas ist KEIN Zeilenumbruch.';
    
    // String-Verknüpfung (Punkt-Operator)
    $vorname = "Max";
    $nachname = "Müller";
    $voller_name = $vorname . " " . $nachname;  // Max Müller
    
    // Heredoc-Syntax (für mehrzeilige Strings)
    $text5 = <<<EOT
Dies ist ein langer Text
mit mehreren Zeilen.
Name: $name2
EOT;
    
    // Nowdoc-Syntax (wie Heredoc, aber ohne Variablenersetzung)
    $text6 = <<<'EOT'
Dies ist ein Text
mit $name2 (wird nicht ersetzt)
EOT;
?>

Integer (Ganzzahl)

<?php
    $ganzzahl1 = 42;
    $ganzzahl2 = -10;
    $ganzzahl3 = 0;
    
    // Verschiedene Zahlensysteme
    $dezimal = 42;       // Dezimal (Basis 10)
    $oktal = 052;         // Oktal (Basis 8) = 42 dezimal
    $hexadezimal = 0x2A; // Hexadezimal (Basis 16) = 42 dezimal
    $binär = 0b101010;   // Binär (Basis 2) = 42 dezimal
    
    // Ganzzahl-Operationen
    $summe = 10 + 20;     // 30
    $differenz = 20 - 5;  // 15
    $produkt = 4 * 7;     // 28
    $quotient = 20 / 4;   // 5 (Ergebnis ist Integer, wenn teilbar)
    $rest = 20 % 3;       // 2 (Modulo)
?>

Float (Gleitkommazahl)

<?php
    $float1 = 3.14;
    $float2 = -2.5;
    $float3 = 1.5e3;    // 1500 (Exponentialschreibweise)
    $float4 = 2.5E-2;   // 0.025
    
    // Achtung bei Vergleichen!
    $a = 0.1 + 0.2;
    $b = 0.3;
    var_dump($a == $b);  // false (wegen Rundungsfehlern!)
    
    // Richtiger Vergleich bei Floats
    var_dump(abs($a - $b) < 0.00001);  // true
?>

Boolean (Wahrheitswert)

<?php
    $wahr = true;
    $falsch = false;
    
    // Ausgabe
    echo $wahr;   // 1
    echo $falsch; // (nichts, leer)
    
    // Bedingungen
    if (true) {
        echo "Das wird ausgeführt";
    }
    
    if (false) {
        echo "Das wird NICHT ausgeführt";
    }
    
    // Werte, die als false interpretiert werden:
    // false, 0, 0.0, "", "0", null, [], $var (undefiniert)
?>

Array (Array)

<?php
    // Index-Array (numerischer Index)
    $fruechte = array("Apfel", "Banane", "Kirsche");
    // Oder kurz (ab PHP 5.4):
    $fruechte = ["Apfel", "Banane", "Kirsche"];
    
    echo $fruechte[0];  // Apfel
    echo $fruechte[1];  // Banane
    
    // Assoziatives Array (String-Index)
    $person = array(
        "name" => "Max",
        "alter" => 25,
        "stadt" => "Berlin"
    );
    // Oder kurz:
    $person = [
        "name" => "Max",
        "alter" => 25,
        "stadt" => "Berlin"
    ];
    
    echo $person["name"];   // Max
    echo $person["alter"];  // 25
    
    // Mehrdimensionale Arrays
    $schueler = [
        ["name" => "Max", "note" => 1.0],
        ["name" => "Anna", "note" => 1.3],
        ["name" => "Tim", "note" => 2.0]
    ];
    
    echo $schueler[0]["name"];  // Max
?>

Null

<?php
    $var1 = null;
    $var2 = NULL;  // Gross-/Kleinschreibung egal
    
    // Überprüfen, ob eine Variable null ist
    var_dump(is_null($var1));  // true
    
    // Überprüfen, ob eine Variable gesetzt ist
    var_dump(isset($var1));   // false
    
    $var3 = "";
    var_dump(isset($var3));   // true (leerer String ist gesetzt)
    var_dump(is_null($var3));  // false
?>

4.4 Typen bestimmen und Typumwandlung

Typ bestimmen mit gettype() und var_dump()

<?php
    $var1 = "Hallo";
    $var2 = 42;
    $var3 = 3.14;
    $var4 = true;
    $var5 = [1, 2, 3];
    $var6 = null;
    
    echo gettype($var1);  // string
    echo gettype($var2);  // integer
    echo gettype($var3);  // double (float wird als double bezeichnet)
    echo gettype($var4);  // boolean
    echo gettype($var5);  // array
    echo gettype($var6);  // NULL
    
    // Detailliertere Informationen mit var_dump()
    var_dump($var1);  // string(5) "Hallo"
    var_dump($var2);  // int(42)
?>

Typüberprüfung mit is_*() Funktionen

<?php
    $var = "42";
    
    var_dump(is_string($var));   // true
    var_dump(is_int($var));      // false
    var_dump(is_numeric($var));  // true (da "42" eine Zahl ist)
    
    $var2 = 42;
    var_dump(is_string($var2));  // false
    var_dump(is_int($var2));     // true
    
    // Weitere is_*() Funktionen:
    // is_float(), is_bool(), is_array(), is_null(), is_object(), is_resource()
?>

Typumwandlung (Type Casting)

<?php
    // Explizite Typumwandlung
    $var = "42";
    
    $int_var = (int) $var;      // 42 (Integer)
    $float_var = (float) $var;  // 42.0 (Float)
    $string_var = (string) 42;  // "42" (String)
    $bool_var = (bool) 42;      // true (Boolean)
    $array_var = (array) 42;    // [42] (Array)
    
    // Auch möglich:
    $int_var = intval($var);    // 42
    $float_var = floatval($var); // 42.0
    $string_var = strval(42);    // "42"
    
    // In Integer umwandeln (mit Fehlerbehandlung)
    $var2 = "42a";
    $int_var2 = (int) $var2;    // 42 (Achtung: stiller Fehler!)
    $int_var3 = intval($var2);   // 42
?>

Lose Typüberprüfung vs. Strenge Typüberprüfung

<?php
    // Lose Typüberprüfung (==)
    var_dump(42 == "42");     // true (Typ wird automatisch umgewandelt)
    var_dump(42 == 42.0);    // true
    var_dump(42 == true);     // true (42 wird als true interpretiert)
    
    // Strenge Typüberprüfung (===)
    var_dump(42 === "42");    // false (Typ ist unterschiedlich)
    var_dump(42 === 42.0);   // false
    var_dump(42 === true);    // false
    
    // Empfehlung: Immer === verwenden, um unerwartete Fehler zu vermeiden!
?>

4.5 Praxis: Variablenoperationen und Datentypumwandlung

Aufgabe: Schreiben Sie ein Skript, das Benutzereingaben verarbeitet und Typen sicher umwandelt.

<?php
    // Simulierte Benutzereingaben (aus einem Formular)
    $benutzer_alter = "25";       // String aus Formular
    $benutzer_gehalt = "3500.50"; // String aus Formular
    $benutzer_aktiv = "1";       // String aus Formular
    
    // Typumwandlung für sichere Verarbeitung
    $alter = (int) $benutzer_alter;        // In Integer umwandeln
    $gehalt = (float) $benutzer_gehalt;    // In Float umwandeln
    $ist_aktiv = (bool) $benutzer_aktiv;   // In Boolean umwandeln
    
    // Berechnungen
    $gehalt_nach_erhoehung = $gehalt * 1.05;  // 5% Erhöhung
    $geburtsjahr = date("Y") - $alter;
    
    // Ausgabe
    echo "<h2>Benutzerinformationen:</h2>";
    echo "Alter: " . $alter . " Jahre<br>";
    echo "Gehalt: " . number_format($gehalt, 2, ',', '.') . " €<br>";
    echo "Aktiv: " . ($ist_aktiv ? "Ja" : "Nein") . "<br>";
    echo "Geburtsjahr (Schätzung): " . $geburtsjahr . "<br>";
    echo "Gehalt nach Erhöhung: " . number_format($gehalt_nach_erhoehung, 2, ',', '.') . " €<br>";
    
    // Typüberprüfung
    echo "<hr>";
    echo "<h3>Typüberprüfung:</h3>";
    echo "Typ von \$alter: " . gettype($alter) . "<br>";
    echo "Typ von \$gehalt: " . gettype($gehalt) . "<br>";
    echo "Typ von \$ist_aktiv: " . gettype($ist_aktiv) . "<br>";
    
    // Fehlerbehandlung bei ungültigen Eingaben
    $ungueltiges_alter = "abc";
    $alternativ_alter = (int) $ungueltiges_alter;  // 0 (Achtung!)
    
    if ($alternativ_alter === 0 && !is_numeric($ungueltiges_alter)) {
        echo "<p style='color: red;'>Fehler: Ungültiges Alter eingegeben!</p>";
    }
?>

Zusammenfassung

In diesem Kapitel haben Sie:

• ✅ Variablen definiert und Namensregeln gelernt
• ✅ Konstanten mit define() und const erstellt
• ✅ Alle wichtigen Datentypen (String, Integer, Float, Boolean, Array, Null) kennengelernt
• ✅ Typen bestimmt und umgewandelt
• ✅ Praktische Übungen zur Variablenverarbeitung gemacht

Nächstes Kapitel: Wir werden Operatoren und Ausdrücke lernen.

---

Übungsaufgaben:

1. Erstellen Sie Variablen für einen Benutzer (Name, Alter, E-Mail) und geben Sie sie aus
2. Definieren Sie Konstanten für Datenbank-Zugangsdaten
3. Experimentieren Sie mit verschiedenen String-Syntaxen (Single Quotes vs. Double Quotes)
4. Schreiben Sie ein Skript, das den Datentyp einer Variablen überprüft und ausgibt

Häufige Fehler:

• ❌ $variable ohne $ verwenden → Immer $ vor Variablennamen
• ❌ Konstante mit $ verwenden → Konstanten haben keinen $ davor
• ❌ == statt === verwenden → Immer striktes === bevorzugen
• ❌ Strings mit . verknüpfen, aber + verwenden → In PHP ist . der Verknüpfungsoperator