PHP OO ¿Usar get/set dentro de la clase o accceder directamente a la propiedad?

[Ronin46]

Hola,

Siguiendo con mi batería de preguntas absurdas...

¿Qué es mejor, usar siempre get y set para trabajar con las propiedades o sólo usar get y set desde fuera de la clase?

Ejemplo ilustrativo

Código PHP:

  /* Caso 1 */
class cPersona
{
    private $Edad;
    
    public function PrintEdad ()
    {
        return ('Tienes ' . $this->Edad . ' años');
    }
}
 
/* Caso 2 */
class cPersona
{
    private $Edad;
    
    public function GetEdad () { return $this->Edad; }
    
    public function PrintEdad ()
    {
        return ('Tienes ' . $this->GetEdad() . ' años');
    }
} 
   

Gracias!

[SetheR]

En estos casos, yo siempre utilizo $this->getLoquesea(). Simplemente porque así recibo el dato (tratado o no) como yo quiero.

[lisandro Arg]

Puede parecer bueno tener un método en medio donde puedas meter algo más pero entonces ya no sería un getEdad(), seria un getCalculoEdad() por ej.

Prefiero el primer caso.

[SetheR]

Y si el getter al que llamo tiene que devolverme un objeto que implemente la interfaz YYY pero voy a usarlo contadas veces?

Es muy común utilizar la carga de clases y/u objetos sólo cuando son necesarios, de otra manera, estarías desperdiciando recursos.

Ejemplo:

Código PHP:

class A{
        private $miServicio;
        private $id;
    private $contador;
    
    public function __construct($id, $contador){
        $this->id = $id;
        $this->contador = $contador;
    }
    
    public function getServicio(){
        if(null === $this->miServicio){
            //cargar clase, etc
            $this->miServicio = new Servicio($this->id);
        }
        return $this->miServicio;
    }
    
    public function usar(){
        $this->miServicio->hacer(); //No funciona
        
        $this->getServicio()->hacer(); //Bien
    }
}
 

[lisandro Arg]

Entiendo, pero si por eso lo usas "siempre" estarías haciendo una regla de una excepción y tendrías un montón de getters/setters que llevan tiempo codear (todo suma ) y crean "ruido". Es mas facil de leer el $this que tener q ir siempre al get a ver que hace.

Con respecto al ejemplo creo q hacerlo en el get es un poco tarde, poco semantico (estas haciendo un set) y hard.

Código PHP:

class A{
    private $miServicio;
    private $id;
    private $contador;
 
    public function __construct($id, $contador){
       $this->id = $id;
       $this->contador = $contador;
   }
 
   public function setServicio($otroServicio = null)
   {
        $this->miServicio = (null !== $otroServicio && $otroServicio instanceof ServicioInterface) ? $otroServicio($this->id) : new Servicio($this->id);
   }
 
    public function usar($otroServicio = null)
    {
        $this->setServicio($otroServicio); //Lo necesito, lo seteo.
        $this->miServicio->hacer();
    }
}
 

[masterpuppet]

Honestamente no te sigo lisando Arg, el ejemplo de SetheR es lazy loading..., a día de hoy no debe haber fw que no lo utilice, personalmente suelo utilizar el accessor si este tiene logica(lazy loading, validations, etc...), si simplemente retorna el valor accedo a la propiedad directamente.

Saludos.

[GatorV]

En efecto, concuerdo con @masterpuppet, es mejor usar el get() y usar lazy loading cuando aplique.

[lisandro Arg]

masterpuppet y GatorV creo q respondieron el post mas leyendo el ejemplo de SetheR que la pregunta original de Ronin46

El ejemplo surgió para mostrar un caso en el que podría necesitar hacer algo antes de devolver un valor. Una propiedad que tiene q tener una instancia de un objeto y que no se setea en el constructor ni en un init la verdad es q creo es el menor de los casos y por eso decia que no es ejemplo para crear una regla.

Por lo que entiendo Ronin46 esta preguntando si, como en el caso q muestra, tiene una variable privada y no va a ser accedida desde fuera
es necesario de todas formas crear un metodo set y otro get. En ese caso, sinceramente no me parece que la resupuesta sea "siempre", sino mas bien, "solo cuando aplique", lo puedes ver en cualquier FW

Ronin, si te fijas en el segundo ejemplo no solo estás devolviendo el valor también estás cambiando la visibilidad, escribir un método más es un punto más en donde te puedes equivocar.

[Ronin46]

lisandro Arg, leyendo tu post creo que quien lo entendió mal fuiste tu

En el caso de que necesite hacer algo antes de devolver un valor si tengo claro que tengo que llamar a un getEdad(), getCalculoEdad() o lo que sea. Más luego los casos que comentan, pero bueno, esos casos no los voy a comentar porque en estos momentos se salen de mis conocimientos (poquito a poco...).

Si la propiedad no va a ser accedida desde fuera, y se puede recoger su valor tal cual, podrías aplicar dos estrategias, crear un método privado / protected llamado getEdad(), lo cual te permite anticiparte por si el día de mañana decides hacerlo público o bien si el día de mañana le vas a meter cálculo. La otra estrategia sería acceder directamente a la propiedad, cosa que veo más lógica.

Ahora bien, llegamos al caso por el que iba la pregunta, ya tengo un getEdad() definido porque quiero que dicha propiedad pueda ser accedida desde fuera, dentro de mi clase, aprovechando la situación, me dedico a recoger la propiedad con getEdad() o accedo directamente a la propiedad (no cambio la visibilidad a nada, simplemente utilizo lo que ya tengo).

La conclusión que he sacado hasta el momento es: si sólo recoge valor accede a la propiedad directamente y si hace cálculos llama al método (lógico), si el día de mañana necesitas un tratamiento de la propiedad (por ejemplo getCalculoEdad()) pues te recorres la clase y sustituyes la llamada a la propiedad por la llamada a getCalculoEdad().

EDITO: La verdad es que viendo el ejemplo que puse en el primer post si que da lugar a la confusión que has tenido.