Ocupar variables globales en clases

[zsamer]

hola tengo una duda, no se si lo que hago es correcto.

Tengo una clase y dentro de ella necesito utilizar el objeto de otra clase (abstracion de base de datos).

Por el momento hago lo siguiente y funciona bien, pero nose si es correcto:

definir globales en los metodos:

Código PHP:

  global $db; 
   

codigo completo:

Código PHP:

  class Config
{

    //Atributos 
    private        $Settings_array;
    private        $plantilla_TemaSelec;
    public         $TemaSelec;
    public         $usuario_cookie;
    
    //Constructor
    function __construct($usuario_cookie)
    {
        $this->usuario_cookie=$usuario_cookie;
        $this->get_config_array();     
    }

    //Metodos
    private function get_config_array()
    { 
        global $db;    
        $result_config = $db->sql_query('SELECT variable,value FROM settings');
        $Settings_array = array();
    
        while ($row_config = $db->sql_fetchrow($result_config))
        {
            $Settings_array[$row_config[0]] = $row_config[1];
        }
        
        $this->Settings_array= $Settings_array;
    }

    public function get_config_row($value_conf)

    {    
        return $this->Settings_array[$value_conf];
    } 
   

Gracias y salu2

zsamer

[enriqueplace]

Iniciado por zsamer

hola tengo una duda, no se si lo que hago es correcto.

Tengo una clase y dentro de ella necesito utilizar el objeto de otra clase (abstracion de base de datos).

Por lo que estuve leyendo, tienes dos opciones (y ya lo comenté en una respuesta reciente): puedes recibir por parámetros el objeto, o tenerlo internamente como parte de la estructura del objeto que lo usa (un atributo).

Iniciado por zsamer

Por el momento hago lo siguiente y funciona bien, pero nose si es correcto:
definir globales en los metodos:

Agh! Nunca uses variables globales cuando trabajes Orientado a Objetos (ni siquiera cuando trabajes estructurado). Estás rompiendo una de las estrategias del la OO: el Encapsulamiento.

Si quieres leer las demás, lee el capítulo de la Wikipedia que trata el tema.

Para tu caso, puedes usar dos estrategias:

1. Crear un objeto DB como parte del atributo de tu clase Config (y lo inicias en el constructor o en el método que realmente lo usa).
2. Recibir por parámetros el objeto DB, creado fuera de la clase Config

Ninguna es mejor que otra, depende de tu contexto.

Pero si tuviera que dar mi opinión (ojo, no conozco tu contexto) usaría la primer opción, así la clase Config queda completamente aislada del mundo exterior (es una clase independiente externamente), y quién la usa, no debe proveerle una instancia de conexión del objeto; es un detalle interno de la clase Config que solo ella debe conocer, escondiendo la complejidad a sus clases "clientes".

Volvemos nuevamente al Encapsulamiento:

• Modularidad - el código fuente de un objeto puede ser escrito y mantenido independientemente del código de otros objetos, de la misma forma, un objeto puede ser transferido alrededor del sistema sin alterar su estado y conducta.
• Ocultamiento de la información - un objeto tiene una "interfaz pública" que otros objetos utilizan para comunicarse con él; el objeto puede mantener información y métodos privados serán cambiados en cualquier momento sin afectar a los otros objetos que dependan de ello.

Nota: muchas veces encuentro desarrolladores que le dan prioridad al lenguaje y a conocerse de memoria todas las funciones que este provee (como en el caso de PHP). Aquí, lo más importante, teniendo en cuenta la POO, son los conceptos alrededor de los Objetos, no las particularidades del lenguaje de turno para programarlos.

Trata de tener primero claro los conceptos básicos de la POO (una fuente puede ser la Wikipedia) y luego trata de aprender algo de UML (que facilita enormemente la abstracción), y cada vez que necesites de funciones del lenguaje, abres una solapa del navegador y buscas la función en la sección correspondiente (y no necesitas aprenderla de memoria).

Si cambias de lenguaje, podrás seguir programando OO pues los conceptos serán los mismos, pero las funciones y la sintaxis del lenguaje cambiarán, lo cual la experiencia anterior te servirá de poco.

[zsamer]

entonces tomando en cuenta la primera opción :

Crear un objeto DB como parte del atributo de la clase Config y lo inicio en el constructor:
Es correcto lo siguiente:

Código PHP:

  class Config
{
 
    //Atributos 
    private        $Settings_array;
    private        $plantilla_TemaSelec;
    public         $TemaSelec;
    public         $usuario_cookie;
    private        $db;
    
    //Constructor
    function __construct($usuario_cookie)
    {
        $this->$db = new sql_db($servidorBD, $usuarioBD, $passBD, $nombreBD, false);
        $this->usuario_cookie=$usuario_cookie;
        $this->get_config_array();
    } 
   

Mi duda es que estaría volviendo ha hacer una nueva conección a la base de datos y eso podria tener problemas de performance al tener mas de una conexion abierta.

¿Es asi o no tiene impacto en el perfomance al Crear mas de una vez el objeto DB ?


Gracias y saludos.

[enriqueplace]

Primer sugerencia: es casi lo mismo crear "variables globales" y "atributos públicos". Por defecto, si no le pones su "visibilidad" el intérprete lo toma como "privado".

"En resumen: no uses nunca atributos públicos"

Lo normal es que uses "atributos privados" y a veces "atributos protegidos", y cuando quieras acceso a los mismos desde fuera de la clase creas los famosos "métodos accesores/modificadores" (getter y setter). Aquí te dejo un enlace al foro donde tocamos este mismo tema.

Código PHP:

      //Atributos 
    private        $Settings_array;
    private        $plantilla_TemaSelec;
    public         $TemaSelec;
    public         $usuario_cookie;
    private        $db; 
   

No me queda muy claro tus intenciones, ¿pero el $usuario_cookie no es el mismo que el que pasas por parámetros en el constructor, no?

Código PHP:

      //Constructor
    function __construct($usuario_cookie)
    {
        $this->$db = new sql_db($servidorBD, $usuarioBD, $passBD, $nombreBD, false);
        $this->usuario_cookie=$usuario_cookie;
        $this->get_config_array();
    } 
   

¿Y de donde vienen la variables que contienen la información de conexión?

Iniciado por zsamer

Mi duda es que estaría volviendo ha hacer una nueva conección a la base de datos y eso podria tener problemas de performance al tener mas de una conexion abierta.

¿Es asi o no tiene impacto en el perfomance al Crear mas de una vez el objeto DB ?

Son dos cosas distintas, una cosa es tener varias instancias de un objeto, y otra es tener varias conexiones a una base.

No necesariamente es malo, pero se puede mitigar con varias estrategias. A veces caemos en el "exceso de optimización" o de "optimización prematura", cuando en verdad las bases de datos existen para usarlas, lo mismo los objetos... el problema es si lo estamos haciendo mal.

Si tu problema es la cantidad de conexiones, puedes implementar el patrón de diseño Singleton, el cual te mantiene siempre la misma conexión en todo el proceso de tu sistema.

También podrías estudiar que la información de conexión esté en un archivo de configuración y no en memoria, o directamente en la base de datos, y luego manejas una "sesión" que caduque en el tiempo (para no tener información del usuario en memoria).

[zsamer]

si el $usuario_cookie lo paso por parametro en el constructor. las variables de conección a al bse de datos bienen más arriba.

Código PHP:

  // Servidor de la Base de Datos 
$servidorBD="localhost"; 
// Usuario de la Base de Datos 
$usuarioBD="root"; 
// Contraseña de la Base de Datos 
$passBD=""; 
// Nombre de la Base de Datos 
$nombreBD="test_db"; 
   

se me olvidó pasarlo por parametros tambioen en el constructor.

osea:

Código PHP:

   function __construct($usuario_cookie,$servidorBD, $usuarioBD, $passBD, $nombreBD)
    {
        $this->$db = new sql_db($servidorBD, $usuarioBD, $passBD, $nombreBD, false);
        $this->usuario_cookie=$usuario_cookie;
        $this->get_config_array();
    } 
   

[zsamer]

Muchas Gracias Enrique ahora me ha quedado muchos más claro.

saludos,

zsamer