Mit übergeordneten Variablen in einer erweiterten Klasse in PHP

Question

Ich habe 2 Klassen, Haupt- und erweitert. Ich brauche Haupt Vars in erweiterten Klasse verwenden.

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

$main = new Main;

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

class Extended extends Main { }

$other = new Extended;

var_dump($other->vars);

?>

Wen kann ich es tun?

Keine gültige zum Beispiel:

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

Ich brauche eine Lösung transparente und effiziente:)

Answer 1

Bearbeiten : Das kann viel besser mit Inversion of Control (IOK) und Dependency Injection (DI) gelöst werden. Wenn Sie Ihren eigenen Rahmen oder eine ohne Dependency Injection Container versuchen Liga / Container

Antwort unten links als Geschichte der dummen Antworten.

---

Der richtige Weg Ich stelle dar.

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

Es wäre mit einem einfachen Konstruktor ohne weiteres möglich sein

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

Ich weiß, das ist super-alt, aber falls jemand anderes muss eine Ahnung ...

Haben Sie statische Variablen in Betracht gezogen?

Das Designmuster PHP OOP ist so, dass statisch deklarierten Variablen in einem Eltern Klasse bleibt gleich in der Kind Klasse auch.

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

Ausführen von Code (auf PHP 5.3- Ich bin sicher, dass es auch für andere Versionen ist auch) gibt Ihnen folgendes Ergebnis:

Test: a

Von dem, was ich in Ihrem OP sammeln konnte, Sie suchen nach einem Weg für das Elternklassenvariablen bleiben - auch in großen Klassen. Dies löst das Problem.

die Variablen außerhalb des Klassen Umfang öffentlich zu nennen (dh, wo Sie normalerweise schreiben würden $ obj-> Vars ), Sie bräuchten eine Funktion in der übergeordneten Klasse erstellen, die self::$variable_name verweist so dass es diese Variable zurück auf den Code werfen kann, die entweder die Klasse, oder jede andere Klasse, die es sich nutzt.

Zum Beispiel so etwas wie:

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

Sie können auch eine magische Methode erstellen, die self :: $ Variable dynamisch zurückwerfen würde auf, was Sie fragen die Instanz für - das heißt, eine Methode oder eine Variable. Sie könnten den Code verdrahten, das Selbst zu werfen zurück :: $ variable Äquivalent in jedem Fall.

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

Die OP war ein wenig kryptisch so war ich nicht sicher, ob das ist genau das, was Sie wollten, aber ich habe niemanden gesehen anderes verweisen hier statische Variablen, also dachte ich läuten würde - hoffe, es hilft

Answer 4

Ich glaube, Sie mehr darüber im Klaren sein, was Sie wollen. Stellen Sie sich vor, dass Sie mehrere Instanzen von beiden Haupt und Extended hatte. Sollten sie alle auf die gleichen Daten verweisen, so dass, wenn Sie die Daten in einem von ihnen ändern, sie sind alle betroffen?

Wenn ja, dann ein Ansatz ist eine statische Variable zu verwenden, die auf die Klasse gebunden ist eher als Einzelfall. Ein weiterer Grund ist ein separates Objekt zu erstellen (von einer anderen Klasse), um Ihre Daten zu speichern, und übergeben sie an den Haupt- und erweiterten Klassen, wenn sie erstellt. Sie können jeweils speichern einen Verweis darauf, z.

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

Wenn nicht, dann Sie Kopien der Daten wollen, anstatt Verweise auf die gleichen Daten. In diesem Fall ist Ihr zweites Beispiel näher, obwohl ich würde nicht einfach blind alle Mitglieder kopiert werden.

Answer 5

oooooooooooooooooooooooooooooooooooooooooooooooooooooh

Sie wollen, dass diese:

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:

auch, Sie können 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");