Suche…
Ganzzahlen
Integer-Werte in PHP können in Basis 2 (binär), Basis 8 (Oktal), Basis 10 (Dezimal) oder Basis 16 (Hexadezimal) nativ angegeben werden.
$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;
echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42
Ganze Zahlen sind je nach Plattform 32 oder 64 Bit lang. Die Konstante PHP_INT_SIZE die Ganzzahl in Byte. PHP_INT_MAX und (seit PHP 7.0) PHP_INT_MIN sind ebenfalls verfügbar.
printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);
Integer-Werte werden bei Bedarf automatisch aus Floats, Booleans und Strings erstellt. Wenn eine explizite Typumwandlung erforderlich ist, kann dies mit der (int) oder (integer) :
$my_numeric_string = "123";
var_dump($my_numeric_string);
// Output: string(3) "123"
$my_integer = (int)$my_numeric_string;
var_dump($my_integer);
// Output: int(123)
Integer-Überlauf wird durch die Umwandlung in einen Float-Wert behandelt:
$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)
Es gibt keinen ganzzahligen Divisionsoperator in PHP, er kann jedoch mit einer impliziten Umwandlung simuliert werden, die immer "rundet", indem der Float-Part einfach gelöscht wird. Ab PHP Version 7 wurde eine Ganzzahl-Divisionsfunktion hinzugefügt.
$not_an_integer = 25 / 4;
var_dump($not_an_integer);
// Output: float(6.25)
var_dump((int) (25 / 4)); // (see note below)
// Output: int(6)
var_dump(intdiv(25 / 4)); // as of PHP7
// Output: int(6)
(Beachten Sie, dass die zusätzlichen Klammern um (25 / 4) benötigt werden, da der (int) -Stich eine höhere Priorität als die Division hat.)
Zeichenketten
Eine Zeichenfolge in PHP besteht aus einer Reihe von Einzelbyte-Zeichen (dh es gibt keine native Unicode-Unterstützung), die auf vier Arten angegeben werden kann:
Einzeln zitiert
Zeigt die Dinge fast vollständig "wie sie ist" an. Variablen und die meisten Escape-Sequenzen werden nicht interpretiert. Die Ausnahme ist, dass zur Anzeige eines wörtlichen einfachen Anführungszeichens das Symbol mit einem Backslash 'und einem Backslash mit einem anderen Backslash \ entkommen kann.
$my_string = 'Nothing is parsed, except an escap\'d apostrophe or backslash. $foo\n';
var_dump($my_string);
/*
string(68) "Nothing is parsed, except an escap'd apostrophe or backslash. $foo\n"
*/
Doppelter Anführungsstrich
Im Gegensatz zu einem String mit einfachen Anführungszeichen werden einfache Variablennamen und Escape-Sequenzen in den Strings ausgewertet. Geschweifte Klammern (wie im letzten Beispiel) können verwendet werden, um komplexe Variablennamen zu isolieren.
$variable1 = "Testing!";
$variable2 = [ "Testing?", [ "Failure", "Success" ] ];
$my_string = "Variables and escape characters are parsed:\n\n";
$my_string .= "$variable1\n\n$variable2[0]\n\n";
$my_string .= "There are limits: $variable2[1][0]";
$my_string .= "But we can get around them by wrapping the whole variable in braces: {$variable2[1][1]}";
var_dump($my_string);
/*
string(98) "Variables and escape characters are parsed:
Testing!
Testing?
There are limits: Array[0]"
But we can get around them by wrapping the whole variable in braces: Success
*/
Heredoc
In einer Heredoc-Zeichenfolge werden Variablennamen und Escape-Sequenzen auf ähnliche Weise analysiert wie in doppelten Anführungszeichen, obwohl für komplexe Variablennamen keine geschweiften Klammern verfügbar sind. Der Anfang der Zeichenfolge wird durch abgegrenzt <<< identifier und das Ende durch identifier , wo identifier ist ein beliebiger gültige PHP Namen. Die Endekennung muss in einer eigenen Zeile stehen. Vor oder nach dem Bezeichner ist kein Leerzeichen zulässig, obwohl es wie jede Zeile in PHP auch mit einem Semikolon abgeschlossen werden muss.
$variable1 = "Including text blocks is easier";
$my_string = <<< EOF
Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. $variable1; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends.
EOF;
var_dump($my_string);
/*
string(268) "Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. Including text blocks is easier; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends."
*/
Nowdoc
Ein nowdoc-String ist wie die einfach zitierte Version von heredoc, obwohl nicht einmal die grundlegendsten Escape-Sequenzen ausgewertet werden. Der Bezeichner am Anfang der Zeichenfolge wird in einfache Anführungszeichen gesetzt.
$my_string = <<< 'EOF'
A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)
EOF;
var_dump($my_string);
/*
string(116) "A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)"
*/
Boolean
Boolean ist ein Typ mit zwei Werten, die als true oder false .
Dieser Code setzt den Wert von $foo auf true und $bar auf false :
$foo = true;
$bar = false;
true und false unterscheiden nicht zwischen Groß- und Kleinschreibung, daher können auch TRUE und FALSE verwendet werden, sogar FaLsE ist möglich. Kleinbuchstaben werden am häufigsten verwendet und in den meisten Code-Style-Guides empfohlen, z. B. PSR-2 .
Booleans können in if-Anweisungen wie folgt verwendet werden:
if ($foo) { //same as evaluating if($foo == true)
echo "true";
}
Aufgrund der Tatsache, dass PHP schwach typisiert ist, wird $foo , wenn es nicht true oder false , automatisch zu einem booleschen Wert gezwungen.
Die folgenden Werte führen zu false :
- ein Nullwert:
0(Ganzzahl),0.0(Float) oder'0'(String) - eine leere Zeichenfolge
''oder ein Array[] -
null(der Inhalt einer nicht festgelegten Variablen oder einer Variablen zugewiesen)
Jeder andere Wert ergibt true .
Um diesen losen Vergleich zu vermeiden, können Sie einen starken Vergleich mit === , wobei Wert und Typ verglichen werden. Siehe Typenvergleich für weitere Einzelheiten.
Um einen Typ in Boolean zu konvertieren, können Sie den Cast (boolean) (bool) oder (boolean) vor dem Typ verwenden.
var_dump((bool) "1"); //evaluates to true
oder rufen Sie die boolval Funktion auf:
var_dump( boolval("1") ); //evaluates to true
Boolesche Konvertierung in einen String (Beachten Sie, dass false einen leeren String ergibt):
var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""
Boolesche Konvertierung in eine Ganzzahl:
var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)
Beachten Sie, dass auch das Gegenteil möglich ist:
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
Auch alle Nicht-Null-Werte geben true zurück:
var_dump((bool) -2); // bool(true)
var_dump((bool) "foo"); // bool(true)
var_dump((bool) 2.3e5); // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array()); // bool(false)
var_dump((bool) "false"); // bool(true)
Schweben
$float = 0.123;
Aus historischen Gründen wird "double" von
gettype()im Falle eines Float zurückgegeben und nicht einfach "float".
Floats sind Fließkommazahlen, die eine höhere Ausgabegenauigkeit als einfache Ganzzahlen ermöglichen.
Floats und Ganzzahlen können zusammen verwendet werden, da PHP die Variablentypen lose ausgibt:
$sum = 3 + 0.14;
echo $sum; // 3.14
PHP zeigt Float nicht wie andere Sprachen an, zum Beispiel:
$var = 1;
echo ((float) $var); //returns 1 not 1.0
Warnung
Fließkomma-Präzision
(Von der PHP-Handbuchseite )
Fließkommazahlen haben eine begrenzte Genauigkeit. Obwohl dies vom System abhängig ist, gibt PHP normalerweise einen maximalen relativen Fehler aufgrund von Rundungen in der Größenordnung von 1,11e-16 aus. Nicht elementare Rechenoperationen geben können größere Fehler und Fehlerfortpflanzung muss berücksichtigt werden , wenn mehrere Operationen zusammengesetzt sind.
Außerdem haben rationale Zahlen, die als Fließkommazahlen in der Basis 10 genau dargestellt werden können, wie 0,1 oder 0,7, keine genaue Darstellung als Fließkommazahlen in der Basis 2 (binär), die unabhängig von der Mantissengröße intern verwendet werden . Daher können sie nicht ohne einen geringen Genauigkeitsverlust in ihre internen binären Gegenstücke umgewandelt werden. Dies kann zu verwirrenden Ergebnissen führen: Zum Beispiel gibt floor ((0,1 + 0,7) * 10) normalerweise 7 anstelle der erwarteten 8 zurück, da die interne Darstellung etwa 7,9999999999999991118 beträgt.
Vertrauen Sie also niemals den Ergebnissen der Gleitkommazahlen auf die letzte Ziffer und vergleichen Sie Gleitkommazahlen nicht direkt auf Gleichheit. Wenn eine höhere Genauigkeit erforderlich ist, sind die mathematischen Funktionen mit beliebiger Genauigkeit und die gmp-Funktionen verfügbar.
Abrufbar
Callables sind alles, was als Rückruf bezeichnet werden kann. Dinge, die als "Rückruf" bezeichnet werden können, lauten wie folgt:
Anonyme Funktionen
Standard-PHP-Funktionen (Hinweis: keine Sprachkonstrukte )
Statische Klassen
nicht statische Klassen (unter Verwendung einer alternativen Syntax )
Spezifische Objekt- / Klassenmethoden
Objekte selbst, solange sich das Objekt in Schlüssel
0eines Arrays befindetBeispiel für das Referenzieren eines Objekts als Arrayelement:
$obj = new MyClass();
call_user_func([$obj, 'myCallbackMethod']);
Rückrufe können durch bezeichnet callable Typ Hinweis ab PHP 5.4.
$callable = function () {
return 'value';
};
function call_something(callable $fn) {
call_user_func($fn);
}
call_something($callable);
Null
PHP steht für "no value" mit dem null Schlüsselwort. Er ähnelt dem Nullzeiger in C-Sprache und dem NULL-Wert in SQL.
Die Variable auf null setzen:
$nullvar = null; // directly
function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar
Überprüfen, ob die Variable auf null gesetzt wurde:
if (is_null($nullvar)) { /* variable is null */ }
if ($nullvar === null) { /* variable is null */ }
Null gegen undefinierte Variable
Wenn die Variable nicht definiert oder nicht gesetzt wurde, sind alle Tests gegen die Null erfolgreich, sie generieren jedoch eine Notice: Undefined variable: nullvar : Notice: Undefined variable: nullvar :
$nullvar = null;
unset($nullvar);
if ($nullvar === null) { /* true but also a Notice is printed */ }
if (is_null($nullvar)) { /* true but also a Notice is printed */ }
Deshalb müssen undefinierte Werte mit isset überprüft isset :
if (!isset($nullvar)) { /* variable is null or is not even defined */ }
Typvergleich
Es gibt zwei Arten von Vergleichen : einen losen Vergleich mit == und einen strengen Vergleich mit === . Ein strikter Vergleich stellt sicher, dass sowohl der Typ als auch der Wert beider Bedienerseiten gleich sind.
// Loose comparisons
var_dump(1 == 1); // true
var_dump(1 == "1"); // true
var_dump(1 == true); // true
var_dump(0 == false); // true
// Strict comparisons
var_dump(1 === 1); // true
var_dump(1 === "1"); // false
var_dump(1 === true); // false
var_dump(0 === false); // false
// Notable exception: NAN — it never is equal to anything
var_dump(NAN == NAN); // false
var_dump(NAN === NAN); // false
Sie können einen starken Vergleich auch verwenden, um zu überprüfen, ob Typ und Wert mit !== nicht übereinstimmen.
Ein typisches Beispiel, bei dem der Operator == nicht ausreicht, sind Funktionen, die verschiedene Typen zurückgeben können, z. B. strpos searchword den searchword false wenn das searchword nicht gefunden wird, und die Übereinstimmungsposition ( int ).
if(strpos('text', 'searchword') == false)
// strpos returns false, so == comparison works as expected here, BUT:
if(strpos('text bla', 'text') == false)
// strpos returns 0 (found match at position 0) and 0==false is true.
// This is probably not what you expect!
if(strpos('text','text') === false)
// strpos returns 0, and 0===false is false, so this works as expected.
Geben Sie Casting ein
In der Regel wird PHP den Datentyp, den Sie verwenden möchten, aus dem Kontext, in dem es verwendet wird, richtig erraten. Manchmal ist es jedoch hilfreich, einen Typ manuell zu erzwingen. Dies kann erreicht werden, indem der Deklaration der Name des erforderlichen Typs in Klammern vorangestellt wird:
$bool = true;
var_dump($bool); // bool(true)
$int = (int) true;
var_dump($int); // int(1)
$string = (string) true;
var_dump($string); // string(1) "1"
$string = (string) false;
var_dump($string); // string(0) ""
$float = (float) true;
var_dump($float); // float(1)
$array = ['x' => 'y'];
var_dump((object) $array); // object(stdClass)#1 (1) { ["x"]=> string(1) "y" }
$object = new stdClass();
$object->x = 'y';
var_dump((array) $object); // array(1) { ["x"]=> string(1) "y" }
$string = "asdf";
var_dump((unset)$string); // NULL
Aber Achtung: Nicht alle Typen wirken so, wie man es erwarten könnte:
// below 3 statements hold for 32-bits systems (PHP_INT_MAX=2147483647)
// an integer value bigger than PHP_INT_MAX is automatically converted to float:
var_dump( 999888777666 ); // float(999888777666)
// forcing to (int) gives overflow:
var_dump((int) 999888777666 ); // int(-838602302)
// but in a string it just returns PHP_INT_MAX
var_dump((int) "999888777666"); // int(2147483647)
var_dump((bool) []); // bool(false) (empty array)
var_dump((bool) [false]); // bool(true) (non-empty array)
Ressourcen
Eine Ressource ist ein spezieller Variablentyp, der auf eine externe Ressource verweist, beispielsweise eine Datei, einen Socket, einen Stream, ein Dokument oder eine Verbindung.
$file = fopen('/etc/passwd', 'r');
echo gettype($file);
# Out: resource
echo $file;
# Out: Resource id #2
Es gibt verschiedene (Unter-) Ressourcentypen. Sie können den Ressourcentyp mit get_resource_type() überprüfen:
$file = fopen('/etc/passwd', 'r');
echo get_resource_type($file);
#Out: stream
$sock = fsockopen('www.google.com', 80);
echo get_resource_type($sock);
#Out: stream
Eine vollständige Liste der integrierten Ressourcentypen finden Sie hier .
Geben Sie Jonglieren ein
PHP ist eine schwach typisierte Sprache. Es ist keine explizite Deklaration von Datentypen erforderlich. Der Kontext, in dem die Variable verwendet wird, bestimmt ihren Datentyp. Die Konvertierung erfolgt automatisch:
$a = "2"; // string
$a = $a + 2; // integer (4)
$a = $a + 0.5; // float (4.5)
$a = 1 + "2 oranges"; // integer (3)
