Eu instalei o PHP 5.2 em um dos computadores o meu teste hoje e um par de pedaços de código, que anteriormente trabalhou muito bem na versão 5.1.6 jogou erros fatais na nova versão. A mensagem de erro foi "nível de nidificação muito profundo - recursive dependência?"E levou um pouco de tempo
No PHP existem dois operadores de comparação, == E ===. É do conhecimento geral que o primeiro não é rigorosa sobre o tipo, mas o segundo é. Assim, for example
eco ( == false 0 ); // verdadeiro
eco ( === false 0 ); // falso
- 0 é um inteiro e falso é um boolean
Meu problema surgiu com digitação não-estrita com os objetos.
$a = new MyObj();
$b = new MyObj();
se( $a == $b )
…
Eu não tinha pensado que eu estava fazendo com este código. Quando comparando dois objetos utilizando o operador de comparação não-estrita (==) PHP compara todas as propriedades dos objetos e se combinam os objetos são considerados iguais. Se eles não corresponderem, não são iguais. Na realidade, temos uma relação recursiva de todas as propriedades de cada objeto, e todas as suas propriedades, etc. até chegar a tipos de dados básicos como strings e inteiros.
If, contudo, usamos comparação estrita (===), PHP irá verificar se os dois objetos são exatamente o mesmo objeto, não apenas objetos com as mesmas propriedades.
MyObj classe
{
p public $;
}$a = new MyObj();
$b = new MyObj();
$c = new MyObj();
$a->p = 1;
$b->p = 1;
$c->p = 2;
eco ( $a == $c ); // falso
eco ( $a == $b ); // verdadeiro
eco ( $a === $b ); // falso
O problema surge quando você tem referências circulares em seus objetos de imóveis. Assim, for example
MyObj classe
{
p public $;
}
OtherObj classe
{
public $ q;
}$a = new MyObj();
$b = new OtherObj();
$a->p = $ b;
$b->q = $ a; // a referência circular: $a->p->=== Q $ a$c = new MyObj();
$d = new OtherObj();
$c->p = $ d;
$d->q = $ c;// outra referência circular: $c->p->q $ c ===eco ( $a == $c ); // Erro fatal:
Nesting level too deep – dependência recursiva?
A fim de comparar a $ a $ c, PHP deve comparar suas propriedades. Portanto, a lógica em PHP é algo como isto: $a == $c if $a->p == $c->p if $a->p->q == $c->p->q if $a->p->q->p == $c->p->q->p etc. indefinidamente.
PHP 5.1 Parecia bom sobre o problema de alguma forma (provavelmente depois de um certo nível de recursão simplesmente retornou false) – e, normalmente, fPHPionou muito bem. PHP 5.2 corretamente produz o erro fatal acima.
Uma vez que você conhece o problema, A solução é fácil – usar comparação estrita.
eco ( $a === $c ); // falso (e nenhum erro)
A comparação rigorosa simplesmente verificar se os dois objetos estão no mesmo local na memória e assim nem sequer olhar para os valores das propriedades.
NB. O mesmo problema pode surgir quando se utiliza os operadores de comparação negada (utilização !== instead of !=) and when using in_array (use in_array’s third parameter to indicate strict comparison).
Devo dizer que partilho essa preferência, Windows assim que eu tiver instalado 7 para o meu laptop em casa.
