eigenen pseudo Datentyp definieren

[1unitedpower]

Nun, vielleicht denkst du nur zu kompliziert. Wenn die Datenbank-Klasse Zugangsdaten braucht, dann könntest du folgende Klasse erstellen:

class PdoServerDetails {
  public $dsn;
  public $username;
  public $password;
}

Fertig ist der Datentyp. Die Frage ist aber, ob sich das lohnt oder ob man nicht die drei Strings als Einzelwerte übergibt.

So ähnlich hätte ich es auch gemacht, wenn man will, kann man das zu einem Builder ausgbauen:

class PdoBuilder
{
    private $dsn;
    private $username;
    private $password;
    private $options = array();

    public function withDsn (string $dsn) : PdoBuilder {
        $this->dsn = $dsn;
        return $this;
    }

    public function withUsername (string $username) : PdoBuilder {
        $this->username = $username;
        return $this;
    }

    public function withPassword (string $password) : PdoBuilder {
        $this->password = $password;
        return $this;
    }

    public function withOptions (array $options) : PdoBuilder {
        $this->options = $options;
        return $this;
    }

    public function create () : PDO {
        if (empty($this->dsn)) {
            throw new Exception('Missing DSN. Consider calling the `withDsn`-method on this builder before invoking the `create`-method.');
        }
        return new PDO (
            $this->dsn,
            $this->username,
            $this->password
            $this->options
        );
    }
}

Der Nachteil ist ganz klar die Wortfülle der Implementierung. Der Vorteil ist die einfache Handhabung für den Nutzer.

$pdo = (new PdoBuilder())
    ->withUsername($username)
    ->withPassword($password)
    ->withDsn($dsn)
    ->withOptions($options)
    ->create();

Man hat nicht das Problem von assoziativen Arrays, dass sich Typos bei der Erzeugung einschleichen können. Gleichzeitig spielt die Reihenfolge in denen man die Paramter übergibt aber auch keine Rolle. Außerdem sind dadurch die Erzeugung und Nutzung der Obejkte klar voneinander getrennt. Man muss die öffentliche Schnittstelle der zu erzeugenden Klasse nicht anfassen. Der Ansatz eignet sich also insbesondere dann, wenn man mit fremden Klassen arbeitet oder wenn man seine Schnittstelle nicht ändern will, weil man dadurch eine inkonsistente API oder eine Abwärtsinkompatibilität erzeugen würde.