Ek het geïnstalleer PHP 5.2 by een van my rekenaars toets vandag en 'n paar stukkies van die kode wat voorheen gewerk het in die weergawe boete 5.1.6 fatale foute gegooi in die nuwe weergawe. Die fout boodskap was "Nesting vlak te diep - rekursiewe afhanklikheid?"En dit het 'n bietjie tyd
In PHP is daar twee vergelyking operateurs, == En ===. Dit is algemeen bekend dat die eerste is nie streng oor die tipe, maar die tweede is. So, byvoorbeeld
echo ( valse == 0 ); // ware
echo ( valse === 0 ); // valse
- 0 'n heelgetal is en valse is' n booleaanse
My probleem ontstaan uit die gebruik van nie-streng tik met voorwerpe.
$a = new MyObj();
$b = new MyObj();
indien( $a == $b )
…
Ek het nie oorweeg wat ek besig was met hierdie kode. Wanneer twee voorwerpe vergelyk met die nie-streng vergelyking operateur (==) PHP vergelyk al die eienskappe van die oogmerke en indien hulle voldoen aan die oogmerke word geag gelyk te wees. As dit nie ooreenstem met hulle nie gelyk is. In effek, Ons het 'n rekursiewe vergelyking van al die eienskappe van elke voorwerp, en al hulle eiendomme, ens. tot ons by basiese gegewens tik, soos snare en heelgetalle.
If, egter, gebruik ons streng vergelyking (===), PHP sal kyk of die twee voorwerpe is presies dieselfde voorwerp, nie net voorwerpe met dieselfde eienskappe.
klas MyObj
{
openbare $ p;
}$a = new MyObj();
$b = new MyObj();
$c = new MyObj();
$a->p = 1;
$b->p = 1;
$c->p = 2;
echo ( $a == $c ); // valse
echo ( $a == $b ); // ware
echo ( $a === $b ); // valse
Die probleem ontstaan as jy het 'n ronde in jou voorwerpe verwysings eiendomme. So, byvoorbeeld
klas MyObj
{
openbare $ p;
}
klas OtherObj
{
openbare $ q;
}$a = new MyObj();
$b = new OtherObj();
$a->p = $ b;
$b->q = $ 'n; // die omsendbrief verwys: $a->p->Q === $ 'n$c = new MyObj();
$d = new OtherObj();
$c->p = $ d;
$d->q = $ h;// 'n ander omsendbrief verwys: $c->p->q $ c ===echo ( $a == $c ); // Fatale fout:
Nesting level too deep – recursive dependency?
Met die oog op $ a tot $ te vergelyk c, PHP moet vergelyk hul eiendomme. Dus is die logika in PHP gaan iets soos dit: $a == $c if $a->p == $c->p if $a->p->q == $c->p->q if $a->p->q->p == $c->p->q->p ens. onbepaalde tyd.
PHP 5.1 skynbaar glad oor die probleem een of ander manier (waarskynlik na 'n sekere vlak van rekursie dit eenvoudig terug valse) – en gewoonlik is dit fyn uitgewerk. PHP 5.2 korrek produseer die fatale fout hierbo.
Sodra jy weet wat die probleem, die oplossing is eenvoudig – gebruik streng vergelyking.
echo ( $a === $c ); // valse (en geen fout)
Die streng vergelyking sal net kyk of die twee voorwerpe is op dieselfde plek in die geheue en dus nie eens kyk na die waardes van die eiendomme.
NB. Dieselfde probleem kan ontstaan wanneer die gebruik van die vergelyking operateurs ontken (gebruik !== In plaas van !=) en wanneer die gebruik van in_array (gebruik in_array se derde parameter streng vergelyking aan te dui).
