PHP Anfänger 25 min

Variablen & Datentypen

PHP-Variablen, skalare Typen, Typdeklarationen und moderne Features wie Nullable Types und Union Types in PHP 8+.

Aktualisiert:
Inhaltsverzeichnis

Variablen & Datentypen

PHP war lange als “dynamisch und lose typisiert” bekannt. Modernes PHP 8+ ist immer noch dynamisch - aber du kannst fast ueberall Typen hinzufuegen.

Variablen

<?php

$name = 'Anna';
$alter = 28;
$aktiv = true;
$pi = 3.14;

Regeln:

  • Variablen beginnen mit $
  • Der erste Buchstabe nach $ muss ein Buchstabe oder Unterstrich sein
  • Gross-/Kleinschreibung ist signifikant: $name ≠ $Name
  • PHP leitet den Typ aus dem zugewiesenen Wert ab

Konstanten

const PI = 3.14159;
const MAX_RETRIES = 5;

// Dynamisch zur Laufzeit
define('APP_VERSION', '1.0.0');

const ist haeufiger, define nur dann noetig, wenn der Wert zur Laufzeit bestimmt werden muss.

Skalare Datentypen

int - Ganzzahlen

$alter = 28;
$grenzen = PHP_INT_MAX;   // systemabhaengiges Maximum
$hex = 0xFF;              // 255
$bin = 0b1010;            // 10
$oct = 0o17;              // 15
$gross = 1_000_000;       // Unterstriche erlaubt

float - Fliesskommazahlen

$pi = 3.14159;
$exp = 1.5e3;             // 1500

string - Zeichenketten

Drei wichtige Varianten:

// Single-Quoted - literal, kein Escaping
$s1 = 'Anna sagt: "Hi"';

// Double-Quoted - mit Variable-Interpolation und Escaping
$name = 'Anna';
$s2 = "Hallo, {$name}!";       // "Hallo, Anna!"
$s3 = "Zeile 1\nZeile 2";      // \n wird Zeilenumbruch

// Heredoc - mehrzeilig mit Interpolation
$s4 = <<<EOT
    Mehrere Zeilen
    mit Interpolation: {$name}
    EOT;

// Nowdoc - mehrzeilig ohne Interpolation
$s5 = <<<'EOT'
    Wie Heredoc, aber ohne Variablen-Interpolation
    EOT;

String-Funktionen

strlen('Anna')             // 4
strtoupper('anna')         // "ANNA"
strtolower('ANNA')         // "anna"
str_replace('a', 'e', 'Anna') // "ennA"
substr('Anna', 1, 2)       // "nn"
explode(',', 'a,b,c')      // ['a', 'b', 'c']
implode(', ', ['a', 'b'])  // "a, b"
trim('  hi  ')             // "hi"

Konkatenation

Mit .:

$gruss = 'Hallo, ' . $name . '!';

Oder lieber Interpolation:

$gruss = "Hallo, {$name}!";

bool - Wahrheitswerte

$aktiv = true;
$fertig = false;

Diese Werte sind falsy: false, 0, '0', '', null, []. Alle anderen sind truthy.

null

$wert = null;

null signalisiert “kein Wert”. Nicht zu verwechseln mit false oder 0.

Compound-Typen

Arrays

PHP-Arrays sind vielseitig: sie sind sowohl Listen als auch assoziative Dictionaries.

// Indiziertes Array (Liste)
$namen = ['Max', 'Anna', 'Leo'];
echo $namen[0];     // "Max"

// Assoziatives Array (Dictionary)
$person = [
    'name' => 'Anna',
    'alter' => 28,
    'aktiv' => true,
];
echo $person['name']; // "Anna"

// Verschachtelt
$team = [
    'anna' => ['alter' => 28, 'rolle' => 'Dev'],
    'max' => ['alter' => 34, 'rolle' => 'PM'],
];
echo $team['anna']['rolle']; // "Dev"

Mehr zu Arrays im Arrays-Kapitel.

Objects (kurzer Vorblick)

class Person
{
    public function __construct(
        public string $name,
        public int $alter
    ) {}
}

$anna = new Person('Anna', 28);
echo $anna->name; // "Anna"

Typdeklarationen

PHP 8+ laesst dich ueberall Typen angeben:

<?php
declare(strict_types=1);

function addieren(int $a, int $b): int
{
    return $a + $b;
}

class Person
{
    public string $name;
    public int $alter;
    public ?string $email = null;   // nullable
}

Moderne Typ-Features

// Union Types - mehrere moegliche Typen
function idAls(string|int $id): string {
    return (string) $id;
}

// Nullable - kurz fuer "Typ|null"
function finde(int $id): ?Person {
    // gibt Person oder null zurueck
}

// Intersection Types (nur fuer Objekte)
function handle(Serializable & Countable $obj): void {}

// never - Funktion kehrt nie zurueck (wirft / exit)
function bruch(string $msg): never {
    throw new \RuntimeException($msg);
}

// true / false als Typen
function istGueltig(): true|false { /* ... */ }

Typ-Konvertierung

Implizit (ohne strict_types)

$a = '5' + 3;         // int 8 - String wird konvertiert
$b = 'abc' + 1;       // warning + int 1

Mit declare(strict_types=1); wird das strenger.

Explizit

$zahl = (int) '42';
$text = (string) 42;
$bool = (bool) 1;
$float = (float) '3.14';

// Oder mit Funktionen
$zahl = intval('42');
$text = strval(42);

Bei Nutzer-Input

$alter = (int) ($_POST['alter'] ?? 0);

// Lieber noch: mit Validierung
$alter = filter_var($_POST['alter'] ?? 0, FILTER_VALIDATE_INT);
if ($alter === false) {
    // ungueltig
}

Variable Scope

PHP-Variablen sind standardmaessig nicht global:

$x = 10;

function zeige(): void {
    // echo $x;   // nicht definiert!
    global $x;    // unsauber, aber moeglich
    echo $x;
}

Empfohlen: Uebergabe ueber Parameter statt global.

Kurze Tests

PHP hat viele praktische Funktionen, um Werte zu pruefen:

is_string($a)
is_int($a)
is_array($a)
is_null($a)
isset($a)          // existiert und ist nicht null
empty($a)          // null, false, 0, '0', '', []

Der ??-Operator

Der “Null Coalescing Operator” - gibt den linken Wert, wenn er gesetzt und nicht null ist:

$name = $_GET['name'] ?? 'Anonym';

// Ersetzt frueher:
$name = isset($_GET['name']) ? $_GET['name'] : 'Anonym';

Der ?.-Operator - Null Safe

Fuer sichere Methodenaufrufe:

$alter = $person?->adresse?->plz;  // null, wenn eine Zwischen-Ref null ist

Zusammenfassung

  • Variablen beginnen mit $, Typ wird aus dem Wert abgeleitet
  • const und define fuer Konstanten
  • Strings: '...' literal, "..." mit Interpolation, Heredoc / Nowdoc mehrzeilig
  • Arrays sind gleichzeitig Listen und Dictionaries
  • Typdeklarationen mit PHP 8+ machen Code sicher: int, string, bool, ?Typ, Type|Typ
  • ?? fuer Default-Werte, ?-> fuer sichere Verkettung
  • declare(strict_types=1); solltest du immer oben haben

Im naechsten Kapitel: Kontrollstrukturen, inklusive des modernen match-Ausdrucks.

Zurück zum PHP Kurs