[SOLUCIONADO] Extraño comportamiento de foreach

[NSD]

Que tal, por un error en mi codigo descubri esta curiosidad del foreach:

Código PHP:

<?php
    class A
    {
        public $datos = [1, 2, 3, 4, 5];
        
        public function __destruct()
        {
            echo("destruido");
        }
    }
    
    $test = new A();
    foreach($test->datos as $test)
    {
        var_dump($test);
    }    
    
    var_dump($test);
 

Produce la salida:

destruido
int 1
int 2
int 3
int 4
int 5
int 5

¿Acaso el foreach itera una propiedad de un objeto destruido?
En la version serbia del manual (no en las otras ) esta la siguiente nota:

Напомена:
Unless the array is referenced, foreach operates on a copy of the specified array and not the array itself. foreach has some side effects on the array pointer. Don't rely on the array pointer during or after the foreach without resetting it.

¿Eso significa que si tengo un array inmenso, php lo duplicara para iterarlo?
para comprobarlo hice esto:

Código PHP:

<?php
    class A
    {
        public $datos = [];
        
        public function __destruct()
        {
            echo("destruido");
        }
    }
    
    $test = new A();
    for($i=0; $i<999999; $i++)
        $test->datos[] = $i;  
        
    var_dump(memory_get_usage());
    
    foreach($test->datos as $test)
    {
        var_dump(memory_get_usage());
        break;
    }       
    var_dump(memory_get_usage());
    
    var_dump($test);
 

la salida es esta:

int 84340000
destruido
int 84339928
int 145592
int 0

por lo visto, el consumo de memoria baja dentro del foreach, por lo que no lo esta duplicando, entonces ¿que es lo que hace realmente?

[Triby]

El destructor se está ejecutando antes de ingresar a foreach, porque solo estás haciendo un echo, en caso de ser mostrado con var_dump() sería algo como string...

En todo caso, habrá que investigar el comportamiento del destructor.

[hhs]

Código PHP:

<?php
    class A
    {
        public $datos = [1, 2, 3, 4, 5];
        
        public function __destruct()
        {
            echo("destruido");
        }
    }
    
    $test = new A();
    foreach($test->datos as $test)
    {
        var_dump($test);
    }    
    
    var_dump($test);
 

Lamento informar que este es el comportamiento esperado

• El alcance de $test es global
• foreach es una estructura
• Destruct se llama de forma natural al final del script o donde se haga la ultima referencia al objeto

La ultima referencia al objeto es cuando se pasa el contenido de la propiedad datos al foreach es cuando se hace la llamada a destruct. y esto pasa por que en el foreach asigna cada valor de la iteración en $test (es global ) que ya no contiene el objeto si no 1 en la primera iteración por eso al final el ultimo var_dump tiene el valor de 5.
El segundo caso:

Código PHP:

var_dump(memory_get_usage());
    
    foreach($test->datos as $test)
    {
        var_dump(memory_get_usage());
        break; // Ojo con esto
    }       
    var_dump(memory_get_usage());
    
    var_dump($test);
 

Es similar pero aquí como no se itera solo una vez ya que el break finaliza el foreach de forma prematura, se pierde el arreglo liberando memoria.
Lo compruebas fácilmente ya que $test en el ultimo var_dump tiene el valor de cero.
Para solucionar el extraño "comportamiento" usa otro nombre de variable.

Código PHP:

class A
{
    public $datos = [1, 2, 3, 4, 5];
 
    public function __destruct()
    {
        echo("destruido");
    }
}
 
$test = new A();
 
var_dump($test);
 
foreach($test->datos as $dato)
{
    var_dump($dato);
}
 
var_dump($test);
 

La salida se comporta como esperabas:

object(A)[1]
public 'datos' =>
array (size=5)
0 => int 1
1 => int 2
2 => int 3
3 => int 4
4 => int 5

int 1

int 2

int 3

int 4

int 5

object(A)[1]
public 'datos' =>
array (size=5)
0 => int 1
1 => int 2
2 => int 3
3 => int 4
4 => int 5

destruido

Creo que esto será una buena pregunta para examen

[NSD]

Gracias a ambos por las respuestas.

@triby estube revisando el manual y haciendo unas pruebas sobre los destructores, pero no hay mucho mas en su comportamiento de lo que menciona @hhs, se invocan cuando el objeto deja de ser necesario (al final del script, cuando se llama a unset, cuando se le asigna un valor o cuando ya no se lo referencia mas)

@hhs interesante el analisis pero tengo una duda con esta parte de tu razonamiento:

$test (es global ) que ya no contiene el objeto si no 1 en la primera iteración por eso al final el ultimo var_dump tiene el valor de 5.

Eso no es tan asi (o no me doy cuenta al menos, espero me tengas paciencia), considera el siguiente ejemplo similar al primero:

Código PHP:

<?php
    error_reporting(E_ALL);
    
    class A implements Iterator
    {
        private $datos = [1, 2, 3, 4, 5];
 
        public function rewind() { reset($this->datos); }
        public function current() { return current($this->datos); }
        public function key() { return key($this->datos); }
        public function next() { return next($this->datos); }
        public function valid() { return (key($this->datos) !== NULL && key($this->datos) !== FALSE); }
        public function __destruct()
        {
            echo("destruido");
        }
    }
 
    $test = new A();
    foreach($test as $test) 
    {    
        var_dump($test);
    }
    var_dump($test);
 

La salida que produce es:

int 1
int 2
int 3
int 4
int 5
destruido
int 5

Por lo tanto, la variable $test cambia su valor dentro del foreach, pero el objeto sigue "vivo" ya que se esta haciendo uso de sus metodos, solo es destruido al finalizar el foreach.

Pero este este script en cambio:

Código PHP:

class A implements IteratorAggregate
    {
        private $datos = [1, 2, 3, 4, 5];
 
        public function getIterator() { return new ArrayIterator($this->datos); }
        public function __destruct()
        {
            echo("destruido");
        }
    }
 
    $test = new A();
    foreach($test as $test) 
    {    
        var_dump($test);
    }
    var_dump($test);
 

produce la salida:

destruido
int 1
int 2
int 3
int 4
int 5
int 5

exactamente la misma que si iterara la propiedad publica directamente (lo cual es coherente).

Para solucionar el extraño "comportamiento" usa otro nombre de variable.

Si, por supuesto, por error escribi el mismo nombre en ambas partes, el script funciono durante mucho tiempo asi, pero aller tube que actualizarlo y al verlo me llamo la atencion porque a priori supuse que eso no funcionaria.
Quiero entender que es lo que esta ocurriendo mas alla de que la solucion sea cambiar el nombre, porque dependiendo de cual sea el comportamiento puede ser (por ejemplo) una buena forma de optimizar la carga de un listado ya que php iria liberando la memoria a medida que produce la salida en vez de mantenerla ocupada hasta terminar de mostrar todo.

Seria interesante combinar esto con los generadores de alguna forma...

[pateketrueke]

Creo que no entiendes como funciona el foreach() entonces.

Por lo tanto, la variable $test cambia su valor dentro del foreach, pero el objeto sigue "vivo" ya que se esta haciendo uso de sus metodos, solo es destruido al finalizar el foreach.

$test no contiene ninguna referencia al objecto, es una copia del último valor que se iteró en el foreach() y nada más.

Código PHP:

$foo = array('candy', 'bar');
 
foreach ($foo as $bar); // sin {}
 
echo $bar; // bar
 

¿Se entiende?

[NSD]

$test no contiene ninguna referencia al objecto, es una copia del último valor que se iteró en el foreach() y nada más.

Pero $test era el objeto, en ejemplo que me pones no pasa nada raro porque el nombre de la variable a iterar y la variable que se usa en la iteracion son diferentes, es lo que menciono @hhs, mi duda es cuando le das a los dos el mismo nombre

[pateketrueke]

Iniciado por NSD

Pero $test era el objeto, en ejemplo que me pones no pasa nada raro porque el nombre de la variable a iterar y la variable que se usa en la iteracion son diferentes, es lo que menciono @hhs, mi duda es cuando le das a los dos el mismo nombre

Te equivocas, $test es el valor que devuelve al extraer cada elemento dentro del foreach(), porque primero se hace una copia de $test->datos y a partir de ahí se sobre escribe $test por lo cual ya no representa al objeto.

[Triby]

Creo entender el punto expuesto por @pateketrueke

Código PHP:

foreach($test->datos as $test) {
     // $test sobreescribe al objeto y, por tanto, llama al destructor
     // Las iteraciones son sobre valores que contenía $test->datos
}
 
foreach($test->datos as $dato) {
    // Aquí no se sobreescribe el objeto y no debería aparecer "Destruido"
}
 

[NSD]

Te equivocas, $test es el valor que devuelve al extraer cada elemento dentro del foreach(), porque primero se hace una copia de $test->datos y a partir de ahí se sobre escribe $test por lo cual ya no representa al objeto.

Si el objeto se copiara se estaria duplicando, por lo tanto deberia ocupar el doble de memoria, sin embargo, unas de las pruebas hechas muestra que la memoria baja dentro del foreach, al llamarse al destructor se destruye el objeto pero la propiedad sigue existiendo ya que es iterada.

foreach($test->datos as $test) {
// $test sobreescribe al objeto y, por tanto, llama al destructor
// Las iteraciones son sobre valores que contenía $test->datos
}

En el primer ejemplo de este mensaje: http://www.forosdelweb.com/f18/extra...0/#post4627420 no estoy iterando la propiedad, sino el objeto mismo a travez se sus metodos, sin embargo la variable se sobreescribe pero todo el objeto sigue existiendo en algun lado y solo es destruido luego de toda la iteracion.

Como si el elemento a iterar no se destruyera.

En la seccion de objetos y referencias esta esto:

Desde PHP 5, una variable de tipo objeto ya no contiene el objeto en sí como valor. Únicamente contiene un identificador del objeto que le permite localizar al objeto real. Cuando se pasa un objeto como parámetro, o se devuelve como retorno, o se asigna a otra variable, las distintas variables no son alias: guardan una copia del identificador, que apunta al mismo objeto.

El objeto solo se destruye cuando no hay mas identificadores definidos de ese objeto.

¿Es posible que el foreach realice una copia de ese identificador y por lo tanto pueda seguir iterando aunque la variable original ya haya cambiado de valor?

[hhs]

Eso no es tan asi (o no me doy cuenta al menos, espero me tengas paciencia), considera el siguiente ejemplo similar al primero:

Código PHP:

$test = new A();
    foreach($test as $test) 
    {    
        var_dump($test);
    }
    var_dump($test);
 

No se ve a simple vista, pero el $test que imprimes dentro del foreach ya no contiene el identificador del objeto por una simple y sencilla razón que estas pasando por alto. La variable $test que pasas al foreach y el que regresa están en el mismo ámbito debido a que el foreach no es una función $test no esta en un ámbito local, asi que la sobre escribe.
Entonces que es lo que pasa cuando iteras el objeto ?

Hasta aqui ya sabemos que $test se sobre escribe pero aun asi se itera el objeto y la razón ya te la respondiste.

El objeto solo se destruye cuando no hay mas identificadores definidos de ese objeto.

¿Es posible que el foreach realice una copia de ese identificador y por lo tanto pueda seguir iterando aunque la variable original ya haya cambiado de valor?

Php trata de forma diferente a los objetos por que su "referencia" se hace por el identificador que pasa a otras variables, por lo cual el foreach a nivel interno tiene que mantenerlo para no crear efectos adversos ya que el objeto puede estar "referenciado" en otras variables.
Esto lo comprobamos de forma sencilla:

Código PHP:

class A implements Iterator
{
    private $datos = [1, 2, 3, 4, 5];
 
    public function rewind() { reset($this->datos); }
    public function current() { return current($this->datos); }
    public function key() { return key($this->datos); }
    public function next() { return next($this->datos); }
    public function valid() { return (key($this->datos) !== NULL && key($this->datos) !== FALSE); }
    public function __destruct()
    {
        echo("destruido");
    }
}
 
$test = new A();
$test1 = $test; //pasamos identificador
foreach($test as $test)
{
    var_dump($test);
}
var_dump($test); //se sobre escribe; ahora vale 5
var_dump($test1); //se mantiene el objeto
echo 'Depues de esto se llama a __destruct <br>';
 

Despues de foreach el objeto original sigue con vida aun después de finalizar el ciclo y como se puede comprobar nuevamente $test se sobre escribe.
Si aun existe duda de si $test mantiene o no la referencia podemos probar algo: tu puedes llamar a __destruct si usas unset

Código PHP:

class A implements Iterator
{
    private $datos = [1, 2, 3, 4, 5];
 
    public function rewind() { reset($this->datos); }
    public function current() { return current($this->datos); }
    public function key() { return key($this->datos); }
    public function next() { return next($this->datos); }
    public function valid() { return (key($this->datos) !== NULL && key($this->datos) !== FALSE); }
    public function __destruct()
    {
        echo("destruido");
    }
}
 
$test = new A();
$test1 = $test; //pasamos identificador
foreach($test as $test)
{
    var_dump($test);
    unset($test);
}
var_dump($test); //se sobre escribe; ahora vale 5
var_dump($test1); //se mantiene el objeto
echo 'Depues de esto se llama a __destruct <br>';
 

Si el $test sigue con el identificador debiera de detener de forma prematura el foreach al destruir el objeto y por ende tendríamos un resultado inesperado en $test1. Pero no es asi si ejecutas esto obtienes lo siguiente:

int 1
int 2
int 3
int 4
int 5


( ! ) Notice: Undefined variable: test in /home/hheredia/public_html/Curso/iteracion.php on line 56
Call Stack
# Time Memory Function Location
1 0.0022 236176 {main}( ) ../iteracion.php:0

null

object(A)[1]
private 'datos' =>
array (size=5)
0 => int 1
1 => int 2
2 => int 3
3 => int 4
4 => int 5

Depues de esto se llama a __destruct
destruido

$test1 sigue integro con su referencia al objeto como es de esperarse junto con el notice de variable indefinida de $test.

[NSD]

Tienes razon, muchas gracias por resolver mi duda, como para cerrar y completar lo dicho (que esta muy claro) hice este codigo:

Código PHP:

<?php
    error_reporting(E_ALL);
   
    class A implements Iterator
    {
        public $datos = [1, 2, 3, 4, 5];
 
        public function rewind() { reset($this->datos); }
        public function current() { return current($this->datos); }
        public function key() { return key($this->datos); }
        public function next() { return next($this->datos); }
        public function valid() { return (key($this->datos) !== NULL && key($this->datos) !== FALSE); }
        public function __destruct()
        {
            echo("destruido");
        }
    }
    
    $test = new A();
    $instancia = $test; 
    debug_zval_dump($instancia);
    foreach($instancia as $test)
    {    
        debug_zval_dump($instancia);
        var_dump($test);
    }
    var_dump($test);
 

cuya salida es:

object(A)#1 (1) refcount(3){ ["datos"]=> array(5) refcount(1){ [0]=> long(1) refcount(2) [1]=> long(2) refcount(2) [2]=> long(3) refcount(2) [3]=> long(4) refcount(2) [4]=> long(5) refcount(2) } } object(A)#1 (1) refcount(3){ ["datos"]=> array(5) refcount(1){ [0]=> long(1) refcount(2) [1]=> long(2) refcount(2) [2]=> long(3) refcount(2) [3]=> long(4) refcount(2) [4]=> long(5) refcount(2) } }
int 1
object(A)#1 (1) refcount(3){ ["datos"]=> array(5) refcount(1){ [0]=> long(1) refcount(2) [1]=> long(2) refcount(2) [2]=> long(3) refcount(2) [3]=> long(4) refcount(2) [4]=> long(5) refcount(2) } }
int 2
object(A)#1 (1) refcount(3){ ["datos"]=> array(5) refcount(1){ [0]=> long(1) refcount(2) [1]=> long(2) refcount(2) [2]=> long(3) refcount(2) [3]=> long(4) refcount(2) [4]=> long(5) refcount(2) } }
int 3
object(A)#1 (1) refcount(3){ ["datos"]=> array(5) refcount(1){ [0]=> long(1) refcount(2) [1]=> long(2) refcount(2) [2]=> long(3) refcount(2) [3]=> long(4) refcount(2) [4]=> long(5) refcount(2) } }
int 4
object(A)#1 (1) refcount(3){ ["datos"]=> array(5) refcount(1){ [0]=> long(1) refcount(2) [1]=> long(2) refcount(2) [2]=> long(3) refcount(2) [3]=> long(4) refcount(2) [4]=> long(5) refcount(2) } }
int 5
int 5
destruido

alli se ve que la cantidad de referencias al objeto aumenta dentro del foreach (sigue igual, pero porque una se elimina al hacer la asignacion) confirmándose lo que dices.

Saludos.

[hhs]

Gracias a ti NSD que expones situaciones como esta, que sirven para exponer como funciona el lenguaje en situaciones poco frecuentes. Además ayudan a tener días fuera de lo habitual en el foro.