In PHP gibt es verschiedene Wege, Variablen in Strings einzufügen. Die einfachste Methode ist die Verkettung mit dem Punkt-Operator oder die Interpolation in doppelten Anführungszeichen. Sobald es aber um präzise Formatierung geht, etwa Zahlen mit festen Nachkommastellen, führende Nullen oder tabellarische Ausgaben, stoßen diese Methoden an ihre Grenzen. Genau hier kommen printf() und sprintf() ins Spiel. Beide Funktionen arbeiten mit einem Formatstring, der Platzhalter enthält. Diese Platzhalter werden zur Laufzeit durch die übergebenen Werte ersetzt. In diesem Tutorial lernst du die Syntax der Formatstrings, die verschiedenen Typspezifizierer und zahlreiche praktische Beispiele für den Einsatz im Alltag.
Der erste Schritt zum Verständnis ist der Unterschied zwischen den beiden Funktionen und ihre jeweilige Ausgabeart.
Unterschied zwischen printf und sprintf
Bevor du mit der Formatierung beginnst, solltest du den zentralen Unterschied zwischen den beiden Funktionen kennen. Obwohl beide dieselbe Formatstring-Syntax verwenden, unterscheiden sie sich in der Art der Ausgabe.
Die Funktion printf() gibt den formatierten String direkt aus. Sie verhält sich wie ein echo, das zusätzlich Platzhalter im Formatstring ersetzt. Die Funktion sprintf() hingegen gibt den formatierten String nicht aus, sondern liefert ihn als Rückgabewert zurück. Das ermöglicht es, den formatierten String in einer Variable zu speichern und später weiterzuverarbeiten.
<?php
$name = 'Max';
$alter = 28;
$note = 1.7;
printf('Name: %s, Alter: %d, Note: %.1f', $name, $alter, $note);
/* Ausgabe: Name: Max, Alter: 28, Note: 1.7 */
Das erste Argument ist der Formatstring mit den Platzhaltern %s, %d und %.1f. Alle weiteren Argumente sind die Werte, die in der Reihenfolge ihres Auftretens eingesetzt werden. Der Platzhalter %s steht für einen String, %d für eine Ganzzahl und %.1f für eine Gleitkommazahl mit einer Nachkommastelle.
<?php
$preis = 49.9;
$ausgabe = sprintf('Preis: %.2f Euro', $preis);
echo $ausgabe; /* Preis: 49.90 Euro */
Hier wird sprintf() verwendet, um den formatierten String in der Variable $ausgabe zu speichern. Erst danach wird er mit echo ausgegeben. In der Praxis ist sprintf() deutlich häufiger anzutreffen als printf(), weil sich der Rückgabewert flexibel weiterverwenden lässt, etwa als Parameter für andere Funktionen, in Log-Nachrichten oder beim Zusammensetzen komplexerer Strings.
flowchart TD
A[Formatstring] --> B{Funktion?}
B -->|printf| C[Direkte Ausgabe]
B -->|sprintf| D[String zurückgeben]
A --> E["Platzhalter-Typen<br/>%s String<br/>%d Integer<br/>%f Float<br/>%05d Füllzeichen<br/>%.2f Präzision"]
Die Formatstring-Syntax
Der Formatstring bildet das Herzstück von printf() und sprintf(). Er besteht aus normalem Text und Platzhaltern, die mit dem Prozentzeichen % beginnen. Jeder Platzhalter beschreibt, wie der zugehörige Wert formatiert werden soll.
Typspezifizierer
Der Typspezifizierer steht am Ende eines Platzhalters und bestimmt den Datentyp der Ausgabe. PHP bietet eine Reihe von Typspezifizierern für unterschiedliche Anwendungsfälle.
Der Spezifizierer %s gibt den Wert als String aus. Er ist der universellste Typ, da PHP die meisten Werte automatisch in einen String umwandeln kann. Der Spezifizierer %d gibt den Wert als vorzeichenbehaftete Ganzzahl (Integer) aus. Gleitkommazahlen werden dabei abgeschnitten, nicht gerundet. Mit %f wird der Wert als Gleitkommazahl (Float) ausgegeben, standardmäßig mit sechs Nachkommastellen. Der Spezifizierer %b gibt den Wert als Binärzahl aus, %x als Hexadezimalzahl in Kleinbuchstaben und %o als Oktalzahl. Diese drei Varianten sind besonders in der Systemprogrammierung und bei der Arbeit mit Farbcodes oder Berechtigungen nützlich. Zusätzlich gibt es %e für die wissenschaftliche Notation und %c, das einen Integer als das entsprechende ASCII-Zeichen ausgibt.
<?php
$zahl = 255;
echo sprintf('Dezimal: %d', $zahl); /* Dezimal: 255 */
echo sprintf('Binaer: %b', $zahl); /* Binaer: 11111111 */
echo sprintf('Hexadezimal: %x', $zahl); /* Hexadezimal: ff */
echo sprintf('Oktal: %o', $zahl); /* Oktal: 377 */
Breite (Width Specifier)
Zwischen dem Prozentzeichen und dem Typspezifizierer kann eine Mindestbreite angegeben werden. Die Mindestbreite legt fest, wie viele Zeichen die Ausgabe mindestens umfassen soll. Ist der Wert kürzer, wird er standardmäßig rechtsbündig mit Leerzeichen aufgefüllt.
<?php
echo sprintf('[%10s]', 'PHP'); /* [ PHP] */
echo sprintf('[%10d]', 42); /* [ 42] */
Die Zahl 10 nach dem Prozentzeichen gibt an, dass die Ausgabe mindestens zehn Zeichen breit sein soll. Der Wert wird rechtsbündig innerhalb dieses Bereichs platziert. Diese Technik eignet sich hervorragend für tabellarische Ausgaben, bei denen Spalten sauber untereinander stehen sollen.
Präzision (Dezimalstellen)
Für Gleitkommazahlen lässt sich die Anzahl der Nachkommastellen mit einem Punkt und einer Zahl vor dem Typspezifizierer f festlegen. Diese sogenannte Präzision bestimmt, auf wie viele Dezimalstellen der Wert gerundet wird.
<?php
$pi = 3.14159265;
echo sprintf('%.0f', $pi); /* 3 */
echo sprintf('%.2f', $pi); /* 3.14 */
echo sprintf('%.4f', $pi); /* 3.1416 */
echo sprintf('%.8f', $pi); /* 3.14159265 */
Die Angabe .2 vor dem f bedeutet zwei Nachkommastellen. Ohne Präzisionsangabe verwendet %f standardmäßig sechs Dezimalstellen. Die Präzision funktioniert auch in Kombination mit einer Mindestbreite. So erzeugt %10.2f eine Ausgabe mit mindestens zehn Zeichen Breite und genau zwei Nachkommastellen.
Füllzeichen und Ausrichtung
Standardmäßig werden Werte mit Leerzeichen aufgefüllt und rechtsbündig ausgerichtet. Beides lässt sich anpassen. Ein Minuszeichen nach dem Prozentzeichen schaltet auf linksbündige Ausrichtung um. Ein Füllzeichen wird durch ein einfaches Anführungszeichen gefolgt vom gewünschten Zeichen angegeben.
<?php
/* Rechtsbuendig mit Leerzeichen (Standard) */
echo sprintf('[%10s]', 'PHP'); /* [ PHP] */
/* Linksbuendig mit Leerzeichen */
echo sprintf('[%-10s]', 'PHP'); /* [PHP ] */
/* Rechtsbuendig mit Punkten als Fuellzeichen */
echo sprintf("[%'.10s]", 'PHP'); /* [.......PHP] */
Die Kombination aus Füllzeichen, Breite und Ausrichtung ermöglicht es, Ausgaben exakt so zu gestalten, wie sie benötigt werden. Das ist besonders bei der Erzeugung von Berichten, Rechnungen oder formatierten Log-Dateien hilfreich. In der Praxis finden sich diese Formatierungsoptionen häufig bei CLI-Skripten, die tabellarische Daten in der Konsole darstellen müssen.
Praktische Beispiele
Die Theorie der Formatstrings wird erst durch konkrete Anwendungsfälle greifbar. Die folgenden Beispiele zeigen typische Szenarien, in denen sprintf() seine Stärke ausspielt.
Zahlen mit führenden Nullen
Führende Nullen werden häufig bei Rechnungsnummern, Bestellnummern oder Zeitangaben benötigt. Mit sprintf() lassen sie sich elegant erzeugen, indem eine Null als Füllzeichen vor der Mindestbreite angegeben wird.
<?php
$nummer = 42;
echo sprintf('%05d', $nummer); /* 00042 */
$stunden = 9;
$minuten = 5;
echo sprintf('%02d:%02d Uhr', $stunden, $minuten); /* 09:05 Uhr */
Der Platzhalter %05d bedeutet: Gib eine Ganzzahl mit mindestens fünf Stellen aus und fülle fehlende Stellen mit Nullen auf. Bei der Zeitformatierung sorgt %02d dafür, dass einstellige Stunden und Minuten immer zweistellig angezeigt werden. Dieses Muster ist auch bei der Erzeugung von Dateinamen mit fortlaufender Nummerierung praktisch, etwa bild_001.jpg bis bild_999.jpg.
Währungsbeträge formatieren
Bei der Ausgabe von Geldbeträgen müssen immer genau zwei Nachkommastellen angezeigt werden. Das lässt sich mit sprintf() und dem Präzisionsspezifizierer .2f zuverlässig sicherstellen.
<?php
$netto = 84.5;
$mwst = $netto * 0.19;
$brutto = $netto + $mwst;
echo sprintf('Netto: %8.2f Euro', $netto); /* Netto: 84.50 Euro */
echo sprintf('MwSt: %8.2f Euro', $mwst); /* MwSt: 16.06 Euro */
echo sprintf('Brutto: %8.2f Euro', $brutto); /* Brutto: 100.56 Euro */
Durch die Kombination von Mindestbreite (8) und Präzision (.2f) stehen die Beträge sauber untereinander. Das ist besonders nützlich bei der Erzeugung von Rechnungen oder Finanzberichten in der Konsole oder in Textdateien. Für die Ausgabe in HTML-Seiten mit lokalisierter Formatierung (Komma als Dezimaltrennzeichen) ist die Funktion number_format() eine ergänzende Alternative.
Prozentzeichen ausgeben
Da das Prozentzeichen in Formatstrings als Einleitung eines Platzhalters dient, muss es verdoppelt werden, wenn es als normales Zeichen in der Ausgabe erscheinen soll.
<?php
$anteil = 85;
echo sprintf('%d%% der Teilnehmer bestanden', $anteil);
/* 85% der Teilnehmer bestanden */
Die Zeichenfolge %% erzeugt ein einzelnes Prozentzeichen in der Ausgabe. Das ist ein häufiger Stolperstein bei der Arbeit mit Formatstrings. Vergisst man das doppelte Prozentzeichen, interpretiert PHP das folgende Zeichen als Teil eines Platzhalters, was zu unerwarteten Ergebnissen oder Fehlern führt.
Reihenfolge der Argumente festlegen
Standardmäßig werden die Argumente in der Reihenfolge ihres Auftretens den Platzhaltern zugeordnet. Mit positionierten Argumenten lässt sich diese Zuordnung ändern. Dafür wird nach dem Prozentzeichen die Position des Arguments (beginnend bei 1) gefolgt von einem Dollarzeichen angegeben.
<?php
$vorname = 'Max';
$nachname = 'Mustermann';
/* Deutsch: Nachname, Vorname */
echo sprintf('%2$s, %1$s', $vorname, $nachname);
/* Mustermann, Max */
Der Platzhalter %2$s greift auf das zweite Argument zu, %1$s auf das erste. Positionierte Argumente sind besonders wertvoll bei der Internationalisierung von Anwendungen. In manchen Sprachen steht der Nachname vor dem Vornamen, in anderen ist es umgekehrt. Durch positionierte Platzhalter kann derselbe Satz von Argumenten in verschiedenen Formatstrings unterschiedlich angeordnet werden, ohne die Reihenfolge der Funktionsparameter zu verändern. Auch bei Formatstrings, in denen dasselbe Argument mehrfach verwendet werden soll, sind positionierte Platzhalter die Lösung.
<?php
$name = 'PHP';
echo sprintf('%1$s ist beliebt. %1$s ist vielseitig.', $name);
/* PHP ist beliebt. PHP ist vielseitig. */
Durch %1$s wird das erste Argument an beiden Stellen im Formatstring eingesetzt. Ohne positionierte Argumente müsste der Wert zweimal als Parameter übergeben werden.
Neben printf() und sprintf() bietet PHP weitere verwandte Funktionen. Die Funktion fprintf() schreibt den formatierten String direkt in eine Datei oder einen Stream. Die Funktion sscanf() arbeitet in die entgegengesetzte Richtung: Sie liest einen String und extrahiert Werte anhand eines Formatstrings. Die Funktion number_format() ist zwar kein Teil der printf-Familie, wird aber häufig als Ergänzung eingesetzt, wenn lokalisierte Zahlenformate mit Tausendertrennzeichen benötigt werden. Auch vsprintf() verdient Erwähnung: Sie funktioniert wie sprintf(), erwartet die Argumente aber als Array statt als einzelne Parameter. Das ist praktisch, wenn die Anzahl der Argumente zur Laufzeit variiert.
<?php
$werte = ['PHP', 8, 3.5];
$formatiert = vsprintf('Sprache: %s, Version: %d, Bewertung: %.1f', $werte);
echo $formatiert; /* Sprache: PHP, Version: 8, Bewertung: 3.5 */
Fazit
Die Funktionen printf() und sprintf() sind leistungsstarke Werkzeuge für die formatierte Ausgabe in PHP. Während printf() das Ergebnis direkt ausgibt, liefert sprintf() den formatierten String als Rückgabewert zurück und ist damit in der Praxis die flexiblere Wahl. Mit Typspezifizierern wie %s, %d und %f lassen sich Strings, Ganzzahlen und Gleitkommazahlen gezielt formatieren. Die Kombination aus Mindestbreite, Präzision und Füllzeichen ermöglicht präzise Kontrolle über das Erscheinungsbild der Ausgabe. Führende Nullen, feste Dezimalstellen und tabellarische Ausrichtung sind damit problemlos umsetzbar. Positionierte Argumente runden den Funktionsumfang ab und machen sprintf() besonders für mehrsprachige Anwendungen wertvoll. Wer diese Funktionen beherrscht, kann auf umständliche String-Verkettungen verzichten und stattdessen sauberen, gut lesbaren Code schreiben.
