7 Variablen, Datentypen und Typumwandlung

<?php
// Variablen werden durch einfache Zuweisung erstellt
$name = "Max Mustermann";
$alter = 30;
$istAktiv = true;

// Ausgabe: "Max Mustermann ist 30 Jahre alt."
echo "$name ist $alter Jahre alt.";
?>

<?php
// Gültige Variablennamen
$name = "Max";
$_name = "Max";
$name1 = "Max";
$ersterName = "Max";  // CamelCase
$erster_name = "Max"; // Snake_case

// Ungültige Variablennamen
// $1name = "Max";    // Beginnt mit einer Zahl
// $name-1 = "Max";   // Enthält ein Bindestrich
// $name 1 = "Max";   // Enthält ein Leerzeichen
?>

<?php
$varName = "alter";
$$varName = 30;  // Erstellt die Variable $alter mit dem Wert 30

echo $alter;     // Gibt 30 aus
?>

<?php
// Globaler Scope
$globalVar = "Ich bin global";

function testScope() {
    // Lokaler Scope
    $localVar = "Ich bin lokal";
    
    // Auf globale Variablen zugreifen
    global $globalVar;
    echo $globalVar;  // "Ich bin global"
    
    // Alternative mit $GLOBALS-Array
    echo $GLOBALS['globalVar'];  // "Ich bin global"
}

testScope();
// echo $localVar;  // Fehler: Undefined variable
?>

<?php
function counter() {
    static $count = 0;
    return ++$count;
}

echo counter();  // 1
echo counter();  // 2
echo counter();  // 3
?>

<?php
$istWahr = true;
$istFalsch = false;

// Diese Werte werden als false ausgewertet:
$falseValues = [
    false,     // Boolean false
    0,         // Integer 0
    0.0,       // Float 0
    "",        // Leerer String
    "0",       // String "0"
    [],        // Leeres Array
    null       // Null
];

if ($istWahr) {
    echo "Bedingung ist wahr";
}
?>

<?php
$dezimal = 42;
$oktal = 052;       // Oktalzahl (führende 0): entspricht 42 dezimal
$hexadezimal = 0x2A; // Hexadezimalzahl (0x prefix): entspricht 42 dezimal
$binär = 0b101010;  // Binärzahl (0b prefix): entspricht 42 dezimal

// Maximaler und minimaler Wert (plattformabhängig)
echo PHP_INT_MAX;   // z.B. 9223372036854775807 (64-bit)
echo PHP_INT_MIN;   // z.B. -9223372036854775808 (64-bit)
?>

<?php
$a = 1.234;
$b = 1.2e3;      // 1.2 × 10^3 = 1200
$c = 7E-10;      // 7 × 10^-10 = 0.0000000007

// Achtung bei Genauigkeit
$x = 0.1 + 0.2;
var_dump($x == 0.3);  // bool(false), wegen Rundungsfehlern
echo $x;             // 0.3 (möglicherweise als 0.30000000000000004 gespeichert)
?>

<?php
// Einfache Anführungszeichen: Kein Parsing von Variablen
$name = 'Max';
$str1 = 'Hallo $name'; // Gibt "Hallo $name" aus

// Doppelte Anführungszeichen: Variables werden ersetzt
$str2 = "Hallo $name"; // Gibt "Hallo Max" aus

// Escape-Sequenzen
$str3 = "Erste Zeile\nZweite Zeile"; // Zeilenumbruch
$str4 = "Tab\tNach Tab";            // Tabulator
$str5 = "Er sagte: \"Hallo!\"";      // Zitat

// Heredoc-Syntax (mit Variablen-Parsing)
$str6 = <<<EOD
Dies ist ein mehrzeiliger String.
Er enthält den Namen: $name
EOD;

// Nowdoc-Syntax (kein Variablen-Parsing)
$str7 = <<<'EOD'
Dies ist ein mehrzeiliger String.
$name wird nicht ersetzt.
EOD;

// String-Zugriff und -Manipulation
echo $str2[0];                      // "H" (erster Buchstabe)
echo strlen($str2);                 // 9 (Länge des Strings)
echo strpos($str2, 'Max');          // 6 (Position von "Max")
?>

<?php
// Indiziertes Array (numerische Schlüssel)
$zahlen = [1, 2, 3, 4, 5];
echo $zahlen[0];          // 1 (erstes Element)

// Assoziatives Array (benutzerdefinierte Schlüssel)
$person = [
    'name' => 'Max Mustermann',
    'alter' => 30,
    'stadt' => 'Berlin'
];
echo $person['name'];     // "Max Mustermann"

// Mehrdimensionales Array
$mitarbeiter = [
    ['name' => 'Max', 'abteilung' => 'IT'],
    ['name' => 'Anna', 'abteilung' => 'HR']
];
echo $mitarbeiter[1]['name'];  // "Anna"

// Array-Funktionen
$anzahl = count($zahlen);      // 5 (Anzahl der Elemente)
$istEnthalten = in_array(3, $zahlen);  // true
$schlüssel = array_keys($person);  // ['name', 'alter', 'stadt']
$werte = array_values($person);    // ['Max Mustermann', 30, 'Berlin']
?>

<?php
// Standard-Objekt erstellen
$person = new stdClass();
$person->name = "Max Mustermann";
$person->alter = 30;
echo $person->name;  // "Max Mustermann"

// Objekt aus Array konvertieren
$array = ['name' => 'Anna', 'alter' => 25];
$obj = (object) $array;
echo $obj->name;     // "Anna"

// Klasse definieren und Objekt erstellen
class Benutzer {
    public $name;
    public $email;
    
    public function begrüßen() {
        return "Hallo " . $this->name;
    }
}

$benutzer = new Benutzer();
$benutzer->name = "Max";
echo $benutzer->begrüßen();  // "Hallo Max"
?>

<?php
$var = null;
var_dump($var);        // NULL
var_dump(is_null($var)); // bool(true)

// Überprüfen, ob eine Variable existiert oder NULL ist
var_dump(isset($var));  // bool(false)
unset($var);           // Variable löschen
?>

<?php
// Datei-Resource
$datei = fopen('daten.txt', 'r');
var_dump($datei);  // resource(4) of type (stream)
fclose($datei);

// Datenbankverbindung
$db = mysqli_connect('localhost', 'benutzer', 'passwort', 'datenbank');
var_dump($db);     // resource/object
mysqli_close($db);
?>

<?php
// Funktion als Callable
function grüßen($name) {
    return "Hallo $name";
}

// Anonyme Funktion (Closure)
$grußFunktion = function($name) {
    return "Hallo $name";
};

// Objekt-Methode als Callable
class Grüßer {
    public function grüßen($name) {
        return "Hallo $name";
    }
}
$obj = new Grüßer();

// Verwendung von Callables
function prozessName($name, callable $formatFunktion) {
    return $formatFunktion($name);
}

echo prozessName("Max", 'grüßen');  // "Hallo Max"
echo prozessName("Max", $grußFunktion);  // "Hallo Max"
echo prozessName("Max", [$obj, 'grüßen']);  // "Hallo Max"
?>

<?php
$var = "123";

// Typbestimmungsfunktionen
var_dump(is_string($var));   // bool(true)
var_dump(is_int($var));      // bool(false)
var_dump(is_float($var));    // bool(false)
var_dump(is_bool($var));     // bool(false)
var_dump(is_array($var));    // bool(false)
var_dump(is_object($var));   // bool(false)
var_dump(is_null($var));     // bool(false)
var_dump(is_resource($var)); // bool(false)
var_dump(is_callable($var)); // bool(false)

// Allgemeine Typinformation
var_dump($var);             // string(3) "123"
echo gettype($var);         // "string"
?>

<?php
$str = "42";
$num = 42;

// String und Integer werden verglichen
if ($str == $num) {
    echo "Gleich (mit ==)";  // Diese Zeile wird ausgegeben
}

// Erzwungener Typenvergleich
if ($str === $num) {
    echo "Identisch (mit ===)";  // Diese Zeile wird NICHT ausgegeben
}

// Implizite Umwandlung in numerische Operation
echo $str + 10;  // 52 (String wird zu Integer konvertiert)

// Implizite Umwandlung in String-Kontext
echo $num . " ist eine Zahl";  // "42 ist eine Zahl"
?>

<?php
$var = "42";

// Umwandlung in verschiedene Typen
$int = (int) $var;    // oder: intval($var)
$float = (float) $var; // oder: floatval($var)
$bool = (bool) $var;   // oder: boolval($var)
$string = (string) $num; // oder: strval($num)
$array = (array) $var;
$object = (object) $var;

// Beispiel für Umwandlungen
var_dump((int) "42");          // int(42)
var_dump((int) "42.7");        // int(42) - Dezimalteil wird abgeschnitten
var_dump((int) "text");        // int(0) - Nicht-numerischer Text wird zu 0
var_dump((float) "42.7");      // float(42.7)
var_dump((string) 42);         // string(2) "42"
var_dump((bool) "0");          // bool(false)
var_dump((bool) "false");      // bool(true) - Nicht-leerer String ist true
var_dump((array) "text");      // array(1) { [0]=> string(4) "text" }
?>

<?php
var_dump(0 == "0");       // bool(true)
var_dump(0 == "");        // bool(true)
var_dump(0 == false);     // bool(true)
var_dump("0" == false);   // bool(true)
var_dump(null == false);  // bool(true)
var_dump([] == false);    // bool(true)

// Identitätsoperator (===) vergleicht Wert UND Typ
var_dump(0 === "0");      // bool(false)
var_dump(0 === false);    // bool(false)
?>

<?php
// String zu Zahl
$int1 = intval("42");
$int2 = (int) "42";
$float1 = floatval("3.14");
$float2 = (float) "3.14";

// Zahl zu String
$str1 = strval(42);
$str2 = (string) 42;
$str3 = "" . 42;        // Konkatenation mit leerem String
$str4 = sprintf("%d", 42); // Formatierte Umwandlung

// Array-Konvertierungen
$arr1 = (array) "text";  // ['text']
$obj = new stdClass();
$obj->name = "Max";
$arr2 = (array) $obj;    // ['name' => 'Max']

// JSON-Konvertierungen (nützlich für komplexe Strukturen)
$json = json_encode(['name' => 'Max', 'alter' => 30]); // String: '{"name":"Max","alter":30}'
$arr = json_decode($json, true);  // Zurück zu Array
$obj = json_decode($json);       // Zu Objekt
?>

<?php
$array = ['name' => 'Max', 'alter' => 30];

// Serialisierung in String
$serialized = serialize($array);
echo $serialized;  // a:2:{s:4:"name";s:3:"Max";s:5:"alter";i:30;}

// Deserialisierung zurück zum ursprünglichen Typ
$original = unserialize($serialized);
var_dump($original);  // Original-Array
?>

<?php
// Dieses Declare muss die allererste Anweisung in der Datei sein
declare(strict_types=1);

// Typdeklarationen für Parameter und Rückgabewert
function addiere(int $a, int $b): int {
    return $a + $b;
}

// Funktioniert im strict mode
echo addiere(5, 10);  // 15

// Fehler im strict mode: TypeError
// echo addiere("5", 10);  // Fehler, da "5" kein int ist

// Ohne strict_types würde dies funktionieren
// (in einer anderen Datei ohne declare(strict_types=1))
?>