Witam wszystkich jako nowy użytkownik tego forum

Siedzę ostatnio nad własnym frameworkiem i zatrzymałem się przy plikach konfiguracyjnych, więc zwracam się z pytaniem do Was.

Jaki typ konfiguracji byłby według Was najlepszy i jak najszybszy: pliki XML, INI, czy też PHP (return array(...); itd.)
Właściwie zastanawiam się nad wyborem między XML, a PHP, z czego bardziej przychylny jestem drugiej opcji, jednak tutaj pojawia się kolejny problem,
mianowicie, nie wiem jak skonstruować klasę konfiguracji:
Czy wykorzystać ArrayObject i sprawić, żeby instancja klasy reprezentowała dany plik konfiguracyjny,
czy też "ładować wszystko do jednego worka", czyli zrobić taki jakby rejestr zawierający całą konfigurację?

A przy okazji rejestrów - zaimplementowałem już rejestr (taki ogólny, do przechowywania wszelkich danych globalnie) - czy warto podczepić pod niego konfigurację?

Kazdy robi to jak chce.
Xml czy Array czy Csv lub Ini to bez roznicy co uwazasz za bardziej wygodne stosujesz.

Ja konfiguracje bibliotek trzymam w array z php-a bo w sumie maja one tylko cos wspolnego z programista, a konfiguracje komponentow i plugin-ow mam w xml bo poprostu sa dosyc duze i zeby kazdy mogl sobie sam ustawic.


Rejestr,Singleton co tylko ze chcesz jak nie uzywam ani jedngo poprostu mam cache konfiguracji i jesli juz dana konfiguracja zostala juz gdzies zaladowana to nie laduje jej x2

Dzięki za odpowiedź.
W sumie dobry pomysł z tym cachowaniem, chociaż wydajnościowo myślę że wyjdzie podobnie jak w przypadku rejestru, ale jeszcze to sprawdzę.
A co do typu konfiguracji podsunąłeś dobrą kwestię, więc zostanę przy array, a inne typy zostawię do modułów.

1. Definiujesz sobie interfejs w oparciu o który Twój framework będzie mógł pobierać informacje.
2. Tworzysz osobną klasę dla każdego źródła konfiguracji (XML, YAML, PHP itd.).

Przede wszystkim na start powinieneś udostępnić sobie konfigurację w XML/PHP.

Tak ale np taka konfiguracje xml/ini/csv trzeba przeprasowac wiec robisz cache z przeparsowana konfiguracja do array-a z php

A to co napisal @Crozin to uwazalem za oczywiste wiec nie wspomnialem aplikacja powinna pozwalac na rozne typy konfigruacji

No wiadomo że oczywiste Mnie chodziło tylko o to, który typ wykorzystać najlepiej jako przewodni

XML - ze względu na wszechobecne wsparcie tego formatu, podpowiadanie/sprawdzanie składni w edytorze oraz podpowiadanie konkretnej struktury dokumentu (schema/dtd).

To jeszcze pozostaje pytanie, czy klasę konfiguracji zrobić jako rozszerzenie ArrayObject, czy też wywoływać przy użyciu getterów i setterów?

Co do ArrayObject, chyba każdy wie jak to wygląda, ale z getterami i setterami chodzi mi o wywoływanie ustawień na zasadzie:

W pliku konfiguracyjnym:

[PHP] pobierz, plaintext 
<?php
return array(
    "mysql" => array(
        "host" => "localhost",
        "port" => 3306,
        "user" => "root",
        "password" => "",
    ),
    // itd.
);
?>
[PHP] pobierz, plaintext 

I aby wywołać, np. nazwę użytkownika bazy:

[PHP] pobierz, plaintext 
$oConfig = Config::load("database", Config_Array::instance());
 
print $oConfig->mysql->user;
[PHP] pobierz, plaintext 

Użycie getterów i setterów, które wygeneruje Ci IDE, udostępni:
1. Pełną kontrolę nad przekazywanymi/zwracanymi wartościami konfiguracyjnymi.
2. Banalnie prostą dokumentację.
3. W pełni statyczną (czytaj: lepszą) strukturę danych - będzie się to też wiązało z koniecznością utworzenia klasy dla każdego złożonego zasobu w konfiguracji.

Skoro piszesz o OOP to raczej:

[PHP] pobierz, plaintext 
$configuration = new XmlConfiguration('/path/to/file');
 
echo $configuration->getDatabaseConfiguration()->getUsername();
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
 
class Config
{
    protected $data;
 
    public function __construct($data = null)
    {
        $this->data = $data;
    }
 
    public function __get($name)
    {
        $this->$name = new Config();
 
        if(isset($this->data[$name]))
        {
            $this->$name = new Config($this->data[$name]);
        }
 
        return $this->$name;
    }
 
    public function isEmpty()
    {
        return empty($this->data);
    }
 
	public function get()
    {
        return $this->data;
    }
 
    public function set($data)
    {
        $this->data = $data;
    }
}
 
$cfg = new Config(array(
    'mysql' => array(
        'host' => 'localhost',
        'port' => 3306,
        'user' => 'root',
        'password' => null,
    )
));
 
 
var_dump($cfg->mysql->get()); // return array('host' => 'localhost', 'port' => 3306, 'user' => 'root', 'password' => null)
 
var_dump($cfg->mysql->host->get()); // return 'localhost'
 
$cfg->mysql->password->set('secret');
var_dump($cfg->mysql->password->get()); // return 'secret'
 
var_dump($cfg->mysql->notDefinded->get()); // return null
[PHP] pobierz, plaintext 

Taki tam przykład jak mógłbyś taką klasę konfiguracji w dość prosty sposób zrobić. Trochę wzorowana na działaniu klasy Zend_Config. Tam to trochę "lepiej" wygląda: http://framework.zend.com/manual/en/zend.c...troduction.html