Witam,
wiem, że za pomocą extract($array) jestem w stanie stworzyć zmienne, a więc takie coś jak poniżej mi zadziała.

[PHP] pobierz, plaintext 
<php
class Test
{
    public $array = array('first' => 'first variable');
 
    public function __construct()
    {
        extract($this->array);
        echo $first; //output: first variable
    }
}
?>
[PHP] pobierz, plaintext 

Lecz jak zrobić to tak żeby zmienne z extract weszły mi pod public $array czyli otrzymałbym coś takiego

[PHP] pobierz, plaintext 
<?php
class Test
{
    public $array = array('first' => 'first variable');
 
    //tutaj juz krok kolejny po wykonaniu extract()
    public $first = 'first variable';
 
    public function __construct()
    {
        extract($this->array);
        echo $this->first; //to powinno działać tylko i wyłącznie po wykonaniu extract ze względu na dynamiczne tworzenie zmiennych.
    }
}
[PHP] pobierz, plaintext 

Najlepiej chciałbym mieć możliwość stworzenia czegoś na wzór powyższego z dynamicznym tworzeniem zmiennych, ale w klasie statycznej tj:

[PHP] pobierz, plaintext 
class Test
{
    private static $array = array('first' => 'first variable'); //to byłoby pobierane z pliku, ale teraz jest array na potrzeby tego postu
 
    public static function loadConfigFile()
    {
        //rozpoznanie srodowiska, w ktorym pracuje
        //ładowanie pliku z konfiguracją i tym samym tymi zmiennymi na podstawie rozpoznanego srodowiska
        //np. ładuje config_dev.yml
        self::createVariables();
    }
 
    /*
    * $_data => data from config file after parse
    */
    private static function createVariables($_data)
    {
        //tutaj odbieram przekazane dane z pliku i chciałbym zrobić extract
        extract($_data);
    }
 
}
[PHP] pobierz, plaintext 

Teraz z innej klasy chciałbym mieć do tego dostęp tj:

[PHP] pobierz, plaintext 
class Start
{
    public function __construct()
    {
        Config::loadConfigFile();
        echo Config::$first;
    }
}
[PHP] pobierz, plaintext 

Da się to jakoś zrobić?
Wiem, że się trochę rozpisałem, ale mam nadzieję, że jest to w jakimś stopniu zrozumiałe.

Pozdrawiam,
Szymon

Ale po co tworzyć takiego paskudnego potworka, jak można utworzyć sobie prosty obiekt-kontener*, który będzie robił to samo, ale o wiele lepiej? Bo co za różnica czy napiszesz sobie:

[PHP] pobierz, plaintext 
echo Config::$first;
echo $config->get('first');
[PHP] pobierz, plaintext 

(pomijając fakt, że pierwsze rozwiązanie ma same wady, a drugie kilka sporych zalet).


* na dobrą sprawę, można sobie nawet rozszerzyć ArrayAccess, żeby uniknąć powielania istniejącego kodu.

EDIT: Drobna "literówka" się wkradła w post.
EDIT2: Oczywiście to drugie rozwiązanie jest lepsze.

Tworzysz zmienną główną:

[PHP] pobierz, plaintext 
class Config {
 
private $_data = array();
 
}
[PHP] pobierz, plaintext 

Następnie dodajesz __get i __set

[PHP] pobierz, plaintext 
class Config {
 
private $_data = array();
 
public function __get($key) {
return $this->_data[$key];
}
 
public function __set($key, $value) {
$this->_data[$key] = $value;
}
 
}
[PHP] pobierz, plaintext 

Potem dodajesz swoje funkcje ładujące, które dodają dane do $_data, a potem się odwołujesz. Przykład:

[PHP] pobierz, plaintext 
// PRZYKŁAD !
$config = Config::instance();
echo $config->maxAllowedUsers;
echo $config->connectionTimeout;
echo $config->somethingElse;
 
[PHP] pobierz, plaintext 

// ADD

[PHP] pobierz, plaintext 
<?php
 
class Config
{
    public $configFile = array('first' => 'first variable');
    public $data;
 
    public function __construct()
    {
        //tworzenie instancji
        $this->createVariables();
    }
 
    public function createVariables()
    {
        foreach ($this->configFile as $key => $value)
        {
            $this->$key = $value;
        }
    }
 
    public function __get($_key)
    {
        return $this->data[$_key];
    }
 
    public function __set($_key, $_value)
    {
        $this->data[$_key] = $_value;
    }
}
 
var_dump(new Config());
[PHP] pobierz, plaintext 

Tylko teraz pytanie jak z utrzymaniem tych danych?
Skoro zrobię w Start.php instancję tej klasy i uruchomię ładowanie pliku, a później gdzieś indziej będę chciał wykorzystać te zmienne czyli np. w klasie Logout czyli praktycznie na samym końcu...

Jak znowu stworzę instancję tej klasy i dane będą zapisane, to super, ale co wtedy z wydajnością? Może trochę głupie pytania, nie mam za bardzo, gdzie teraz tego sprawdzić. Dopiero w domu.

1. Wywal metody __get()/__set() na rzecz normalnych get()/set(). Obecne rozwiązanie nie przynosi Ci absolutnie żadnej korzyści, a tworzy kilka idiotycznych problemów oraz zmniejsza czytelność kodu.
2. Raz utworzony obiekt przekazujesz sobie tam gdzie go potrzebujesz - Google: dependency injection. Chociaż taki obiekt jak "Logout", raczej nie będzie potrzebował zależności do całego obiektu konfiguracji.

1)
index.php

[PHP] pobierz, plaintext 
<?php
include_once 'Config.php';
 
$config = Config::getInstance();
var_dump($config);
 
echo '<a href="logout.php">Logout</a>';
[PHP] pobierz, plaintext 

logout.php

[PHP] pobierz, plaintext 
<?php
include_once 'Config.php';
 
$config = Config::getInstance();
echo $config->get('first');
[PHP] pobierz, plaintext 

Config.php

[PHP] pobierz, plaintext 
<?php
 
<?php
 
class Config
{
    public $configFile = array('first' => 'first variable');
    public $env = 'prod';
    public $data;
 
    private static $_instance = NULL;
 
    /*
     * Creates instance of Config class
     * 
     * @return $Config
     */
    public static function getInstance()
    {
        if (self::$_instance === NULL)
        {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
 
    public function __construct()
    {
        $this->loadFile();
        $this->createVariables();
    }
 
    public function loadFile()
    {
        switch ($this->env)
        {
            case 'prod' :
                $file = 'config_prod.yml';
                break;
            case 'dev' :
                $file = 'config_dev.yml';
                break;
        }
 
        var_dump('Loaded file: ' . $file);
    }
 
    /*
     * Creates variables from the config file
     */
    public function createVariables()
    {
        foreach ($this->configFile as $key => $value)
        {
            $this->set($key, $value);
        }
    }
 
    public function get($_key)
    {
        return $this->data[$_key];
    }
 
    public function set($_key, $_value)
    {
        $this->data[$_key] = $_value;
    }
}
[PHP] pobierz, plaintext 

2) Co do dependency injection mam zamiar się wziąć powoli i tak ogólnie za wzorce projektowe, aczkolwiek nie wiem kiedy znajdę chwilę na to, bo matura niedługo.

Takie coś już jest dobrze wg Ciebie Crozin?

Dependency Injection i inne podstawy OOP w 45 sekund:
1. Obiekt w miarę możliwości nie powinien odwoływać się do niczego co pochodzi spoza jego samego, tj. żadnych zmiennych globalnych czy odwołania do innych klas (patrz: Config::getInstance() czy zapisanie nazw plików wewnątrz klasy).
2. Biorąc sobie do serca punkt pierwszy, musimy dojść do wniosku, że wszelkie zależności muszą być przekazane przez argumenty metod.
2.1. Jeżeli jakaś zależność jest niezbędna do działania obiektu, powinna być przekazana już w konstruktorze.
2.2. Jeżeli jakaś zależność jest opcjonalna można dla niej utworzyć osobnego settera.
3. Każdy obiekt zajmuje się jedną rzeczą (czyli taki obiekt Config nie bawi się już w rozpoznawanie czy pracuje w środowisku produkcyjnym czy deweloperskim).
4. Gdzie się tylko da unikamy static (tutaj nie ma żadnej przesłanki sugerującej konieczność skorzystania z tego).
5. Dbamy o obsługę błędów (metoda get() powinna rzucić wyjątek InvalidArgumentException w przypadku odwołania się do nieistniejącego klucza).

Oczywiście nie są to jakieś nienaruszalne zasady, ale jeżeli je łamiesz musisz to robić świadomie i umieć sobie odpowiedzieć dlaczego warto je łamać.

3. Czyli powinienem mieć osobną klasę do rozpoznania środowiska na wzór np.

[PHP] pobierz, plaintext 
class Environment
{
    public static $env = 'prod';
 
    public static function getEnv()
    {
        return self::$env;
    }
 
//lub
    public static function getEnv()
    {
        switch (self::$env)
        {
            //case takie jak w config
        }
 
        return $file;
    }
[PHP] pobierz, plaintext 

i teraz w Config

[PHP] pobierz, plaintext 
public function loadConfigFile()
{
    YamlReader.load(Environment::getEnv());
}
[PHP] pobierz, plaintext 

5. To jest właśnie to, gdzie pewnie w wielu przypadkach brakuje i chyba wezmę to sobie do serca i poćwiczę jeszcze coś takiego.

Wrócę do tego później, bo za 13min jest dzwonek i koniec lekcji przy komputerze.

Dziękuję Ci bardzo za te rady - jeszcze popatrzę na przykłady DI.

Ale chyba Config jeszcze może zająć się ładowaniem konkretnego pliku konfiguracyjnego?