PHP
Referenties

Syntaxis

• $foo = 1; $bar = &$foo; // both $foo and $bar point to the same value: 1
• $var = 1; function calc(&$var) { $var *= 15; } calc($var); echo $var;

Opmerkingen

$foo = 1;
$bar = &$foo;

$baz = &$bar;
unset($bar);
$baz++;

Wijs op referentie

Dit is de eerste fase van verwijzing. In wezen staat u toe dat twee variabelen dezelfde waarde delen als u op referentie toekent.

$foo = &$bar;

$foo en $bar zijn hier gelijk. Ze wijzen niet op elkaar. Ze wijzen naar dezelfde plaats ( de "waarde" ).

U kunt ook toewijzen door middel van verwijzing binnen de taalconstructie array() . Hoewel het niet strikt een referentieopdracht is.

$foo = 'hi';
$bar = array(1, 2);
$array = array(&$foo, &$bar[0]);

Merk echter op dat verwijzingen in arrays potentieel gevaarlijk zijn. Als u een normale (niet op referentie) toewijzing uitvoert met een verwijzing aan de rechterkant, verandert de linkerkant niet in een referentie, maar in deze normale toewijzingen worden referenties in arrays bewaard. Dit geldt ook voor functieaanroepen waarbij de array wordt doorgegeven door waarde.

Toekenning door verwijzing is niet alleen beperkt tot variabelen en arrays, ze zijn ook aanwezig voor functies en alle "pass-by-reference" associaties.

function incrementArray(&$arr) {
    foreach ($arr as &$val) {
        $val++;
    }
}

function &getArray() {
    static $arr = [1, 2, 3];
    return $arr;
}

incrementArray(getArray());
var_dump(getArray()); // prints an array [2, 3, 4]

Toewijzing is de sleutel binnen de functiedefinitie zoals hierboven. U kunt een uitdrukking niet doorgeven als referentie, alleen een waarde / variabele. Vandaar de instantiatie van $a in bar() .

Retour op referentie

Af en toe komt er tijd voor u om impliciet per referentie terug te keren.

Terugkeren op referentie is handig wanneer u een functie wilt gebruiken om te zoeken naar welke variabele een referentie moet worden gebonden. Gebruik geen return-by-reference om de prestaties te verbeteren. De motor zal dit automatisch automatisch optimaliseren. Retourneer alleen referenties als u daarvoor een geldige technische reden hebt.

^{Genomen uit de PHP-documentatie voor retourneren op referentie .}

Er zijn veel verschillende vormen die retour door verwijzing kan aannemen, waaronder het volgende voorbeeld:

function parent(&$var) {
    echo $var;
    $var = "updated";
}

function &child() {
    static $a = "test";
    return $a;
}

parent(child()); // returns "test"
parent(child()); // returns "updated"

Return by reference is niet alleen beperkt tot functieverwijzingen. Je hebt ook de mogelijkheid om de functie impliciet aan te roepen:

function &myFunction() {
    static $a = 'foo';
    return $a;
}

$bar = &myFunction();
$bar = "updated"
echo myFunction();

U kunt niet direct naar een functieaanroep verwijzen , deze moet aan een variabele worden toegewezen voordat deze wordt gebruikt. Om te zien hoe dat werkt, probeer je gewoon echo &myFunction(); .

Notes

• U moet een referentie ( & ) opgeven op beide plaatsen waar u deze wilt gebruiken. Dat betekent voor uw functiedefinitie ( function &myFunction() {... ) en in de function callFunction(&$variable) {... or &myFunction(); ).
• U kunt een variabele alleen als referentie retourneren. Vandaar de instantiëring van $a in het bovenstaande voorbeeld. Dit betekent dat u geen uitdrukking kunt retourneren, anders wordt er een E_NOTICE PHP-fout gegenereerd ( Notice: Only variable references should be returned by reference in ...... ).
• Terugkeer door verwijzing heeft legitieme gebruiksscenario's, maar ik moet waarschuwen dat ze spaarzaam moeten worden gebruikt, alleen na het verkennen van alle andere mogelijke opties om hetzelfde doel te bereiken.

Doorgeven via referentie

Hiermee kunt u een variabele doorgeven aan de hand van een functie of element waarmee u de oorspronkelijke variabele kunt wijzigen.

Doorgeven door referentie is niet alleen beperkt tot variabelen, maar het volgende kan ook doorgegeven worden als referentie:

• Nieuwe verklaringen, bijv. foo(new SomeClass)
• Verwijzingen geretourneerd uit functies

arrays

Een veelgebruikt gebruik van "passeren door verwijzing" is om beginwaarden in een array te wijzigen zonder in de richting te gaan van het maken van nieuwe arrays of het vervuilen van uw naamruimte. Doorgeven door referentie is zo eenvoudig als het voorafgaan / voorvoegen van de variabele met een & => &$myElement .

Hieronder ziet u een voorbeeld van het benutten van een element uit een array en eenvoudig 1 toevoegen aan de oorspronkelijke waarde.

$arr = array(1, 2, 3, 4, 5);

foreach($arr as &$num) {
    $num++;
}

Wanneer u nu een element binnen $arr , wordt het oorspronkelijke element bijgewerkt naarmate de referentie werd verhoogd. U kunt dit verifiëren door:

print_r($arr);

Notitie

U moet er rekening mee houden bij het gebruik van pass by reference in lussen. Aan het einde van de bovenstaande lus bevat $num nog steeds een verwijzing naar het laatste element van de array. Het toewijzen van de postlus zal uiteindelijk het laatste array-element manipuleren! Je kunt ervoor zorgen dat dit niet gebeurt door het na de lus uit te zetten unset() :

$myArray = array(1, 2, 3, 4, 5);

foreach($myArray as &$num) {
   $num++;
}
unset($num);

Het bovenstaande zorgt ervoor dat u geen problemen tegenkomt. Een voorbeeld van problemen die hieruit kunnen voortvloeien, staat in deze vraag over StackOverflow .

functies

Een ander veelgebruikt gebruik voor het passeren door verwijzing is binnen functies. Het wijzigen van de oorspronkelijke variabele is zo eenvoudig als:

$var = 5;
// define
function add(&$var) {
    $var++;
}
// call
add($var);

Dit kan worden geverifieerd door de oorspronkelijke variabele te echo .

echo $var;

Er zijn verschillende beperkingen voor functies, zoals hieronder vermeld in de PHP-documenten:

Opmerking: er is geen verwijzingsteken op een functieaanroep - alleen op functiedefinities. Functiedefinities alleen zijn voldoende om het argument correct door te geven. Vanaf PHP 5.3.0 krijgt u een waarschuwing dat "call-time pass-by-reference" is verouderd wanneer u & in foo (& $ a); gebruikt. En vanaf PHP 5.4.0 is call-time pass-by-reference verwijderd, dus het gebruik ervan zal een fatale fout veroorzaken.