PHP:
switch ($var) {
case 'foo':
echo 'foo';
break;
case 'bar':
echo 'bar';
break;
case 'baz':
echo 'baz';
break;
default:
echo 'default';
break;
}
// kann so gelesen werden:
if ($var == 'foo') {
echo 'foo';
} elseif ($var == 'bar') {
echo 'bar';
} elseif ($var == 'baz') {
echo 'baz';
} else {
echo 'default';
}
// Man beachte, dass switch per == prüft, nicht typsicher per ===
PHP:
$var = $_GET['something'];
// Wenn $_GET['something'] nicht gesetzt ist, ist $var nun technisch gesehen
// null. Das ist aber schlechter Stil und löst E_STRICT-Notices aus
error_reporting(-1);
ini_set('display_errors', 1);
$var = $_GET['gibts-nicht']; // PHP Notice: Undefined index: gibts-nicht
// Gut:
$var = 'default-wert';
if (isset($_GET['something'])) {
// Überschreiben, falls GET-Wert gesetzt
$var = $_GET['something'];
}
// $var ist nun in jedem Fall mit einem Wert belegt
// Dieser Wert ist ein String oder ein Array (<input name="something[]" value="test">)
// Im Zweifel noch auf den Typ testen:
$var = 'default-wert';
if (isset($_GET['something']) && is_string($_GET['something'])) {
// Überschreiben, falls GET-Wert gesetzt
$var = $_GET['something'];
}
// $var ist nun in jedem Fall ein String
Thomasio schrieb:
Klar, PHP versucht, sofern es einen Anhaltspunkt dafür gibt was der Code da will, automatisch zwischen String und INT zu konvertieren, aber das funktioniert definitiv nicht immer.
Doch, das funktioniert immer. Jeder String in PHP kann in einen Integer umgeformt werden und umgekehrt.
Hintergründe dazu:
PHP: Strings - Manual
Ich habe mal aufgemalt, welche Datentypen problemlos in andere umgeformt werden können und welche nicht:
Code:
nach--> | | | | | | |
|| (bool) | (int) | (float) |(string) | (array) |(object) | (unset) |
von || | | | | | | |
==|=====++=========+=========+=========+=========+=========+=========+=========+
v || | | | | |stdClass | |
boolean || ja | 1 / 0 | 1 / 0 | "1"/"" | array | scalar | NULL |
|| | | | | (bool) | (bool) | |
--------++---------+---------+---------+---------+---------+---------+---------+
|| | | | | |stdClass | |
integer || ja | ja | ja | ja | array | scalar | NULL |
|| | | | | (int) | (int) | |
--------++---------+---------+---------+---------+---------+---------+---------+
|| | | | | |stdClass | |
float || ja | ja | ja | ja | array | scalar | NULL |
|| | | | | (float) | (float) | |
--------++---------+---------+---------+---------+---------+---------+---------+
|| | | | | |stdClass | |
string || ja | ja | ja | ja | array | scalar | NULL |
|| | | | |(string) |(string) | |
--------++---------+---------+---------+---------+---------+---------+---------+
|| |/////////|/////////| | | | |
array || true / |undefined|undefined| "Array" | ja | ja | NULL |
|| false |/////////|/////////| | | | |
--------++---------+---------+---------+=========+---------+---------+---------+
|| |#########|#########|FATALERR|| | | |
object || true |#Notice##|#Notice##|||ODER|||| ja | ja | NULL |
|| |#########|#########|toString|| komplex | | |
--------++---------+---------+---------+=========+---------+---------+---------+
|| |/////////|/////////| | |stdClass | |
resource|| true |undefined|undefined| "Res id | array | scalar | NULL |
|| |/////////|/////////| #<n>" | (undef) | (undef) | |
--------++---------+---------+---------+---------+---------+---------+---------+
|| |/////////|/////////| | | | |
NULL || false |undefined|undefined| "" | array() |stdClass | ja |
|| |/////////|/////////| | | () | |
--------++---------+---------+---------+---------+---------+---------+---------+
Zu Fehlern oder anderen Problemen führen die neun schraffierten Umformungen.
Die Resultate ergeben nicht unbedingt immer Sinn, aber das dürfte nachzuvollziehen sein. Beispielsweise wird jedes Array zu einem String "Array".
Zu größer-als:
PHP:
var_dump(
'1' > '0', // true \
1 > '0', // true |---- Äquivalent zum Resultat von (int) '1' > (int) '0'
'1' > 0 , // true /
(int) '1' > (int) '0'
);
Man kann es auch übertreiben mit der PHP-Automatik.
Ich würde nach Möglichkeit mit festen Datentypen arbeiten und lieber mal explizit typecasten.
PHP:
<?php
$new = 0;
$var = 0;
if (isset($_GET['var']) && !is_array($var)) {
// is_array() sollte hinzugefügt werden, weil ein Typecast array -> int
// ein undefiniertes Ergebnis liefert. De facto wird 0 oder 1 geliefert,
// aber laut Doku ist das nicht definiert, kann sich also ohne vorherige
// Benachrichtigung von einer PHP-Version auf die andere ändern
$var = (int) $_GET['var'];
}
// $var ist nun definitiv vom Typ Integer
// Auf diese Weise werden allerdings sämtliche Eingaben akzeptiert. Falls
// beispielsweise $_GET['var'] = 'Hallo Welt' ausgeschlossen werden soll, muss
// die Eingabe ernsthafter validiert werden. Dazu kann PHPs Filter-Mechanismus
// genutzt werden oder vielleicht auch reguläre Ausdrücke
// - http://de2.php.net/manual/en/book.filter.php
// Vergleicht Integer
if ($var > $new) {
// ...
}
bdt600 schrieb:
Das hast du vollkommen recht, aber PHP ist nicht genügsam, sondern selber schlampig. So manch' ein Quellcode ist dermaßen vermurkst, da würde so ziemlich jeder Compiler ohne Ende meckern. Nur PHP ist so manches wurscht und versucht irgendetwas zu vermuten.
Na ja, schwache Typisierung halt. Mit E_STRICT-Error-Reporting meckert PHP auch gerne mal. Das sollte als Standard angesehen werden.
Umgekehrt kannst du auch „strikt“ typisierten Sprachen vorwerfen, dass sie
string_new = string_var + int_var; zulassen, wobei "+" hier der Konkatenationsoperator sein soll. Sauber wäre:
string_new = string_var + int_to_string(int_var); Da gibt es etliche Beispiele. Stichwörter auch Autoboxing oder Operator überladen. (Aber dann nicht
string1 == string2 zulassen, sondern
string1.equals(string2) wollen, weil man ja so extrem sauber ist. I’m looking at you, Java.)
Die in dieser Hinsicht konsequenteste Sprache, mit der ich bisher gearbeitet habe, war glaube ich Object Pascal (meine Erinnerung mag mich aber trügen).
Andererseits muss man klar festhalten, dass natürlich keine Sau Lust hat, ständig int_to_string() usw. zu tippen, also wirklich explizit zu programmieren.
