Optimización: pasar argumento a un método o usar un método interno, un getter

[Covids0020]

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 ;)

[Covids0020]

umm... bueno, lo preguntaré de otra manera, que me lío mucho.
En relación a rendimiento y funcionamiento interno de php:
¿qué método podría ser mejor: A, B, da igual?

Código PHP:

  public function setConfig($config) {
    $this->_config    = $config;
    // A: Pasando un argumento
    $this->setQuery($config->query);
    // B: Usando un método interno para obtener $this->_config->query
    $this->setQuery();
}
// A.
public function setQuery($query) { // ... }
// B.
public function setQuery()       { $config = $this->getConfig(); //... }
// Getter
public function getConfig() { return $this->_config; }  
   

;)

[GatorV]

Bueno dejando de lado que un setter debe ser para establecer un valor, todo depende de la cantidad de información que vayas a pasar, sí es un objeto esto es muy rápido, ya que los objetos se pasan por referencia y no por valor.

En cambio si es un valor plano, depende de la cantidad de información de que estés pasando de un lado a otro.

Saludos.

[Covids0020]

Gracias, como siempre, GatorV ;)
Lo he mirado 20 veces y no me queda claro del todo a qué te refieres con lo "establecer un valor", ¿te refieres a "establecer un (sólo) valor" - por setConfig() -?
O lo dices por esto:

Código PHP:

  // B.
public function setQuery() { $config = $this->getConfig(); //... }  
   

Obviamente, al método le falta lo principal, establecer el valor, pongámoslo así:

Código PHP:

  // B.
public function setQuery() { $this->_query = $this->getConfig()->query; }  
   

Se me han quedado muchos de tus consejos GatorV, desde estoy en aquí gg ...y sabía que alguna reprimenda me iba a llevar xD
De todas formas la clase no es así exactamente, lo puse para intentar explicar mi pregunta.

---
En realidad el config es un objeto Zend_Config en el que se mete un objeto $query y arrays de configuración para un layout y una vista. setConfig() en realidad es una especie de bootstrap -sé que debería cambiarle el nombre- que deja disponible la query e inicializa el layout y la vista.
Antes lo tuve todo separado con setters públicos pero era un coñazo :S

[GatorV]

Me refiero a que un set() siempre debe de establecer un valor o mínimo aceptar un valor:

Código PHP:

public function setFoo($Foo = null) {
    if ($Foo == null) {
            $Foo= new DefaultFoo();
    }
 
    $this->foo = $Foo;
}
 

Lo otro pues es lo mismo que te digo, lo más optimo depende del dato que quieras pasar, si es un objeto siempre es más rápido porque son punteros (números) los que se pasan y no todo el objeto entero.

[Covids0020]

Suponía que era esto lo que querías decir, es decir, un setter como debe ser gg
Como mencioné, en el código real, setQuery() es público y acepta un argumento para poder sobreescribir el atributo $query durante la ejecución. setConfig() lo establece sólo para garantizar que ya hay una query válida en la inicialización.

---
No quiero ser pesado, pero la cuestión principal de mi duda, repito en relación al rendimiento, era si sería mejor pasar un dato como argumento o usar otro método para obtener ese dato; pongamos que el dato es exactamente el mismo.
Es decir, si en general, a una función php le "costaría" más llamar a otro método (o función) o usar argumentos.

Si la respuesta va a ser "depende" como intuyo, me doy por contestado ;)

[GatorV]

Creo entonces deberías de ver como trabaja PHP:

Código PHP:

function foo($foo) {
        // haces algo con $foo
}
 
foo($foo); // Aqui PHP crea una copia de tu variable y la pasa a foo()
foo(&$foo); // Aqui PHP crea una referencia de tu variable y la pasa a foo()
 

Al usar dentro de un método:

Código PHP:

public function foo() {
       $foo = $this->foo; // Copia de $this->foo a $foo
       $foo =& $this->foo; //Referencia a $this->foo
}
 

Todo esto es válido para variables nativas, cuando hablas de objetos estos siempre son pasados por referencia.

Ahora cuando te digo que todo depende es de la cantidad de información que vayas a estar pasando, no es lo mismo pasar un string de 5 carácteres, a un string de 5000 carácteres. Así que pues te repito lo mismo:

Depende.

Saludos.

[masterpuppet]

Depende :P, pero como rule of thumb puedes utilizar para esos casos lazy loading en los getters, ahora, si un objeto A para funcionar correctamente necesita de un objeto B, deberías pasar B vía constructor a A.

Saludos.

[Covids0020]

Ummm... debí de explicarme mal porque no es que necesite una solución a mi aplicación, ya funciona como debe, sea más o menos purista a la hora (en concreto) de "nombrar" métodos. Sólo me refería a lo que menciona Gator del funcionamiento de php.
Siendo como será siempre un objeto: Zend_Config o un objeto Query, ya sé que "en mi aplicación" da igual como lo haga.
Masterpupet; sí, setConfig hace esto, asegurar componentes básicos; y la clase es un singleton configurado con setConfig.

Iniciado por Covids0020

Si la respuesta va a ser "depende" como intuyo, me doy por contestado ;)