PHP
Variabelen

Syntaxis

• $ variable = 'value'; // Wijs algemene variabele toe
• $ object-> property = 'value'; // Wijs een objecteigenschap toe
• ClassName :: $ property = 'value'; // Wijs een statische klasse-eigenschap toe
• $ array [0] = 'waarde'; // Wijs een waarde toe aan een index van een array
• $ array [] = 'waarde'; // Push een item aan het einde van een array
• $ array ['key'] = 'value'; // Wijs een matrixwaarde toe
• echo $ variable; // Echo (print) een variabele waarde
• some_function ($ variable); // Gebruik variabele als functieparameter
• unset ($ variable); // Schakel een variabele uit
• $$ variable = 'value'; // Wijs toe aan een variabele variabele
• isset ($ variable); // Controleer of een variabele is ingesteld of niet
• legen ($ variable); // Controleer of een variabele leeg is of niet

Opmerkingen

<?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');

Dynamisch toegang krijgen tot een variabele op naam (variabele variabelen)

Variabelen zijn toegankelijk via dynamische variabelenamen. De naam van een variabele kan worden opgeslagen in een andere variabele, waardoor deze dynamisch toegankelijk is. Dergelijke variabelen staan bekend als variabele variabelen.

Om van een variabele een variabele variabele te maken, plaatst u een extra $ put voor uw variabele.

$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};

Variabele variabelen zijn handig voor het toewijzen van functie / methode-aanroepen:

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

$funcName = 'add';

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

Dit wordt vooral handig in PHP-klassen:

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

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

Het is mogelijk, maar niet verplicht om $variableName tussen {} :

${$variableName} = $value;

De volgende voorbeelden zijn zowel equivalent als uitvoer "baz":

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

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

Het gebruik van {} is alleen verplicht als de naam van de variabele zelf een uitdrukking is, zoals deze:

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

Het wordt echter aanbevolen om altijd {} , omdat het beter leesbaar is.

Hoewel het niet wordt aanbevolen om dit te doen, is het mogelijk om dit gedrag te koppelen:

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

Het is belangrijk op te merken dat het overmatig gebruik van variabele variabelen door veel ontwikkelaars als een slechte gewoonte wordt beschouwd. Omdat ze niet goed geschikt zijn voor statische analyse door moderne IDE's, kunnen grote codebases met veel variabele variabelen (of dynamische methode-invocaties) snel moeilijk te onderhouden worden.

Verschillen tussen PHP5 en PHP7

Een andere reden om altijd {} of () , is dat PHP5 en PHP7 een iets andere manier hebben om met dynamische variabelen om te gaan, wat in sommige gevallen tot een ander resultaat leidt.

In PHP7 worden dynamische variabelen, eigenschappen en methoden nu strikt van links naar rechts geëvalueerd, in tegenstelling tot de combinatie van speciale gevallen in PHP5. De onderstaande voorbeelden laten zien hoe de volgorde van evaluatie is veranderd.

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

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

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

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

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

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

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

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

Gegevenstypen

Er zijn verschillende gegevenstypen voor verschillende doeleinden. PHP heeft geen expliciete typedefinities, maar het type van een variabele wordt bepaald door het type van de waarde dat wordt toegewezen, of door het type waarnaar het wordt gecast. Dit is een kort overzicht van de typen, voor een gedetailleerde documentatie en voorbeelden, zie het onderwerp PHP-typen .

Er zijn de volgende gegevenstypen in PHP: null, boolean, integer, float, string, object, resource en array.

Nul

Null kan aan elke variabele worden toegewezen. Het vertegenwoordigt een variabele zonder waarde.

$foo = null;

Dit maakt de variabele ongeldig en de waarde ervan zou ongedefinieerd of ongeldig zijn als deze wordt aangeroepen. De variabele wordt uit het geheugen gewist en door de vuilnisman verwijderd.

Boolean

Dit is het eenvoudigste type met slechts twee mogelijke waarden.

$foo = true;
$bar = false;

Booleans kunnen worden gebruikt om de codestroom te regelen.

$foo = true;

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

Geheel getal

Een geheel getal is een geheel getal positief of negatief. Het kan worden gebruikt met elke nummerbasis. De grootte van een geheel getal is platformafhankelijk. PHP ondersteunt geen niet-ondertekende gehele getallen.

$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)

Vlotter

Drijvende-kommagetallen, "dubbels" of eenvoudigweg "drijvers" genoemd zijn decimale getallen.

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

reeks

Een array is als een zoeklijst. De eenvoudigste vorm van een array wordt geïndexeerd door geheel getal en geordend door de index, waarbij het eerste element op index 0 ligt.

$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 kunnen ook een andere sleutel dan een integerindex aan een waarde koppelen. In PHP zijn alle arrays associatieve arrays achter de schermen, maar als we duidelijk naar een 'associatieve array' verwijzen, bedoelen we meestal een die een of meer sleutels bevat die geen gehele getallen zijn.

$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"

Draad

Een tekenreeks is als een reeks tekens.

$foo = "bar";

Net als een array kan een string worden geïndexeerd om de afzonderlijke tekens terug te geven:

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

Voorwerp

Een object is een instantie van een klasse. De variabelen en methoden zijn toegankelijk met de -> operator.

$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".

hulpbron

Bronvariabelen bevatten speciale handvatten voor geopende bestanden, databaseverbindingen, streams, afbeeldingscanvasgebieden en dergelijke (zoals in de handleiding wordt vermeld).

$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)

Gebruik de functie gettype() om het type van een variabele als een tekenreeks te krijgen:

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

Wereldwijde variabele best practices

We kunnen dit probleem illustreren met de volgende pseudo-code

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

Uw eerste vraag ligt hier voor de hand

Waar komt $bob vandaan?

Ben je in de war Mooi zo. Je hebt zojuist geleerd waarom globals verwarrend zijn en als een slechte gewoonte worden beschouwd .

Als dit een echt programma was, is het je volgende plezier om alle instanties van $bob op te sporen en te hopen dat je de juiste vindt (dit wordt alleen maar erger als $bob overal wordt gebruikt). Erger nog, als iemand anders $bob definieert (of je bent die variabele vergeten en opnieuw gebruikt), kan je code breken (in het bovenstaande codevoorbeeld zou het hebben van het verkeerde object of helemaal geen object een fatale fout veroorzaken).

Omdat vrijwel alle PHP-programma's code gebruiken zoals include('file.php'); uw taakbeheercode als deze wordt exponentieel moeilijker naarmate u meer bestanden toevoegt.

Dit maakt het ook heel moeilijk om uw applicaties te testen. Stel dat u een globale variabele gebruikt om uw databaseverbinding te behouden:

$dbConnector = new DBConnector(...);

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

Om deze functie in eenheden te testen, moet u de globale variabele $dbConnector overschrijven, de tests uitvoeren en vervolgens op de oorspronkelijke waarde terugzetten, wat erg gevoelig is voor fouten:

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

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

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

Hoe vermijden we Globals?

De beste manier om globals te vermijden is een filosofie genaamd Dependency Injection . Hier geven we de tools die we nodig hebben door aan de functie of klasse.

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

Dit is veel gemakkelijker te begrijpen en te onderhouden. Het is niet te raden waar $bob is ingesteld omdat de beller verantwoordelijk is om dat te weten (het geeft ons door wat we moeten weten). Beter nog, we kunnen typeverklaringen gebruiken om te beperken wat wordt doorgegeven.

We weten dus dat $bob een instantie van de klasse Bar , of een instantie van een kind van Bar , wat betekent dat we weten dat we de methoden van die klasse kunnen gebruiken. In combinatie met een standaard autoloader (beschikbaar sinds PHP 5.3), kunnen we nu verder gaan waar Bar is gedefinieerd. PHP 7.0 of hoger bevat uitgebreide typeaangiften, waar u ook scalaire types (zoals int of string ) kunt gebruiken.

Alle gedefinieerde variabelen verkrijgen

get_defined_vars() retourneert een array met alle namen en waarden van de variabelen die zijn gedefinieerd in het bereik waarin de functie wordt aangeroepen. Als u gegevens wilt afdrukken, kunt u standaardfuncties gebruiken voor het uitvoeren van door mensen leesbare gegevens, zoals print_r of var_dump .

var_dump(get_defined_vars());

Opmerking : deze functie retourneert meestal slechts 4 superglobals : $_GET , $_POST , $_COOKIE , $_FILES . Andere superglobals worden alleen geretourneerd als ze ergens in de code zijn gebruikt. Dit komt door de auto_globals_jit die standaard is ingeschakeld. Wanneer deze is ingeschakeld, worden de variabelen $_SERVER en $_ENV gemaakt wanneer ze voor het eerst worden gebruikt (Just In Time) in plaats van wanneer het script wordt gestart. Als deze variabelen niet in een script worden gebruikt, levert deze richtlijn een prestatiewinst op.

Standaardwaarden van niet-geïnitialiseerde variabelen

Hoewel niet noodzakelijk in PHP, is het echter een zeer goede gewoonte om variabelen te initialiseren. Niet-geïnitialiseerde variabelen hebben een standaardwaarde van hun type, afhankelijk van de context waarin ze worden gebruikt:

Uitgeschakeld EN niet vermeld

var_dump($unset_var); // outputs NULL

Boolean

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

Draad

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

Geheel getal

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

Float / double

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

reeks

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

Voorwerp

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

Vertrouwen op de standaardwaarde van een niet-geïnitialiseerde variabele is problematisch in het geval van het opnemen van een bestand in een ander dat dezelfde variabelenaam gebruikt.

Variabele waarheidsgetrouwheid en identieke operator

In PHP hebben variabele waarden een bijbehorende "waarheid", zodat zelfs niet-booleaanse waarden gelijk zijn aan true of false . Hierdoor kan elke variabele in een voorwaardelijk blok worden gebruikt, bijvoorbeeld

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

Hier zijn enkele fundamentele regels voor verschillende soorten variabele waarden:

• Strings met niet-nul lengte zijn gelijk aan true inclusief strings die alleen witruimte bevatten zoals ' ' .
• Lege tekenreeksen '' gelijk aan 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

• Gehele getallen zijn gelijk aan true als ze niet nul zijn, terwijl nul gelijk is aan 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 gelijk aan false

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

• Lege strings '' en string nul '0' gelijk aan 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

• Drijvende-kommawaarden zijn gelijk aan true als ze niet nul zijn, terwijl nulwaarden gelijk zijn aan false .
  • NAN (PHP's Not-a-Number) is gelijk aan true , dwz NAN == true is true . Dit komt omdat NAN een niet - nul drijvende- NAN is.
  • Nulwaarden omvatten zowel +0 als -0 zoals gedefinieerd door IEEE 754. PHP maakt geen onderscheid tussen +0 en -0 in zijn dubbel-precisie drijvende-komma, dwz floatval('0') == floatval('-0') is true .
    • floatval('0') === floatval('-0') .
    • Bovendien zijn zowel floatval('0') == false en 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

IDENTIEKE EXPLOITANT

In de PHP-documentatie voor vergelijkingsoperatoren is er een identieke operator === . Deze operator kan worden gebruikt om te controleren of een variabele identiek is aan een referentiewaarde:

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

Het heeft een overeenkomstige niet identieke operator !== :

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

De identieke operator kan worden gebruikt als alternatief voor taalfuncties zoals is_null() .

GEBRUIK CASE MET strpos()

De strpos($haystack, $needle) wordt gebruikt om de index te vinden waarbij $needle voorkomt in $haystack , of dat het strpos($haystack, $needle) voorkomt. De functie strpos() is hoofdlettergevoelig; als u niet hoofdlettergevoelig bent, kunt u kiezen voor stripos($haystack, $needle)

De functie strpos & stripos bevat ook een derde parameter- offset (int) die, indien opgegeven, het aantal tekens start dat wordt geteld vanaf het begin van de tekenreeks. In tegenstelling tot strrpos en strripos kan de offset niet negatief zijn

De functie kan terugkeren:

• 0 als $needle wordt gevonden aan het begin van $haystack ;
• een niet-nul geheel getal dat de index opgeeft als $needle ergens anders wordt gevonden dan het begin in $haystack ;
• en de waarde false als $needle is nergens te vinden in $haystack .

Omdat beide 0 en false hebben truthiness false in PHP, maar vertegenwoordigen verschillende situaties voor strpos() , is het belangrijk om onderscheid te maken tussen hen en het gebruik van de identieke operator === om precies te kijken voor false en niet alleen een waarde die gelijk staat aan false .

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

Als alternatief kunt u de niet-identieke operator gebruiken:

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