Andere Datentypen in Strings umwandeln (Thema: PHP Beispiele)

Beschreibung der Möglichkeiten, um z.B. Integers oder Floats in Strings umzuwandeln

1. Integer in String umwandeln


Um Variablen des Datentyps „Integer” in Strings umzuwandeln können folgende Möglichkeiten verwendet werden:
  • Die Funktion strval() auf den Integer anwenden. Diese gibt einen String zurück.
  • Einen Typecast zu String mit (string)$int durchführen.
  • Den Integer mit einem beliebigen String verknüpfen: $str = '' . $int;. Der Integer-Wert wird dann automatisch in String umgewandelt.
  • Die Funktion settype(&$var, $type) verwenden mit $type = 'string'.
Der Weg über settype() ist unschön und sollte daher möglichst nicht verwendet werden.

PHP-Code
<?php
	$int = 1001;
	var_dump(strval($int));
	var_dump((string)$int);
	var_dump('' . $int); // analog würde auch funktionieren: var_dump("$int");
	settype($int, 'string');
	var_dump($int);

	// Die Verknüpfung mit einem String ist besonders dann nützlich, wenn
	// man den Integer-Wert ohnehin in einem String einfügen will.
	$int = 1001;
	echo('Geschichten aus ' . $int . ' Nacht.');
	echo("Geschichten aus $int Nacht."); // automatisches Parsing von Variablen bei doppelten Anführungszeichen
?>
Ausgabe
string(4) "1001"
string(4) "1001"
string(4) "1001"
string(4) "1001"
Geschichten aus 1001 Nacht.Geschichten aus 1001 Nacht.

Sollen die Tausenderstellen des Integers per Punkt getrennt werden (z. B. „100.000”), kann number_format($int, 0, ',', '.') dazu verwendet werden.
PHP-Code
<?php
	$int = 1000000;
	$str = number_format($int, 0, ',', '.'); // die Funktion wandelt den Integer-Wert auch gleich in einen String um
	var_dump($int);
	var_dump((string)$int);
	var_dump($str);
?>
Ausgabe
int(1000000)
string(7) "1000000"
string(9) "1.000.000"

2. Float in String umwandeln


Die Konvertierung von Float zum Datentyp String erfolgt analog zur vorherigen Umwandlung (Integer zu String).
Es gibt wieder folgende Möglichkeiten:
  • strval($float): Die Funktion gibt den Float-Wert als String zurück.
  • (string)$float: Typecast zu String.
  • Verknüpfung mit String: Über $str = '' . $float (oder $str = "$float").
  • settype(&$var, $type): Ändert den Datentyp der Variable. $type muss auf "string" gesetzt werden. Die vorherigen Methoden sind settype() vorzuziehen.

Floats können sehr viele Nachkommastellen haben, die bei der Ausgabe eventuell nicht erwünscht sind.
Die Anwendung von round($float, $nachkommastellen) kann sich daher lohnen, um die Nachkommastellen auf eine angemessene Anzahl zu begrenzen.
Möglich ist auch wieder die Verwendung von number_format($float, $nachkommastellen, $nachkomma_trennzeichen, $tausender_trennzeichen).
Entsprechend des zweiten Parameters ($nachkommastellen) rundet die Funktion bei der Umwandlung automatisch.
PHP-Code
<?php
	$float = 5.423849372894323248923;
	var_dump(strval($float));
	var_dump((string)$float);
	var_dump('' . $float);
	$tmp = $float;
	settype($tmp, 'string');
	var_dump($tmp);

	// runden mit round()
	var_dump(strval(round($float, 2)));

	// runden und Formatierung mit number_format()
	$formated = number_format($float, 2, ',', '.');
	var_dump($formated);
?>
Ausgabe
string(15) "5.4238493728943"
string(15) "5.4238493728943"
string(15) "5.4238493728943"
string(15) "5.4238493728943"
string(4) "5.42"
string(4) "5,42"

3. Boolean in String umwandeln


Auch für die Umwandlung von Boolean nach String stehen die zuvor genannten Möglichkeiten zur Verfügung.
  • strval($bool): Wandelt auch Booleans in einen String um und gibt diesen zurück.
  • (string)$bool: Typecast nach Boolean.
  • Verknüpfung mit String: Sowohl $str = '' . $bool als auch $str = "$bool" (und ähnliche Schreibweisen) funktionieren.
  • settype(&$var, $type): Änderung des Datentyps der Variable, $type muss wieder auf "string" gesetzt sein. Auch hier gilt, dass die vorherigen Methoden vorzuziehen sind.
Bei der Umwandlung ist allerdings zu beachten, dass alle zuvor genannten Methoden den Wert (bool)true in (string)"1" und den Wert (bool)false in (string)"" (!) umwandeln. Man erhält also nicht "true" und "false" (jeweils als Strings) und die normale String-Repräsentation von (bool)false ist nicht intuitiv. Um dieses Problem zu umgehen kann zum Beispiel eine if-else-Abfrage verwendet werden.
PHP-Code
<?php
	$boolTrue = true;
	$boolFalse = false;
	
	// Tests mit true
	var_dump(strval($boolTrue));
	var_dump((string)$boolTrue);
	var_dump('' . $boolTrue);
	$tmp = $boolTrue;
	settype($tmp, 'string');
	var_dump($tmp);

	// Tests mit false
	var_dump(strval($boolFalse));
	var_dump((string)$boolFalse);
	var_dump('' . $boolFalse);
	$tmp = $boolFalse;
	settype($tmp, 'string');
	var_dump($tmp);	
	
	// Umwandlung mit if-else
	$var = $boolFalse;
	if ($var) {
		$var = 'true';
	} else {
		$var = 'false';
	}
	var_dump($var);

	// Identisch mit dem vorherigen if-else, aber dafür etwas kürzer ist der folgende bedingte Ausdruck
	$var = ($boolFalse) ? 'true' : 'false'; // Wenn $boolFalse true ist, dann weise $var 'true' zu, sonst weise $var 'false' zu
	var_dump($var);
?>
Ausgabe
string(1) "1"
string(1) "1"
string(1) "1"
string(1) "1"
string(0) ""
string(0) ""
string(0) ""
string(0) ""
string(5) "false"
string(5) "false"

4. Eindimensionales Array in String umwandeln


Sofern alle Werte in einem Array skalar (also String, Integer, Float oder Boolean) sind, kann dieses Array mit implode($glue, $arr) in einen String umgewandelt werden. Dabei ist der Parameter $arr das Array und $glue eine Zeichenkette mit der die Werte getrennt werden sollen. implode(', ', $arr) erzeugt zum Beispiel einen mit Kommata getrennten String.
PHP-Code
<?php
	$arr = array('eins', 15, 3.141, false, 'foo');
	var_dump(implode(', ', $arr));
?>
Ausgabe
string(22) "eins, 15, 3.141, , foo"

Durch implode() gehen die Schlüssel des Arrays verloren. Sollen sie beibehalten werden, dann kann eine foreach-Schleife oder array_map($callback, $arr1, [$arr2, ...]) oder array_walk($array, $callback) oder alternativ die Funktion http_build_query($arr, '', ', ') verwendet werden.
PHP-Code
<?php
	$arr = array('januar'=>'jan', 'februar'=>'feb');
	$glue = ', ';	


	// foreach
	$str = '';
	foreach ($arr as $key=>$val) {
		$str .= "$key: $val$glue";
	}
	// foreach platziert am Ende ein Mal ", " zu viel, welches hier weggekürzt wird
	$str = ($str!=='') ? mb_substr($str, 0, -mb_strlen($glue)) : $str;
	var_dump($str);


	// array_map()
	$arr2 = $arr;
	$callback = function($key, $val) {
		return "$key: $val";
	};
	$arr3 = array_map($callback, array_keys($arr2), array_values($arr2));
	var_dump(implode($glue, $arr3));


	// array_walk()
	$arr2 = $arr;
	$str = '';
	$callback = function($val, $key) use (&$str, $glue) {
		$str .= "$key: $val$glue";
	};
	array_walk($arr2, $callback);
	$str = ($str!=='') ? mb_substr($str, 0, -mb_strlen($glue)) : $str; // letztes Komma wird wieder entfernt
	var_dump($str);


	// http_build_query()
	// Die Schreibweise lautet bei dieser Funktion immer $key=$value und
	// lässt sich nicht ändern (z.B. zu $key: $value)
	var_dump(http_build_query($arr, '', $glue));
?>
Ausgabe
string(25) "januar: jan, februar: feb"
string(25) "januar: jan, februar: feb"
string(25) "januar: jan, februar: feb"
string(23) "januar=jan, februar=feb"

Arrays oder Objekte oder andere nicht skalare Datentypen können in den oben aufgeführten Funktionen Warnungen oder unschön aussehende Ergebnisse erzeugen. Zudem wird (bool)false stets in (string)"" umgewandelt. Um diese Probleme zu verhindern, kann der Datentyp abgefragt werden, hier beispielhaft mit einer foreach-Schleife gezeigt:
PHP-Code
<?php
	class Test { }
	$arr = array('jan', 'feb', 1000, false, 'test', array(), new Test(), null);
	$str = '';
	$glue = ', ';
	foreach ($arr as $key=>$val) {
		if (!is_scalar($val)) {
			// $val ist nicht Integer, Float, String oder Boolean
			if (is_object($val)) {
				// $val ist ein Objekt
				$arr[$key] = 'object('.get_class($val).')'; // get_class($object) gibt den Namen der Klasse des Objekts zurück
			} else {
				// $val ist nicht skalar und kein Objekt
				$arr[$key] = gettype($val); // gettype($var) gibt den Datentyp der Variable zurück
			}
		} else {
			if (is_bool($val)) {
				// (bool)true wird zu (string)"true" und (bool)false zu (string)"false"
				$arr[$key] = ($val===true) ? 'true' : 'false';
			} else {
				// Wert ist Integer, Float oder String und muss daher nicht geändert werden
				//$arr[$key] = $val;
			}
		}
	}
	var_dump(implode($glue, $arr));
?>
Ausgabe
string(54) "jan, feb, 1000, false, test, array, object(Test), NULL"

5. Mehrdimensionales Array in String umwandeln


Ein mehrdimensionales Array in einen String umzuwandeln ist — im Vergleich zum eindimensionalen Array — wesentlich schwieriger. Die Funktion array_walk_recursive($arr, $callback) ist eine Möglichkeit:
PHP-Code
<?php
	$arr = array('eins', array('zwei', 'drei'), array('hallo', 'foo'));
	$str = '';
	$glue = ', ';
	$cb = function($value, $key) use (&$str, $glue) {
		$str .= "$key: $value$glue";
	};
	array_walk_recursive($arr, $cb);
	$str = ($str!=='') ? mb_substr($str, 0, -mb_strlen($glue)) : $str; // letztes Komma wird wieder entfernt
	var_dump($str);
?>
Ausgabe
string(43) "0: eins, 0: zwei, 1: drei, 0: hallo, 1: foo"

Der Nachteil von array_walk_recursive() ist, dass beim Durchlaufen des Arrays keine Informationen darüber vorliegen, ob der aktuelle Wert in einem Unterarray (oder Unterunterarray usw.) eingeordnet ist. Spezielle Formatierungen auf Basis der „Tiefe” sind dadurch nicht möglich. Eine eigene rekursive Funktion kann hier helfen:
PHP-Code
<?php
	// Eine kurze Funktion, um jeden möglichen Wert des Arrays in einen passenden String umzuwandeln
	function var2str($var) {
		if (is_bool($var)) {
			return ($var) ? 'true' : 'false';
		} else {
			return (is_scalar($var)) ? strval($var) : gettype($var);
		}
	}

	// Die rekursive Funktion, die das Array durchläuft
	function arr2str_recursive($arr, $depth=0) {
		$str = '';
		foreach ($arr as $key=>$val) {
			if (is_array($val)) {
				$str .= arr2str_recursive($val, $depth+1);
			} else {
				$var = var2str($val);
				// Sterne entsprechend der Tiefe und dann $key: $val mit anschließendem Zeilenumbruch
				// z. B. "*** foo: bar"
				$str .= str_repeat('*', $depth+1) . $key . ': ' . $var . "\n";
			}
		}
		return $str;
	}

	$arr = array('eins', array('zwei', 'drei'), null, array('hallo', array(1, 2, 3), 'foo'), 'test');
	var_dump(arr2str_recursive($arr));
?>
Ausgabe
string(91) "*0: eins
**0: zwei
**1: drei
*2: NULL
**0: hallo
***0: 1
***1: 2
***2: 3
**2: foo
*4: test
"

6. Object in String umwandeln


Objekte haben eine spezielle Methode __toString(), um sie in einen String umzuwandeln.
Im Gegensatz zu anderen Programmiersprachen muss diese Methode in PHP zwangsweise implementiert werden, sofern das Objekt in einen String konvertiert werden soll.
Ist eine derartige Methode nicht implementiert und wird die Umwandlung dennoch versucht, hat das einen Fatal Error zur Folge.
PHP-Code
<?php
	// ohne überschriebene __toString()-Methode
	class A { }
	
	// mit überschriebener __toString()-Methode
	class Person {
		private $name;
		public function __construct($name) {
			$this->name = $name;
		}

		public function __toString() {
			return $this->name;
		}
	}
	
	$smith = new Person('John Smith');
	$objA = new A();

	// (string)$smith ruft automatisch die Methode __toString() des Objekts $smith auf,
	// man kann genauso auch $smith->__toString() schreiben
	var_dump((string)$smith);
	var_dump($smith->__toString());
	
	// erzeugt einen Fatal Error, da die Klasse A keine __toString()-Methode hat
	var_dump((string)$objA);
?>
Ausgabe
string(10) "John Smith"
string(10) "John Smith"
<br />
<b>Catchable fatal error</b>:  Object of class A could not be converted to string in <b>PFAD</b> on line <b>26</b><br />
Von der Fehlerbezeichnung „Catchable fatal error” sollte man sich übrigens nicht täuschen lassen: Der Fehler kann nicht mittels try-catch aufgefangen werden.

Kommentare (0)

Von neu nach alt