PHP gettype(): Der umfassende Leitfaden zur Variablentyp-Prüfung

Viele Entwickler stehen früher oder später vor der Frage, welchen Typ eine Variable in PHP tatsächlich besitzt. Die Funktion gettype() liefert darauf eine schnelle Antwort. Doch wann solltest du sie einsetzen? Was musst du beachten, und welche Alternativen sind sinnvoll?

In diesem Artikel findest du alles, was du zur sicheren Typprüfung mit gettype() wissen musst – inklusive Fallstricken, praxisnahen Beispielen und einem Überblick zu verwandten Funktionen.

Was ist PHP gettype()? Definition und Syntax

Bevor wir tiefer einsteigen, schauen wir uns an, wie die Funktion grundsätzlich funktioniert.

Die Funktion gettype() gibt den Typ einer übergebenen Variable als String zurück. Das ist besonders in PHP, einer dynamisch und lose typisierten Sprache, wichtig, weil sich Variablen während der Laufzeit verändern können.

Syntax:

/** Die Funktion gibt den Typ der Variablen als String zurück */

string gettype ( mixed $wert )

Parameter:

• $wert: Die zu untersuchende Variable, deren Typ du bestimmen möchtest.

Das Resultat ist stets ein String, der den Typ beschreibt – zum Beispiel „integer“ oder „array“.

Mögliche Rückgabewerte (mit übersichtlicher Tabelle)

Im Alltag ist es wichtig zu wissen, welche Rückgabewerte gettype() überhaupt liefern kann. Die folgende Tabelle gibt dir den vollständigen Überblick.

Hier findest du sämtliche möglichen Rückgabewerte, den zugehörigen Datentyp und jeweils ein kurzes Beispiel.

Seit PHP 7.2 gibt es für geschlossene Ressourcen den Wert "resource (closed)", früher wurde „unknown type“ zurückgegeben. Das ist einer der Knackpunkte, die du im Hinterkopf behalten solltest.

Grundlegende Anwendungsbeispiele

Nichts verdeutlicht den Nutzen einer Funktion besser als echte Codebeispiele. Die folgenden Beispiele helfen dir, den Einsatz von gettype() sofort nachzuvollziehen.

Du siehst verschiedene Anwendungsfälle, die vom simplen Skalarwert bis zu Spezialfällen wie Ressourcen reichen.

Beispiel 1: Überprüfung von Skalartypen

Zunächst untersuchen wir einfache Variablentypen: Integer, Float, String und Boolean.

/** Prüft den Typ verschiedener Skalartypen */

$iZahl = 42;

$fKommazahl = 3.14;

$sText = "Hallo Welt";

$bWahrheitswert = true;



echo gettype($iZahl); 
/** Gibt 'integer' zurück */

echo gettype($fKommazahl); 
/** Gibt 'double' zurück */

echo gettype($sText); 
/** Gibt 'string' zurück */

echo gettype($bWahrheitswert);

/** Gibt 'boolean' zurück */

Beispiel 2: Überprüfung von zusammengesetzten Typen

Hier prüfen wir ein Array und ein Objekt.

/** Prüft den Typ eines Arrays und eines Objekts */

$aListe = [1, 2, 3];

$oObjekt = new stdClass();



echo gettype($aListe); /** Gibt 'array' zurück */

echo gettype($oObjekt); /** Gibt 'object' zurück */

Beispiel 3: Überprüfung von speziellen Typen

Nun noch die Spezialfälle: NULL und eine Ressource.

/** Prüft NULL und eine Datei-Ressource */

$mNichts = NULL;

$oDatei = fopen("beispiel.txt", "w");



echo gettype($mNichts); 
/** Gibt 'NULL' zurück */

echo gettype($oDatei); 
/** Gibt 'resource' zurück */



fclose($oDatei);

echo gettype($oDatei); 
/** Gibt ab PHP 7.2 'resource (closed)' zurück */

gettype() vs. is_* Funktionen: Was soll man wann verwenden?

Viele Entwickler fragen sich: Wann ist es sinnvoll, auf gettype() zu setzen – und wann solltest du lieber eine der zahlreichen is_* Funktionen nutzen? Genau das schauen wir uns hier differenziert an.

Die Unterscheidung ist entscheidend für sauberen und effizienten Code.

Szenario 1: Überprüfung auf einen bestimmten Typ

Wenn du gezielt testen willst, ob eine Variable einen bestimmten Typ besitzt, solltest du immer eine is_* Funktion verwenden. Sie ist nicht nur prägnanter, sondern auch schneller.

/** Korrekte Typprüfung mit is_* */

if (is_int($iZahl)) {

 /** Die Variable ist ein Integer */

}

Diese Variante ist besser lesbar als:

if (gettype($iZahl) === 'integer') {

 /** Funktioniert, ist aber schlechter wartbar */

}

Szenario 2: Debugging oder Protokollierung

Beim Debugging ist gettype() praktisch. Du willst oft einfach wissen, was du gerade vor dir hast – unabhängig vom erwarteten Typ. Auch für Logs und schnelle Typausgaben ist es nützlich, ohne jede Möglichkeit einzeln abzufragen.

Ab PHP 8 gibt es zusätzlich get_debug_type(), das noch genauere Typinformationen liefert (z. B. auch Klassennamen).

Performance-Vergleich

Die is_* Funktionen sind im Vorteil: Sie liefern direkt ein Boolean-Resultat, während gettype() immer einen String erzeugt. Das spart Rechenzeit, gerade bei sehr vielen Typprüfungen.

Fallstricke und wichtige Hinweise („Gotchas“)

Nicht alles an gettype() ist selbsterklärend. Hier findest du typische Stolpersteine aus der Praxis, die dich vor Fehlern im Live-Betrieb bewahren.

Oft treten Fehler auf, weil Entwickler von den Rückgabewerten oder der Historie der Funktion überrascht werden.

• "integer" vs. is_int():
  gettype() gibt den String “integer” zurück, die korrespondierende Prüf-Funktion heißt aber is_int(), nicht is_integer().

• "double" vs. is_float():
  Für Fließkommazahlen liefert gettype() “double”, auch wenn du intern is_float() benutzt.

• Geschlossene Ressourcen:
  Seit PHP 7.2 gibt es für geschlossene Ressourcen den speziellen Wert “resource (closed)”. Ältere PHP-Versionen meldeten hier noch “unknown type”. Das ist für Legacy-Projekte relevant.

• Objekte:
  Egal, welches Objekt du prüfst – gettype() gibt immer “object” zurück. Willst du wissen, um welche Klasse es sich handelt, brauchst du get_class().

Praxisnaher Anwendungsfall: Dynamische Parameterbehandlung

Gerade bei flexiblen Funktionen mit gemischten Parametern wird gettype() nützlich. Mit einer switch-Anweisung kannst du auf den Typ flexibel reagieren.

Das folgende Beispiel zeigt, wie du für unterschiedliche Typen gezielt verschiedene Aktionen auslösen kannst.

/** Funktion, die je nach Typ der Eingabe unterschiedlich reagiert */

function mBearbeiteWert($mWert)

{

 switch (gettype($mWert)) {

 case 'integer':

 /** Verarbeitung für Integer */

 echo "Zahl: $mWert";

 break;

 case 'double':

 /** Verarbeitung für Float/Double */

 echo "Kommazahl: $mWert";

 break;

 case 'string':

 /** Verarbeitung für Text */

 echo "Text: $mWert";

 break;

 case 'array':

 /** Verarbeitung für Arrays */

 echo "Array mit " . count($mWert) . " Elementen";

 break;

 case 'object':

 /** Verarbeitung für Objekte */

 echo "Objekt der Klasse: " . get_class($mWert);

 break;

 case 'NULL':

 /** Verarbeitung für NULL */

 echo "Kein Wert übergeben";

 break;

 default:

 /** Unbekannter oder seltener Typ */

 echo "Spezialfall: " . gettype($mWert);

 }

}

Diese Strategie empfiehlt sich, wenn die Art der Verarbeitung stark vom Typ abhängt und du nicht für jeden Typ eine separate Funktion schreiben willst.

Verwandte Funktionen und Alternativen

Nicht jede Typprüfung muss mit gettype() erfolgen. Es gibt einige Alternativen und verwandte Funktionen, die im Alltag oft hilfreicher oder spezieller sind.

Lerne die wichtigsten kennen und wähle je nach Anwendungsfall das passende Werkzeug.

• settype()
  Damit kannst du den Typ einer Variablen gezielt ändern.

  /** Ändert den Typ einer Variablen in Integer */
  
  $mWert = "42";
  
  settype($mWert, "integer");
  
  /** $mWert ist nun vom Typ Integer */ 
  

• get_class()
  Liefert den Klassennamen eines Objekts als String zurück.

  $oObjekt = new DateTime();
  
  echo get_class($oObjekt); /** Gibt 'DateTime' zurück */ 
  

• get_debug_type()
  Seit PHP 8 verfügbar, gibt klarere und oft detailliertere Typen zurück (inklusive Klassennamen).

  $oObjekt = new DateTime();
  
  echo get_debug_type($oObjekt); /** Gibt 'DateTime' zurück */ 
  

• var_dump()
  Gibt nicht nur den Typ, sondern auch den Wert der Variablen aus – für Debugging-Zwecke unentbehrlich.

  var_dump($oObjekt); /** Beispielausgabe: object(DateTime)#1 (3) {...} */ 
  

Fazit: Best Practices zusammengefasst

Zum Schluss findest du die wichtigsten Erkenntnisse zum Thema „Variablentyp-Prüfung in PHP“ auf einen Blick.

• Für logische Typprüfungen im Code solltest du immer is_* Funktionen wie is_int(), is_string() und so weiter verwenden. Sie sind lesbarer und meist performanter.

• Für Debugging und Logging bieten sich gettype() und ab PHP 8 auch get_debug_type() an.

• Achte immer auf die exakten String-Rückgabewerte – insbesondere, dass „integer“ und „double“ die Rückgabe sind, während die Prüf-Funktionen is_int() und is_float() heißen.

• Prüfe bei Ressourcen, ob deine PHP-Version bereits zwischen offenen und geschlossenen Ressourcen unterscheidet.

• Willst du wissen, welcher Klasse ein Objekt angehört, nutze immer get_class().

Mit diesem Wissen bist du sowohl beim Debugging als auch bei der robusten Entwicklung von PHP-Anwendungen klar im Vorteil.