PHP: Métodos Mágicos II

__call()

Este método es llamado cada vez que un objeto intenta utilizar un método inaccesible (private o protected) o que no existe.

noExiste();

Dadas sus características puede ser aprovechado para construir funciones, que actúen de forma dinámica. También para simular la sobrecarga de funciones (característica inexistente en PHP). En este caso se sobrecargará el constructor en tres tipos distintos.

Sobrecarga de Constructor

    private function constructor2($nombre, $cuenta)
    {
        $this->nombre = $nombre;
        $this->cuenta = $cuenta;
    }

    private function constructor3($nombre, $cuenta, $carrera)
    {
        $this->nombre = $nombre;
        $this->cuenta = $cuenta;
        $this->carrera = $carrera;
    }
}

?>

__clone()

Esta función sirve para clonar objetos. Es decir, crear una copia de un objeto, sin hacer referencia de éste.
En el caso en el que un objeto es inyectado en otro, este método elimina la referencia que puede ocurrir de una clonación superficial (utilizando el operador clone).

capacidad = $capacidad;
        $this->liquido = $liquido;
    }

    public function __get($atributo)
    {
        if (property_exists($this, $atributo))
            return $this->$atributo;
    }

    public function __set($atributo, $valor)
    {
        if (property_exists($this, $atributo))
            $this->$atributo = $valor;
    }

    public function __toString()
    {
        return $this->liquido . '(' . $this->capacidad . ')';
    }
}

//------------------------------------------------------------

class Liquido
{
    private $nombre;
    private $sabor;

    public function __construct($nombre, $sabor)
    {
        $this->nombre = $nombre;
        $this->sabor = $sabor;
    }

    public function darSabor($sabor)
    {
        $this->sabor = $sabor;
    }

    public function __toString()
    {
        return $this->nombre . ' ' . $this->sabor;
    }
}

?>

En el siguiente ejemplo, se puede ver que al copiar $taza2 de $taza, y modificarlo posteriormente, la referencia existente hace que los dos objetos sean modificados… lo cual es una situación inesperada.

capacidad = 3;

echo $taza, PHP_EOL;		// té amargo(3)
echo $taza2, PHP_EOL;		// té amargo(3)

?>

Utilizando el operador clone, se logra una clonación, es decir, crear un nuevo objeto en lugar de una referencia. Sin embargo, esto puede ser superficial si el objeto clonado posee internamente otros objetos.

capacidad = 3;

// Límites de una clonación superficial
// El objeto clonado hace referencia a los objetos internos de taza
$taza2->liquido->darSabor('dulce');

echo $taza, PHP_EOL; 	// té dulce(5)
echo $taza2, PHP_EOL;	// té dulce(3)

?>

Para evitar esta situación es conveniente utilizar el método mágico __clone(), al cual se llama cuando se intenta clonar un objeto. Para este caso, se tratará de manejar el objeto interno de tipo Liquido.

// Cuando se intente clonar un objeto tipo Taza
// se clonará también el objeto interno tipo Liquido
public function __clone()
{
    $this->liquido = clone $this->liquido;
}