Datentypen

Geschätzte Lektüre: 13 Minuten 456 Ansichten

In PHP, wie in jeder Programmiersprache, gibt es verschiedene Arten von Daten, die wir verwenden können. Diese nennt man Datentypen. Datentypen bestimmen, welche Art von Wert eine Variable speichern kann und welche Operationen mit ihr durchgeführt werden können.

PHP ist eine „schwach typisierte“ Sprache, was bedeutet, dass du Variablen nicht explizit einen Typ zuweisen musst – PHP bestimmt den Typ automatisch basierend auf dem zugewiesenen Wert.

Die grundlegenden Datentypen in PHP

PHP unterstützt acht primitive Datentypen, die in drei Kategorien unterteilt werden können:

  1. Skalare Typen (einzelne Werte)
    • boolean
    • integer
    • float (auch double genannt)
    • string
  2. Zusammengesetzte Typen (mehrere Werte)
    • array
    • object
    • callable
    • iterable
  3. Spezielle Typen
    • resource
    • NULL

Skalare Datentypen

Boolean (Wahrheitswert)

Der einfachste Datentyp in PHP. Ein boolean drückt einen Wahrheitswert aus und kann entweder true (wahr) oder false (falsch) sein.

Beispiel:

$isOnline = true;
$hasPermission = false;

if ($isOnline) {
    echo "Der Benutzer ist online.";
} else {
    echo "Der Benutzer ist offline.";
}

Booleans werden oft in bedingten Anweisungen verwendet.

Integer (Ganzzahl)

Ein integer ist eine ganze Zahl ohne Dezimalpunkt. Er kann positiv oder negativ sein.

Beispiel:

$age = 25;
$temperature = -5;
$population = 8000000;

// Berechnungen mit Integern
$sum = 10 + 5;  // Ergebnis: 15 (integer)
$product = 3 * 7;  // Ergebnis: 21 (integer)

Integer können in verschiedenen Notationen geschrieben werden:
• Dezimal (Basis 10): 1234
• Oktal (Basis 8): 01234
• Hexadezimal (Basis 16): 0x1A
• Binär (Basis 2): 0b11111111

Float (Gleitkommazahl)

Auch bekannt als „double“ oder „real number“. Floats sind Zahlen mit Dezimalpunkt oder in exponentieller Schreibweise.

Beispiel:

$price = 12.99;
$pi = 3.14159;
$scientific = 1.2e3;  // Das bedeutet 1.2 * 10^3 = 1200

// Berechnungen mit Floats
$total = $price * 3;  // Ergebnis: 38.97 (float)

Wichtig: Floats haben eine begrenzte Präzision, was zu Rundungsfehlern führen kann.

String (Zeichenkette)

Ein String ist eine Folge von Zeichen, die zur Darstellung von Text verwendet wird. Strings können in PHP auf verschiedene Weise definiert werden.

Beispiel:

$name = "Max Mustermann";  // Doppelte Anführungszeichen
$city = 'Berlin';         // Einfache Anführungszeichen

// String-Verarbeitung
$greeting = "Hallo, " . $name . "!";  // Verkettung mit .
echo $greeting;  // Ausgabe: Hallo, Max Mustermann!

Unterschied zwischen einfachen und doppelten Anführungszeichen:

  • Einfache Anführungszeichen: Wörtliche Interpretation (keine Variablenersetzung)
  • Doppelte Anführungszeichen: Variablen werden ersetzt, spezielle Escape-Sequenzen werden interpretiert

Beispiel:

$age = 30;

echo 'Ich bin $age Jahre alt.';  // Ausgabe: Ich bin $age Jahre alt.
echo "Ich bin $age Jahre alt.";  // Ausgabe: Ich bin 30 Jahre alt.

Strings können auch mit der „heredoc“ und „nowdoc“ Syntax erstellt werden, was für längere Textblöcke nützlich ist.

Zusammengesetzte Datentypen

Array

Ein Array ist eine geordnete Map, die Werte speichert. Ein Array kann als eine Sammlung von Schlüssel-Wert-Paaren betrachtet werden.

Beispiel:

// Einfaches Array (numerisch indiziert)
$fruits = array("Apfel", "Banane", "Orange");
// Kurzschreibweise (seit PHP 5.4)
$fruits = ["Apfel", "Banane", "Orange"];

// Assoziatives Array (benannte Schlüssel)
$person = [
    "name" => "Max",
    "age" => 30,
    "city" => "Berlin"
];

// Zugriff auf Array-Elemente
echo $fruits[0];  // Ausgabe: Apfel
echo $person["name"];  // Ausgabe: Max

// Array erweitern
$fruits[] = "Erdbeere";  // Fügt am Ende hinzu
$person["job"] = "Entwickler";  // Fügt neues Schlüssel-Wert-Paar hinzu

Arrays sind extrem vielseitig und werden häufig in PHP verwendet.

Object

Ein Objekt ist eine Instanz einer Klasse. Klassen sind benutzerdefinierte Datentypen, die Eigenschaften und Methoden enthalten können.

Beispiel:

// Eine einfache Klasse definieren
class Person {
    public $name;
    public $age;
    
    public function greet() {
        return "Hallo, mein Name ist " . $this->name . "!";
    }
}

// Ein Objekt erstellen
$person1 = new Person();
$person1->name = "Anna";
$person1->age = 28;

echo $person1->greet();  // Ausgabe: Hallo, mein Name ist Anna!

Objekte ermöglichen die objektorientierte Programmierung in PHP.

Callable

Ein callable ist ein Datentyp, der Funktionen repräsentiert, die aufgerufen werden können. Dies kann der Name einer Funktion als String sein, ein Array mit einem Objekt und einer Methode oder eine anonyme Funktion.

Beispiel:

// Normale Funktion
function sayHello() {
    echo "Hallo!";
}

// Callable als String
$functionName = 'sayHello';
$functionName();  // Aufruf der Funktion

// Anonyme Funktion (Closure)
$greet = function($name) {
    echo "Hallo, $name!";
};
$greet('Max');  // Ausgabe: Hallo, Max!

Iterable

Ein iterable ist ein Pseudotyp, der für alle Werte steht, die mit foreach durchlaufen werden können, also Arrays und Objekte, die das Traversable-Interface implementieren.

Beispiel:

function printIterable(iterable $myIterable) {
    foreach($myIterable as $item) {
        echo $item;
    }
}

$arr = ["a", "b", "c"];
printIterable($arr);

Spezielle Datentypen

Resource

Eine Resource ist eine spezielle Variable, die einen externen Verweis auf eine Ressource enthält (z.B. eine Datenbankverbindung oder eine geöffnete Datei).

Beispiel:

// Öffnen einer Datei (gibt eine Resource zurück)
$file = fopen("example.txt", "r");

// Arbeiten mit der Resource
if ($file) {
    while (($line = fgets($file)) !== false) {
        echo $line;
    }
    fclose($file);  // Resource freigeben
}

NULL

NULL ist ein spezieller Datentyp, der bedeutet, dass eine Variable keinen Wert hat. Eine Variable ist NULL:

  • wenn sie explizit auf NULL gesetzt wurde
  • wenn sie noch keinen Wert zugewiesen bekommen hat
  • wenn sie mit unset() gelöscht wurde

Beispiel:

$var = NULL;  // Explizit auf NULL setzen
$var2;        // Noch kein Wert zugewiesen (implizit NULL)

if (is_null($var)) {
    echo "Die Variable ist NULL";
}

Die gettype() Funktion in PHP

Die gettype() Funktion ist ein nützliches Werkzeug in PHP, um den Datentyp einer Variable zur Laufzeit zu ermitteln. Sie gibt einen String zurück, der den Typ der übergebenen Variable beschreibt.

Syntax:

string gettype(mixed $var)

Beispiel:

$values = [
    42,
    3.14,
    "Hallo Welt",
    true,
    null,
    ['a', 'b', 'c'],
    new stdClass(),
    fopen('example.txt', 'r')
];

foreach ($values as $value) {
    echo gettype($value) . "\n";
}

Mögliche Rückgabewerte:

  • „boolean“ (für true/false)
  • „integer“
  • „double“ (für float-Werte)
  • „string“
  • „array“
  • „object“
  • „resource“
  • „NULL“
  • „unknown type“ (sehr selten)

Praktische Anwendung:

$userInput = $_POST['age']; // Angenommen, dies kommt aus einem Formular

if (gettype($userInput) === 'string') {
    $age = (int)$userInput;
    echo "Alter als Integer: " . $age;
} elseif (gettype($userInput) === 'integer') {
    echo "Alter wurde bereits als Integer übergeben: " . $userInput;
} else {
    echo "Ungültiger Datentyp für Alter";
}

Hinweis: Während gettype() für Debugging-Zwecke nützlich ist, sollte für Typüberprüfungen in Produktionscode normalerweise die spezifischeren is_*-Funktionen (wie is_int(), is_string() etc.) bevorzugt werden, da sie präziser und performanter sind.

Typenprüfung und Typenumwandlung

Typenprüfung

PHP bietet mehrere Funktionen, um den Typ einer Variable zu überprüfen:

$var = "123";

is_int($var);      // false
is_string($var);   // true
is_bool($var);     // false
is_array($var);    // false
is_float($var);    // false
is_null($var);     // false
is_numeric($var);  // true (weil der String in eine Zahl umgewandelt werden kann)

Typenumwandlung (Type Casting)

Du kannst den Typ einer Variable explizit ändern, indem du den gewünschten Typ in Klammern vor die Variable schreibst.

Beispiel:

$str = "123.45abc";
$int = (int)$str;    // 123 (integer)
$float = (float)$str; // 123.45 (float)
$bool = (bool)$str;  // true (boolean)

Mögliche Casts:
• (int) oder (integer)
• (bool) oder (boolean)
• (float) oder (double) oder (real)
• (string)
• (array)
• (object)
• (unset) (veraltet)

Besonderheiten der PHP-Typisierung

Automatische Typumwandlung

PHP führt automatisch Typumwandlungen durch, wenn es nötig ist. Dies wird als „type juggling“ bezeichnet.

Beispiel:

$sum = "5" + 2;  // Ergebnis ist 7 (integer)
echo $sum;

$result = "10 apples" + "5 oranges";  // Ergebnis ist 15 (integer)
echo $result;

Strikte Typenprüfung

Seit PHP 7 kannst du mit declare(strict_types=1); eine strikte Typenprüfung aktivieren, die keine automatische Typumwandlung erlaubt.

Beispiel:

declare(strict_types=1);

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

echo add(5, 3);      // Funktioniert
echo add("5", "3");  // TypeError!

Best Practices für Datentypen in PHP

  1. Konsistente Typen verwenden: Versuche, Variablen konsistent zu verwenden und unerwartete Typumwandlungen zu vermeiden.
  2. Typen explizit prüfen: Wenn der Typ einer Variable wichtig ist, prüfe ihn mit is_* Funktionen.
  3. Dokumentation: Dokumentiere die erwarteten Typen in deinen Funktionen, besonders wenn du strikte Typen verwendest.
  4. Type-Hinting nutzen: Ab PHP 7 kannst du Typen für Funktionsparameter und Rückgabewerte angeben.
  5. Vorsicht mit Floats: Vermeide Floats für finanzielle Berechnungen wegen möglicher Rundungsfehler (verwende stattdessen z.B. die BC Math Funktionen).

Grundlegend

Das Verständnis der verschiedenen Datentypen in PHP ist grundlegend für die Entwicklung von robusten und fehlerfreien Anwendungen. PHP bietet eine flexible Typisierung, die es Anfängern leicht macht, aber auch erfahrene Entwickler müssen die Eigenheiten der automatischen Typumwandlung verstehen, um unerwartetes Verhalten zu vermeiden.

Dieses Dokument teilen

Datentypen

Oder Link kopieren

INHALT

Abonnieren

×
Cancel