Hola, tengo una duda sobre optimización en una clase que aún no he logrado aclarar, debo decir que he buscado en Google y en el foro pero no he encontrado nada, debo ser muy malo buscando ;)
La cuestión es que no sé qué puede ser menos "pesado", si que
un método use otro método interno para obtener un atributo ya establecido, o pasarle a ese método como argumento lo que necesite.
Supongo que puede depender, entre otras cosas, de lo pesado que sea lo que se le pase y esto es parte de mi duda. Por ejemplo:
si el atributo ya establecido es un array muy grande, imagino que es más pesado que el método obtenga con un getter (
no es un getter como tal pero para entendernos) todo el array, a pasarle sólo la parte del array que nos interese.
Esa, básicamente, es mi duda, pero no tanto por lo grande o no que pueda ser lo que se le pase sino en general o
por el funcionamiento interno de php:
¿
pasar un argumento o usar un getter?
Este es más o menos el código de ejemplo, sólo pongo el código reducido para no ocupar mucho:
Código PHP:
public function setConfig($config)
{
// Digamos que es array para el ejemplo
if ( null === $this->_config )
$this->_config = $config;
// A: aquí debo decidir si pasarle sólo la porción del array que quiero:
if ( null === $this->_query )
$this->setQuery($config->query);
// B: ó que el propio método setQuery obtenga el atributo config y su porción query.
// Obviando que puedo hacer que getConfig sólo retorne una porción específica del array:
if ( null === $this->_query )
$this->setQuery();
}
// Este sería el método que retornaría el atributo, todo el array:
public function getConfig()
{
return $this->_config;
}
// A. puedo hacerlo pasando un argumento con la porción que quiero:
public function setQuery($query)
{
// ...
}
// B. u obteniendo el atributo con el método interno:
public function setQuery()
{
$config = $this->getConfig(); // opcionalmente podría obtener una porción
// con getConfig('porcion')
// ...
}
Nota off topic: setQuery es público porque aún no he decido como hacer esto y si se puede sobreescribir o no.
La clase, por cierto, es un singleton; sólo habría una instancia.
En cualquier caso, la pregunta en general es:
¿qué suele ser más pesado, pasar un argumento al método o que el método use un método interno para obtener el atributo?
Muchas gracias por adelantado y saludos ;)