7. PHP¶

Grundsätzlich zu empfehlende Quellen:

7.1. Grundlagen in Objekt orientierter Entwicklung¶

7.1.1. Das schreiben von Klassen¶

7.1.2. Das instantiieren von Klassen¶

Grundsätzlich wird eine neue Instanz via new Classname erzeugt, dabei sind die Klammern optional: new Classname().

Teilweise sieht man auch folgende Konstrukte:

class Singleton
{
    /**
     * @var Singleton The reference to *Singleton* instance of this class
     */
    private static $instance;

    /**
     * Returns the *Singleton* instance of this class.
     *
     * @return Singleton The *Singleton* instance.
     */
    public static function getInstance()
    {
        if (null === static::$instance) {
            static::$instance = new static();
        }

        return static::$instance;
    }
    /**
     * Protected constructor to prevent creating a new instance of the
     * *Singleton* via the `new` operator from outside of this class.
     */
    protected function __construct()
    {
    }
    /**
     * Private clone method to prevent cloning of the instance of the
     * *Singleton* instance.
     *
     * @return void
     */
    private function __clone()
    {
    }
    /**
     * Private unserialize method to prevent unserializing of the *Singleton*
     * instance.
     *
     * @return void
     */
    private function __wakeup()
    {
    }
}

class SingletonChild extends Singleton
{
}

$obj = Singleton::getInstance();
var_dump($obj === Singleton::getInstance());             // bool(true)
$anotherObj = SingletonChild::getInstance();
var_dump($anotherObj === Singleton::getInstance());      // bool(false)
var_dump($anotherObj === SingletonChild::getInstance()); // bool(true)

Source: https://phptherightway.com/pages/Design-Patterns.html

Damit werden Singletons implementiert. Singletons gelten allerdings als Anti-Pattern.

In TYPO3 gibt es noch folgende zwei Arten Instanzen von Klassen zu erzeugen:

// Example 1
GeneralUtility::makeInstance(ExampleClassName::class);

// Example 2
GeneralUtility::makeInstance(ObjectManager::class)
   ->get(ExampleClassName::class);

Bei diesen Beispielen wird jeweils TYPO3 über eine API gebeten die Instanz zu erzeugen. Dadurch können alternative Implementierungen hinterlegt werden, und TYPO3 kann weitere Schritte unternehmen. So kann im 2. Beispiel die Dependency Injection getriggert werden. In beiden Fällen bietet TYPO3 bereits eine Implementierung für Singletons.

7.1.3. Einschränkung der Sichtbarkeit von Methoden und Eigenschaften¶

PHP bietet mittlerweile folgende Zugriffsbeschränkungen für Eigenschaften, Methoden und Konstanten (seit PHP 7.1.0):

public: Ist grundsätzlich erreichbar.
protected: Ist nur innerhalb der Definition (gleiche Klasse) und in Unterklassen (Klassen welche die Definition erweitern) erreichbar.
private: Ist nur innerhalb der Definition (gleiche Klasse) erreichbar.

Weitere Infos findet man unter https://www.php.net/manual/en/language.oop5.visibility.php

Grundsätzlich sollte private genutzt werden. Alles andere ist öffentliche API, für Kindklassen oder externe Klassen. Somit ist jede Anpassung an der API, welche Breaking ist, mit potenziellem Aufwand verbunden.

7.2. Verwendung von Namespaces in PHP¶

7.2.1. PSR-4 Autoloading¶

PSR-4 ist ein Standard der definiert wie Autoloading im Dateisystem, entsprechend eines Klassennamens ablaufen soll.

Dabei wird definiert dass der erste Teil des Namespaces dem Vendor entspricht. Dies sollte ein eindeutiger Identifier sein. Typischerweise entspricht dies z.B. dem Firmennamen oder einem Kürzel wie Codappix oder Cdx. Dieser Vendor definiert wem der Code gehört und verhindert Duplikate.

Anschließend können beliebig viele Bereiche folgen, ehe der eigentliche Klassenname erscheint. Ein Beispiel:

namespace Codappix\CdxExampleExtension\Service\LinkBuildingService

Durch die Verwendung von Composer kann nun innerhalb der composer.json definiert werden, dass das Paket dem PSR-4 folgt und auf welchen Ordner der Vendor gemappt werden soll. Siehe Konfiguration autoloading.

7.2.2. Definieren von Klassen innerhalb eines Namespaces¶

7.2.3. Importieren von Klassen aus einem anderen Namespace¶

7.3. Verwendung von Interfaces (optional)¶

7.3.1. Definieren eines Interfaces (optional)¶

7.3.2. Prüfen einer Instanz auf implementierte Interfaces (optional)¶

7.4. Verwendung von PHPDoc (optional)¶

7.4.1. Syntax des PHPDoc (optional)¶

7.4.2. Schreiben von PHPDoc an Eigenschaften und Methoden (optional)¶

7.4.3. Bedeutung von @param innerhalb von PHPDoc (optional)¶

7.5. Closures (optional)¶

z.B. (function (string $someString) { echo $someString; })(‚ein String‘); (optional)

Inhalt