Wer Benutzereingaben, API-Antworten oder Konfigurationswerte verarbeitet, muss sich auf den Datentyp verlassen können. Die Funktion is_string() prüft, ob eine Variable tatsächlich eine Zeichenkette enthält. Gerade bei dynamischen Daten aus Formularen oder JSON-Schnittstellen schützt diese Prüfung vor unerwarteten Fehlern und macht den PHP-Code robuster.
graph TD
A["Variable pruefen"] --> B{"Typ?"}
B -->|String| C["is_string: true"]
B -->|Zahl| D["is_numeric pruefen"]
B -->|Objekt| E["__toString?"]
D -->|Ganze Zahl| F["ctype_digit"]
D -->|Dezimal| G["is_float"]
E -->|Ja| H["Stringable"]
E -->|Nein| I["Kein String"]
Grundlegende Verwendung
is_string() gibt true zurück, wenn die übergebene Variable vom Typ string ist. Bei allen anderen Datentypen liefert sie false. Die Syntax ist denkbar einfach:
<?php
$name = "PHP";
$zahl = 42;
$komma = 3.14;
$liste = ["a", "b"];
$leer = null;
var_dump(is_string($name)); // bool(true)
var_dump(is_string($zahl)); // bool(false)
var_dump(is_string($komma)); // bool(false)
var_dump(is_string($liste)); // bool(false)
var_dump(is_string($leer)); // bool(false)
?>
Auch ein leerer String "" ist ein gültiger String. is_string("") gibt also true zurück. Das ist ein wichtiger Unterschied zu empty(), die bei leeren Strings true liefert.
Formulareingaben prüfen
Daten aus $_GET und $_POST kommen immer als Strings an. Trotzdem kann es vorkommen, dass ein Feld als Array gesendet wird, etwa wenn der Feldname eckige Klammern enthält. Mit is_string() lässt sich das abfangen:
<?php
$eingabe = $_POST["benutzername"] ?? null;
if (!is_string($eingabe) || trim($eingabe) === "") {
echo "Bitte einen gültigen Namen eingeben.";
} else {
$sauber = htmlspecialchars($eingabe);
echo "Willkommen, " . $sauber;
}
?>
Diese Prüfung ist der erste Schritt in einer sicheren Validierungskette. Danach sollte der Wert mit filter_input() weiter gefiltert und mit htmlspecialchars() für die Ausgabe vorbereitet werden. Mehr zum Thema Sicherheit findest du im Tutorial zu SQL-Injection und XSS.
Kombination mit Längenvalidierung
In der Praxis reicht es selten aus, nur den Typ zu prüfen. Fast immer will man auch wissen, ob der String eine bestimmte Mindest- oder Maximallänge hat. Die Funktion mb_strlen() zählt dabei korrekt mit Multibyte-Zeichen wie Umlauten:
<?php
function validiereString(
mixed $wert,
int $minLaenge = 1,
int $maxLaenge = 255
): string|false {
if (!is_string($wert)) {
return false;
}
$wert = trim($wert);
$laenge = mb_strlen($wert, "UTF-8");
if ($laenge < $minLaenge || $laenge > $maxLaenge) {
return false;
}
return $wert;
}
/* Beispiel: Benutzername 3-30 Zeichen */
$name = validiereString($_POST["name"] ?? "", 3, 30);
if ($name === false) {
echo "Name muss 3 bis 30 Zeichen lang sein.";
} else {
echo "Gueltig: " . htmlspecialchars($name);
}
?>
Diese Funktion lässt sich in jedem Formular wiederverwenden. Sie prüft den Typ, entfernt Leerzeichen am Rand und validiert die Länge in einem Schritt.
API-Daten absichern
JSON-APIs liefern häufig gemischte Datentypen. Ein Feld, das normalerweise einen String enthält, kann bei bestimmten Antworten plötzlich null, ein Integer oder ein verschachteltes Objekt sein. Hier schützt is_string() vor Laufzeitfehlern:
<?php
$json = '{"name": "Max", "alter": 28, "bio": null}';
$daten = json_decode($json, true);
foreach ($daten as $feld => $wert) {
if (is_string($wert)) {
echo $feld . ": " . htmlspecialchars($wert);
echo "<br>";
}
}
/* Ausgabe: name: Max */
?>
So werden nur die tatsächlichen Strings weiterverarbeitet. Felder mit null oder numerischen Werten werden übersprungen, ohne dass eine Fehlermeldung auftritt.
Stolperfalle: Objekte mit __toString()
Objekte, die eine __toString()-Methode besitzen, lassen sich zwar als String ausgeben, sind aber trotzdem keine Strings im Sinne von is_string():
<?php
class Produkt {
public function __construct(
private string $name
) {}
public function __toString(): string {
return $this->name;
}
}
$p = new Produkt("Tastatur");
echo $p; // Tastatur
var_dump(is_string($p)); // bool(false)
?>
Das Objekt verhält sich wie ein String, ist aber keiner. Das kann bei Funktionen wie strlen() oder strtolower() zu Problemen führen, wenn man vorher mit is_string() prüft.
Stringable-Interface seit PHP 8.0
Seit PHP 8.0 gibt es das Stringable-Interface. Jede Klasse mit einer __toString()-Methode implementiert dieses Interface automatisch. Damit lässt sich eine zuverlässigere Prüfung bauen:
<?php
function istStringArtig(mixed $wert): bool
{
return is_string($wert)
|| $wert instanceof Stringable;
}
$p = new Produkt("Tastatur");
var_dump(istStringArtig("Hallo")); // true
var_dump(istStringArtig($p)); // true
var_dump(istStringArtig(42)); // false
?>
Für Type Hints in Funktionsparametern kann man seit PHP 8.0 direkt string|Stringable als Union Type verwenden. So akzeptiert die Funktion sowohl echte Strings als auch Objekte mit __toString():
<?php
function gibAus(string|Stringable $text): void
{
echo htmlspecialchars((string) $text);
}
gibAus("Normaler Text");
gibAus(new Produkt("Maus"));
?>
Unterschied zu is_numeric() und ctype_digit()
Die drei Funktionen is_string(), is_numeric() und ctype_digit() werden oft verwechselt, prüfen aber völlig unterschiedliche Dinge:
| Wert | is_string() | is_numeric() | ctype_digit() |
|---|
"Hallo" | true | false | false |
"42" | true | true | true |
"3.14" | true | true | false |
42 | false | true | false |
"" (leer) | true | false | false |
"-7" | true | true | false |
is_string() prüft nur den Datentyp. is_numeric() prüft, ob der Wert als Zahl interpretiert werden kann, egal ob String oder Integer. ctype_digit() ist am strengsten und akzeptiert nur Strings, die ausschließlich aus den Ziffern 0 bis 9 bestehen.
Type Hinting als Alternative
In modernem PHP lassen sich Funktionsparameter direkt mit einem Typ versehen. Dadurch wird die manuelle Prüfung per is_string() in vielen Fällen überflüssig:
<?php
function begruessung(string $name): string
{
return "Hallo, " . htmlspecialchars($name);
}
/* PHP wirft einen TypeError wenn
kein String uebergeben wird */
echo begruessung("Anna"); // Hallo, Anna
?>
is_string() bleibt trotzdem unverzichtbar, wenn die Daten aus einer dynamischen Quelle stammen: Formulare, JSON-APIs, Datenbank-Ergebnisse oder Konfigurationsdateien. In diesen Fällen kennt PHP den Typ erst zur Laufzeit. Als Faustregel gilt: Verwende Type Hints für eigene Funktionen und is_string() für externe Daten.
Verwandte Funktionen
PHP bietet eine ganze Familie von Typ-Prüfungsfunktionen. Je nach Situation ist eine andere Funktion die richtige Wahl:
