PHP
Variablen

Syntax

• $ variable = 'Wert'; // Allgemeine Variable zuweisen
• $ object-> property = 'value'; // Weisen Sie eine Objekteigenschaft zu
• ClassName :: $ property = 'value'; // Weisen Sie eine statische Klasseneigenschaft zu
• $ array [0] = 'value'; // Weisen Sie einem Index eines Arrays einen Wert zu
• $ array [] = 'value'; // Drücke ein Element am Ende eines Arrays
• $ array ['key'] = 'value'; // Einen Arraywert zuweisen
• echo $ variable; // Einen variablen Wert ausgeben (drucken)
• some_function ($ variable); // Variable als Funktionsparameter verwenden
• unset ($ variable); // Setze eine Variable
• $$ Variable = 'Wert'; // Zuweisung einer Variablenvariablen
• isset ($ variable); // Prüfen Sie, ob eine Variable gesetzt ist oder nicht
• leer ($ variable); // Prüfen Sie, ob eine Variable leer ist oder nicht

Bemerkungen

<?php

/**
 * Juggle numbers and return true if juggling was
 * a great success.
 */
function numberJuggling(int $a, int $b) : bool
{
    $sum = $a + $b;

    return $sum % 2 === 0;
}

<?php
declare('strict_types=1');

Dynamischer Zugriff auf eine Variable nach Namen (Variablenvariablen)

Auf Variablen kann über dynamische Variablennamen zugegriffen werden. Der Name einer Variablen kann in einer anderen Variablen gespeichert werden, so dass auf sie dynamisch zugegriffen werden kann. Solche Variablen werden als Variablenvariablen bezeichnet.

Um aus einer Variablen eine Variable zu machen, setzen Sie einen zusätzlichen $ put vor Ihre Variable.

$variableName = 'foo';
$foo = 'bar';

// The following are all equivalent, and all output "bar":
echo $foo;
echo ${$variableName};
echo $$variableName;

//similarly,
$variableName  = 'foo';
$$variableName = 'bar';

// The following statements will also output 'bar'
echo $foo; 
echo $$variableName; 
echo ${$variableName};

Variablenvariablen sind nützlich, um Funktions- / Methodenaufrufe abzubilden:

function add($a, $b) {
    return $a + $b;
}

$funcName = 'add';

echo $funcName(1, 2); // outputs 3

Dies ist besonders hilfreich in PHP-Klassen:

class myClass {
    public function __construct() {
        $functionName = 'doSomething';
        $this->$functionName('Hello World');
    }

    private function doSomething($string) {
        echo $string; // Outputs "Hello World"
    }
}

Es ist möglich, aber nicht erforderlich, $variableName zwischen {} :

${$variableName} = $value;

Die folgenden Beispiele sind gleichwertig und geben "baz" aus:

$fooBar = 'baz';
$varPrefix = 'foo';

echo $fooBar;               // Outputs "baz"
echo ${$varPrefix . 'Bar'}; // Also outputs "baz"

Die Verwendung von {} ist nur dann obligatorisch, wenn der Name der Variablen selbst ein Ausdruck ist, wie folgt:

${$variableNamePart1 . $variableNamePart2} = $value;

Es wird jedoch empfohlen, immer {} , da es besser lesbar ist.

Dies wird zwar nicht empfohlen, es ist jedoch möglich, dieses Verhalten zu verketten:

$$$$$$$$DoNotTryThisAtHomeKids = $value;

Es ist wichtig zu wissen, dass die übermäßige Verwendung von Variablenvariablen von vielen Entwicklern als schlechte Praxis betrachtet wird. Da sie sich nicht gut für die statische Analyse durch moderne IDEs eignen, können große Codebasen mit vielen Variablenvariablen (oder dynamischen Methodenaufrufen) schnell schwer zu warten sein.

Unterschiede zwischen PHP5 und PHP7

Ein weiterer Grund, immer {} oder () , ist der etwas andere Umgang mit dynamischen Variablen in PHP5 und PHP7, was in einigen Fällen zu einem anderen Ergebnis führt.

In PHP7 werden dynamische Variablen, Eigenschaften und Methoden jetzt strikt in der Reihenfolge von links nach rechts ausgewertet, im Gegensatz zur Kombination von Spezialfällen in PHP5. Die folgenden Beispiele zeigen, wie sich die Reihenfolge der Auswertung geändert hat.

Fall 1: $$foo['bar']['baz']

• PHP5-Interpretation: ${$foo['bar']['baz']}
• PHP7-Interpretation: ($$foo)['bar']['baz']

Fall 2: $foo->$bar['baz']

• PHP5-Interpretation: $foo->{$bar['baz']}
• PHP7-Interpretation: ($foo->$bar)['baz']

Fall 3: $foo->$bar['baz']()

• PHP5-Interpretation: $foo->{$bar['baz']}()
• PHP7-Interpretation: ($foo->$bar)['baz']()

Fall 4: Foo::$bar['baz']()

• PHP5-Interpretation: Foo::{$bar['baz']}()
• PHP7-Interpretation: (Foo::$bar)['baz']()

Datentypen

Es gibt verschiedene Datentypen für verschiedene Zwecke. PHP verfügt nicht über explizite Typdefinitionen, der Typ einer Variablen wird jedoch durch den Typ des zugewiesenen Werts oder durch den Typ bestimmt, in den sie umgewandelt wird. Dies ist eine kurze Übersicht über die Typen. Eine ausführliche Dokumentation und Beispiele finden Sie im Thema PHP-Typen .

Es gibt folgende Datentypen in PHP: null, boolean, integer, float, string, object, resource und array.

Null

Jede Variable kann mit Null belegt werden. Es repräsentiert eine Variable ohne Wert.

$foo = null;

Dies macht die Variable ungültig und ihr Wert wäre undefiniert oder ungültig, wenn sie aufgerufen wird. Die Variable wird aus dem Speicher gelöscht und vom Speicherbereiniger gelöscht.

Boolean

Dies ist der einfachste Typ mit nur zwei möglichen Werten.

$foo = true;
$bar = false;

Booleans können verwendet werden, um den Code-Fluss zu steuern.

$foo = true;

if ($foo) {
    echo "true";
} else {
    echo "false";
}

Ganze Zahl

Eine ganze Zahl ist eine ganze Zahl, die positiv oder negativ ist. Es kann mit einer beliebigen Nummernbasis verwendet werden. Die Größe einer Ganzzahl ist plattformabhängig. Vorzeichenlose Ganzzahlen werden von PHP nicht unterstützt.

$foo = -3;  // negative
$foo = 0;   // zero (can also be null or false (as boolean)
$foo = 123; // positive decimal
$bar = 0123; // octal = 83 decimal
$bar = 0xAB; // hexadecimal = 171 decimal
$bar = 0b1010; // binary = 10 decimal
var_dump(0123, 0xAB, 0b1010); // output: int(83) int(171) int(10)

Schweben

Fließkommazahlen, "Doubles" oder einfach "Floats" genannt, sind Dezimalzahlen.

$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;

Array

Ein Array ist wie eine Liste von Werten. Die einfachste Form eines Arrays wird nach Ganzzahl indiziert und nach Index geordnet, wobei das erste Element auf Index 0 liegt.

$foo = array(1, 2, 3); // An array of integers
$bar = ["A", true, 123 => 5]; // Short array syntax, PHP 5.4+

echo $bar[0];    // Returns "A"
echo $bar[1];    // Returns true
echo $bar[123];  // Returns 5
echo $bar[1234]; // Returns null

Arrays können einem Wert auch einen anderen Schlüssel als einen ganzzahligen Index zuordnen. In PHP sind alle Arrays assoziative Arrays hinter den Kulissen. Wenn wir uns jedoch auf ein assoziatives Array beziehen, meinen wir normalerweise eines, das einen oder mehrere Schlüssel enthält, die keine Ganzzahlen sind.

$array = array();
$array["foo"] = "bar";
$array["baz"] = "quux";
$array[42] = "hello";
echo $array["foo"]; // Outputs "bar"
echo $array["bar"]; // Outputs "quux"
echo $array[42]; // Outputs "hello"

String

Eine Zeichenfolge ist wie ein Array von Zeichen.

$foo = "bar";

Wie ein Array kann ein String indiziert werden, um seine einzelnen Zeichen zurückzugeben:

$foo = "bar";
echo $foo[0]; // Prints 'b', the first character of the string in $foo.

Objekt

Ein Objekt ist eine Instanz einer Klasse. Auf seine Variablen und Methoden kann mit dem Operator -> zugegriffen werden.

$foo = new stdClass(); // create new object of class stdClass, which a predefined, empty class
$foo->bar = "baz";
echo $foo->bar; // Outputs "baz"
// Or we can cast an array to an object:
$quux = (object) ["foo" => "bar"];
echo $quux->foo; // This outputs "bar".

Ressource

Ressourcenvariablen enthalten spezielle Handles für geöffnete Dateien, Datenbankverbindungen, Streams, Bereiche der Bildleinwand und dergleichen (wie im Handbuch angegeben ).

$fp = fopen('file.ext', 'r'); // fopen() is the function to open a file on disk as a resource.
var_dump($fp); // output: resource(2) of type (stream)

Um den Typ einer Variablen als Zeichenfolge gettype() , verwenden Sie die Funktion gettype() :

echo gettype(1); // outputs "integer"
echo gettype(true); // "boolean"

Best Practices für globale Variablen

Wir können dieses Problem mit dem folgenden Pseudocode veranschaulichen

function foo() {
    global $bob;
    $bob->doSomething();
}

Ihre erste Frage hier ist offensichtlich

Woher kam $bob ?

Bist du verwirrt? Gut. Sie haben gerade erfahren, warum Globals verwirrend sind und als schlechte Praxis betrachtet werden .

Wenn dies ein echtes Programm wäre, ist der nächste Spaß, alle Instanzen von $bob aufzuspüren und zu hoffen, dass Sie das richtige finden (dies wird noch schlimmer, wenn $bob überall verwendet wird). Schlimmer noch, wenn jemand anderes $bob definiert (oder Sie diese Variable vergessen und wiederverwendet haben), kann Ihr Code beschädigt werden (im obigen Codebeispiel würde ein falsches Objekt oder gar kein Objekt einen schwerwiegenden Fehler verursachen).

Da praktisch alle PHP-Programme Code wie include('file.php'); Ihr Job, der Code wie diesen verwaltet, wird umso exponentiell schwieriger, je mehr Dateien Sie hinzufügen.

Dies macht es auch sehr schwierig, Ihre Anwendungen zu testen. Angenommen, Sie verwenden eine globale Variable, um Ihre Datenbankverbindung zu halten:

$dbConnector = new DBConnector(...);

function doSomething() {
    global $dbConnector;
    $dbConnector->execute("...");
}

Um diese Funktion zu testen, müssen Sie die globale $dbConnector Variable $dbConnector , die Tests ausführen und dann auf ihren ursprünglichen Wert zurücksetzen, was sehr fehleranfällig ist:

/**
 * @test
 */
function testSomething() {
     global $dbConnector;

     $bkp = $dbConnector; // Make backup
     $dbConnector = Mock::create('DBConnector'); // Override

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

Wie vermeiden wir Globals?

Der beste Weg, um globale Werte zu vermeiden, ist eine Philosophie, die als Abhängigkeitsinjektion bezeichnet wird . Hier geben wir die benötigten Werkzeuge in die Funktion oder Klasse ein.

function foo(\Bar $bob) {
    $bob->doSomething();
}

Dies ist viel einfacher zu verstehen und zu pflegen. Es gibt keine Vermutung, wo $bob eingerichtet wurde, da der Anrufer dafür verantwortlich ist (dies passiert uns, was wir wissen müssen). Besser noch, wir können mit Typdeklarationen einschränken, was passiert wird.

Wir wissen also, dass $bob entweder eine Instanz der Bar Klasse oder eine Instanz eines untergeordneten Elements von Bar , was bedeutet, dass wir die Methoden dieser Klasse verwenden können. Kombiniert mit einem Standard-Autoloader (verfügbar seit PHP 5.3) können wir jetzt nachverfolgen, wo Bar definiert ist. PHP 7.0 oder höher enthält erweiterte Typdeklarationen, in denen Sie auch Skalartypen (wie int oder string ) verwenden können.

Alle definierten Variablen abrufen

get_defined_vars() gibt ein Array mit allen Namen und Werten der Variablen zurück, die in dem Bereich definiert sind, in dem die Funktion aufgerufen wird. Wenn Sie Daten drucken möchten, können Sie Standardfunktionen für die Ausgabe von lesbaren Daten wie print_r oder var_dump .

var_dump(get_defined_vars());

Hinweis : Diese Funktion gibt normalerweise nur 4 Superglobals zurück : $_GET , $_POST , $_COOKIE , $_FILES . Andere Superglobals werden nur zurückgegeben, wenn sie irgendwo im Code verwendet wurden. Dies liegt an der auto_globals_jit Direktive, die standardmäßig aktiviert ist. Wenn diese $_SERVER aktiviert ist, werden die Variablen $_SERVER und $_ENV bei der ersten Verwendung (Just In Time) erstellt, anstatt dass das Skript gestartet wird. Wenn diese Variablen nicht in einem Skript verwendet werden, führt die Aktivierung dieser Anweisung zu einer Leistungssteigerung.

Standardwerte von nicht initialisierten Variablen

In PHP ist dies zwar nicht notwendig, es empfiehlt sich jedoch, Variablen zu initialisieren. Nicht initialisierte Variablen haben einen Standardwert ihres Typs, abhängig vom Kontext, in dem sie verwendet werden:

Nicht gesetzt UND nicht referenziert

var_dump($unset_var); // outputs NULL

Boolean

echo($unset_bool ? "true\n" : "false\n"); // outputs 'false' 

String

$unset_str .= 'abc';
var_dump($unset_str); // outputs 'string(3) "abc"'

Ganze Zahl

$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // outputs 'int(25)'

Float / Doppel

$unset_float += 1.25;
var_dump($unset_float); // outputs 'float(1.25)'

Array

$unset_arr[3] = "def";
var_dump($unset_arr); //  outputs array(1) {  [3]=>  string(3) "def" }

Objekt

$unset_obj->foo = 'bar';
var_dump($unset_obj); // Outputs: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

Die Verwendung des Standardwerts einer nicht initialisierten Variablen ist problematisch, wenn eine Datei in eine andere aufgenommen wird, die denselben Variablennamen verwendet.

Variabler Wert Wahrheit und identischer Operator

In PHP haben Variablenwerte eine "Wahrheit", sodass auch nicht-boolesche Werte mit " true oder " false " gleichgesetzt werden. Dadurch kann jede Variable in einem Bedingungsblock verwendet werden, z

if ($var == true) { /* explicit version */ }
if ($var) { /* $var == true is implicit */ }

Hier sind einige grundlegende Regeln für verschiedene Arten von Variablenwerten:

• Zeichenfolgen mit einer Länge ungleich Null entsprechen " true einschließlich Zeichenfolgen, die nur Leerzeichen enthalten, z. B. ' ' .
• Leere Strings '' gleichsetzen zu false .

$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '   ';
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

• Ganzzahlen sind true wenn sie nicht Null sind, während Null gleich false .

$var = -1;
$var_is_true = ($var == true); // true
$var = 99;
$var_is_true = ($var == true); // true
$var = 0;
$var_is_true = ($var == true); // false

• null entspricht false

$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• Leere Zeichenfolgen '' und Nullzeichenfolge '0' entsprechen false .

$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '0';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• Gleitkommawerte entsprechen " true wenn sie nicht Null sind, während Nullwerte " false .
  • NAN (PHP Not-a-Number) entspricht true , dh NAN == true ist true . Dies ist darauf zurückzuführen, dass NAN ein Gleitkommawert ungleich Null ist.
  • Nullwerte umfassen sowohl +0 als auch -0, wie in IEEE 754 definiert. PHP unterscheidet in seinem Gleitkommawert mit doppelter Genauigkeit nicht zwischen +0 und -0, dh floatval('0') == floatval('-0') ist true .
    • In der Tat floatval('0') === floatval('-0') .
    • Außerdem sind floatval('0') == false und floatval('-0') == false .

$var = NAN;
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

$var = floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = floatval('0') == floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

IDENTISCHER BETREIBER

In der PHP-Dokumentation für Vergleichsoperatoren gibt es einen identischen Operator === . Mit diesem Operator kann geprüft werden, ob eine Variable mit einem Referenzwert identisch ist:

$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false

Es hat einen entsprechenden nicht identischen Operator !== :

$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true

Der identische Operator kann als Alternative zu Sprachfunktionen wie is_null() .

CASE WITH mit strpos()

Die strpos($haystack, $needle) wird verwendet, um den Index zu ermitteln, an dem $needle in $haystack , oder ob er überhaupt auftritt. Die Funktion strpos() Groß- und Kleinschreibung. Wenn Sie nicht nach Groß- und Kleinschreibung suchen, können Sie mit stripos($haystack, $needle) gehen stripos($haystack, $needle)

Die Funktion strpos & stripos enthält auch den dritten Parameter offset (int). Wenn diese stripos angegeben ist, beginnt die Suche mit dieser Anzahl von Zeichen, die vom Anfang des Strings gezählt werden. Im Gegensatz zu Strrpos und Strripos kann der Versatz nicht negativ sein

Die Funktion kann zurückgeben:

• 0 wenn $needle am Anfang von $haystack ;
• eine ganze Zahl ungleich Null, die den Index angibt, wenn $needle anderen Ort als dem Anfang in $haystack ;
• und der Wert false , wenn $needle nicht überall gefunden $haystack .

Da beide 0 und false Iness haben false in PHP aber repräsentieren unterschiedliche Situationen für strpos() , ist es wichtig , zwischen ihnen und verwenden Sie den identischen Operator zu unterscheiden === sehen genau für false und nicht nur einen Wert, der zu gleichsetzt false .

$idx = substr($haystack, $needle);
if ($idx === false) 
{
    // logic for when $needle not found in $haystack
} 
else
{
    // logic for when $needle found in $haystack
}

Alternativ können Sie den nicht identischen Operator verwenden:

$idx = substr($haystack, $needle);
if ($idx !== false) 
{
    // logic for when $needle found in $haystack
} 
else
{
    // logic for when $needle not found in $haystack
}