Mit parent-Variablen in eine erweiterte Klasse in PHP

BEARBEITEN: Dies kann gelöst werden, viel besser mit Inversion of Control (IoC) und Dependency Injection (DI). Wenn Sie Ihren eigenen Rahmen oder ohne Dependency Injection Container versuchen Liga/Container

Antwort unten Links, wie es die Geschichte der dummen Antworten.

Den richtigen Weg, finde ich.

<?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";

InformationsquelleAutor OIS

Ich weiß, das ist super alt, aber in Fall, jemand Bedürfnisse eine Ahnung...

Haben Sie als statische Variablen?

PHP OOP design pattern ist eine solche, die statisch deklarierte Variablen in einer Eltern Klasse bleiben die gleichen in der Kind Klasse, zu.

Zum Beispiel...

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

Dieser code ausgeführt (auf PHP 5.3 - ich bin sicher, es ist das gleiche für die anderen Versionen) geben Sie das folgende Ergebnis:

Test: ein

Von dem, was ich sammeln konnte in Ihrer OP sind Sie auf der Suche nach einem Weg für die übergeordneten Klasse Variablen zu bleiben - auch in großen Klassen. Dies löst dieses problem.

Nennen die Variablen, die öffentlich außerhalb der Gültigkeitsbereich der Klasse (also, wo würden Sie normalerweise schreiben $obj->vars), würden Sie brauchen, um eine Funktion zu erstellen, in der übergeordneten Klasse, die Verweise self::$variable_name so dass er werfen kann, dass die variable auf den code, der nutzt entweder die Klasse oder eine andere Klasse, die Sie erweitert.

Zum Beispiel, etwas wie:

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

Könnten Sie auch schaffen eine Magische Methode, die dynamisch werfen zurück self::$variable basiert auf der Frage der Instanz - d.h. eine Methode oder eine variable. Sie könnten Draht, den code zurück zu werfen self::$variable entspricht in jedem Fall.

Lesen http://php.net/manual/en/language.oop5.magic.php für weitere Informationen über die verschiedenen magischen Praktiken, die es Ihnen ermöglichen, das zu tun diese Art von Sachen.

Die OP war ein bisschen kryptisch, so war ich nicht sicher, ob das ist genau das, was Sie wollte, aber ich wollte nicht sehen, jemand anderes hier Referenz-statische Variablen, also dachte ich würde Glockenspiel - hoffe es hilft!

InformationsquelleAutor Lee Benson

oooooooooooooooooooooooooooooooooooooooooooooooooooooh

du willst:

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:

können, können Sie auch dies tun:

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

InformationsquelleAutor nlaq