Uso de variables de los padres en una clase extendida en PHP

Question

Tengo 2 clases, principal y extendida. Necesito usar VARs principales en la clase extendida.

<?php
class Main {
  public $vars = array();
}

$main = new Main;

$main->vars['key'] = 'value';

class Extended extends Main { }

$other = new Extended;

var_dump($other->vars);

?>

A quién puedo hacerlo?

No válido por ejemplo:

<?php
class Extended extends Main {
  function __construct ($main) {
    foreach ($main as $k => $v) {
      $this->$k = $v;
    }
  }
}
?>

Necesito alguna solución más transparente y eficiente:)

Answer 1

Editar : Esto se puede resolver mucho mejor con Inversión de Control (COI) y Inyección de dependencias (DI). Si usa su propio marco o uno sin Inyección de dependencias del envase Liga / contenedor

Respuesta abajo a la izquierda como la historia de respuestas tontas.

---

La forma correcta Calculo.

<?php
class Config {
    protected $_vars = array();

    protected static $_instance;

    private function __construct() {}

    public static function getInstance()
    {
        if (!isset(self::$_instance)) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }

    public function &__get($name) {
        return $this->_vars[$name];
    }

    public function __set ($name, $value) {
        $this->_vars[$name] = $value;
    }
}

$config = Config::getInstance();
$config->db = array('localhost', 'root', '');
$config->templates = array(
    'main' => 'main',
    'news' => 'news_list'
);

class DB {
    public $db;

    public function __construct($db)
    {
        $this->db = $db;
    }

    public function connect()
    {
        mysql_connect($this->db[0], $this->db[1], $this->db[2]);
    }
}

$config = Config::getInstance();
$db = new DB($config->db);
$db->connect();

class Templates {
    public $templates;

    public function __construct($templates)
    {
        $this->templates = $templates;
    }

    public function load ($where) {
        return $this->templates[$where];
    }
}

$config = Config::getInstance();
$templates = new Templates($config->templates);
echo $templates->load('main') . "\n";

Answer 2

Sería posible fácilmente con un simple constructor

<?php

class One {

    public static $string = "HELLO";

}

class Two extends One {

    function __construct()
    {
        parent::$string = "WORLD";
        $this->string = parent::$string;
    }

}

$class = new Two;
echo $class->string; // WORLD

?>

Answer 3

Me di cuenta que es super viejo, pero en caso de que alguien más tiene una pista ...

¿Ha considerado el uso de variables estáticas?

El patrón de diseño PHP programación orientada a objetos es tal que estáticamente por las variables de un padres de clase siguen siendo los mismos en el menor clase, también.

Por ejemplo ...

<?php
class A {
    public static $test = 'a';

    public function test() {
        echo 'Test is: '.self::$test;
    }

}
class B extends A {
    public static $test = 'b';
}
$obj = new B;
$obj->test();
?>

La ejecución de este código (en PHP 5.3- Estoy seguro de que es el mismo para las otras versiones, también) le dará el siguiente resultado:

prueba es: a

Por lo que pude reunir en su OP, que busca una manera para que los variables de clase de padres para permanecer - incluso en las clases extendidas. Esto resuelve ese problema.

Para llamar a las variables públicamente fuera del ámbito de la clase (es decir, donde normalmente se escribe $ obj-> vars ), que había necesidad de crear una función en la clase padre que hace referencia a self::$variable_name para que se pueda tirar esa variable volver al código que utiliza ya sea esta última, o cualquier otra clase que se extiende a él.

Por ejemplo, algo como:

public function get_variable() {
    return self::$variable;
}

También puede crear un método mágico que echar hacia atrás de forma dinámica la variable self :: $ basado en lo que pide la instancia de - es decir, un método o una variable. Se podía conectar el código para lanzar de nuevo el self :: $ variables equivalente en cualquier caso.

http://php.net/manual/en/language. oop5.magic.php para obtener más información sobre los diferentes métodos mágicos que le permiten hacer este tipo de cosas.

El PO fue un poco críptico, así que no estaba seguro de si eso es exactamente lo que quería, pero no vi a nadie más aquí referencia a variables estáticas así que pensé que interrumpiría - espero que ayude

Answer 4

Creo que se necesita para ser más clara en lo que quiere. Imagínese que usted tenía varios casos de ambos principal y extendido. En caso de que todos ellos se refieren a los mismos datos, por lo que si cambia los datos en cualquiera de ellos, todos están afectados?

Si es así, a continuación, uno de los enfoques es utilizar una variable estática, que está ligada a la clase en lugar de la instancia individual. Otra es la de crear un objeto separado (de una clase diferente) para almacenar sus datos, y pasarlo a la principal y las clases extendidas cuando se crean. Cada uno de ellos se podrían almacenar una referencia a la misma, por ejemplo:.

class Main {
   public $data;
   function __construct(Data $data) {
     $this->data = $data;
   }
}
class Extended extends Main {}

$ourData = new Data();
$ourData->vars = array(1,2,3);

$main = new Main($ourData);
$other = new Extended($ourData);

Si no es así, entonces usted quiere copias de los datos, en lugar de referencias a los mismos datos. En ese caso, su segundo ejemplo está más cerca, aunque no me acaba de copiar ciegamente todos los miembros.

Answer 5

oooooooooooooooooooooooooooooooooooooooooooooooooooooh

desea que esta:

class Config
{
    private $m_vars = array();

    function __get($name)
    {
        return $this->m_vars[$name];
    }

    function & __set($name, $value) // << the & is important!
    {
        $this->m_vars[$name] = $value;
    }
}

class Db
{
    funciton __construct(Config $config)
    {
        $this->Connect($config->host, $config->user, $config->pass, $config->db);
    }
}

$config = new Config();
$config->host = "localhost";
...
$db = new Db($config);

:)

EDIT:

También, usted puede hacer esto:

class Templator
{
    private $m_config = null;
    function __construct($config)
    {
        $this->m_config = $config;
    }

    function PrintTemplate($name)
    {
        echo file_get_contents($this->m_config->template_path . $name);
    }

}

$config->template_path = "./templates/";
$temp = new Templator($config);
$temp->PrintTemplate("index.html");