Zyppora schreef op vrijdag 10 oktober 2008 @ 13:41:
[...]
Dat je een reference eerst moet unsetten voordat je daar een expliciete waarde aan kunt hangen is geen rocket science. De quirk zit'em dan ook in de scope. Het voorbeeld in de bugreport probeert daar voor mijn gevoel een dramatisch verhaal aan te geven, maar het blijft een simpele quirk en als je dat in je achterhoofd houdt, hoeft er echt geen issue van gemaakt te worden en is het triviaal hier op juiste wijze mee om te springen. Dat het een workaround is, ben ik met je eens.
Als je die redenatie aanhoudt hoef je nergens meer over na te denken bij het ontwerp van je taal. Gezien de laatste alinea van je laatste post hamer je imho teveel op de term "bug". Je kan idd stellen dat het geen bug is omdat het werkt volgens de spec (dat die spec dan wel weer het resultaat is van de implementatie laten we dan voor het gemak maar even in het midden). Maar of je het nou een bug noemt of niet, je kan niet ontkennen dat de manier zoals het nu is wat onhandig werkt. Je zegt zelf al dat het een quirk is en dat je een workaround nodig hebt. En dáár gaat het nou juist over in deze discussie, dat de designkeuze onhandig is of dat er op z'n minst niet goed over na is gedacht.
Alleen voor references

Niet-references kun je gewoon overschrijven. Maar het is inderdaad niet de beste manier om met codeblokken en diens variabelen om te springen.
Álle variabelen in PHP zijn references. Het punt is dat ze niet altijd naar iets unieks hoeven te wijzen. En er is geen manier om dat uit te vinden, anders dan de hele source doorspitten. Jij zegt "het hoeft niet voor niet-references" (vertaling: het hoeft niet voor variabelen die je nooit naar iets anders hebt laten wijzen). Het probleem is dat het niet direct duidelijk is of dat bij een bepaalde variabele het geval is. Dus vandaar: om defensief te programmeren moet je altijd unsetten.
Ik geef toe dat er wat dat betreft nogal wat aan PHP schort, maar da's een andere discussie vrees ik.
Mwoa, het was niet mijn bedoeling om te stellen dat er iets aan PHP's concept van references schort. Ik legde slechts uit dat het anders in elkaar zit dan ogenlijk vergelijkbare concepten in andere talen.
Ik vraag me af wat functioneel gezien het verschil tussen een reference in PHP en een reference/pointer in een willekeurig andere (fatsoenlijke) taal is.
Zoals ik al zei, alles in PHP is een reference. Alleen bij het eerste gebruik van een variabele zal er een lege slot ergens worden gealloceerd waarnaar verwezen wordt. Assignments aan een variabele veranderen die slot. De =& zorgt ervoor dat de verwijzing van een variabele veranderd naar de slot waar de andere variabele naar verwees.
Neem dit stukje code:
PHP:
1
2
3
4
5
6
| $a = 3;
$b = 4;
$b = &$a;
$b = 5;
unset($a);
$a = 6; |
$a wordt aangemaakt (stel slot #0 wordt gealloceerd), waaraan 3 wordt geassignd. Dus de 3 staat in #0
Op regel 2 verwijst $b naar #1, met 4 erin.
Dan verwijst $b ook naar #0, dus $b heeft dan de waarde 3, net als $a
Dan wordt 5 geassigned aan $b, dus aan slot #0. De verandering zie je ook terug in $a.
Daarna wordt $a geunset en opnieuw geassigned. $a krijgt dus een verwijzing naar slot #2, met de waarde 6.
Het is foutief om te denken dat $b naar $a wijst op regel 3. Je moet het juist zien als dat $a en $b naar hetzelfde stuk geheugen wijzen. Dit blijkt wel wanneer je $a een andere verwijzing zou meegeven direct na regel 3 - $b verandert dan niet ineens mee.
In C++:
C++:
1
2
3
4
5
6
| int *a = new int; *a = 3; // $a = 3
int *b = new int; *b = 4; // $b = 4
b = a; // $b = &$a
*b = 5; // $b = 5
a = NULL; // unset($a)
a = new int; *a = 6; // $a = 6 |
[
Voor 16% gewijzigd door
.oisyn op 10-10-2008 15:31
]