Zwei Fragen zu Klassen/Funktionen/...

ZappelPhillip · 18. November 2015

Hallo,

seit kurzem beschäftige ich mich etwas mit PHP, nun stehe ich vor zwei Problemen und hoffe, dass mir hier jemand behilflich sein kann.

Ich habe eine Konfigurationsdatei, wo ich allgemeine Daten speicher, diese speicher ich mittels Konstanten.
Nun möchte ich gerne die Konfig-Datei über eine globale Klasse laden und dann ganz normal verwenden können.
Versucht habe ich das nun so:

PHP

<?phpclass GlobalClass {
  public function __construct() {    $this->loadConfig();  }
  function loadConfig() {    require_once __DIR__.'config.php';  }}?>

Da ich Smarty nutze, möchte ich diese Konstanten nun mittels Smarty ganz normal in meinem TPL nutzen.
Leider funktioniert das nicht (wird nichts ausgegeben). Mit dieser Funktion. Wenn ich die Datei hingegen direkt im TPL include, dann geht das.

Das zweite Problem:

Liegt bei Smarty. Da ich die Smarty-Klasse nicht in jeder Datei neu laden will, wollte ich es ebenfalls über diese globale Klasse machen.

Versucht habe ich es wie folgt:

PHP

class GlobalClass {  public static $smarty  public function __construct() {    $this->initSmartyTPL();  }  function initSmartyTPL() {    self::$smarty = new smarty;  }}?>

PHP

class MySite {
  public function getSite() {
  //... DB-Abfragen etc.
  GlobalClass::$smarty->assignByRef('bla', $bla);  GlobalClass::$smarty->display('MySite.tpl');
  }
}

Resultiert in der Fehlermeldung "Call to a Member function assignByRef() on a non-object in ..."

Würde mich freuen, wenn mir jemand weiterhelfen könnte...

cottton · 18. November 2015

Stichwort "Singleton"

PHP

<?php




# main script:
require_once 'pah/path/Singleton.php';




// file: pah/path/Singleton.php
class Singleton 
{  
	private static $_instances;
	public static function init() 
	{    
		require_once __DIR__ . 'config.php'; 
	}
	public static function getInstance($className) 
	{    
        if(!isset(self::$_instances[$classname])){ 
            self::$_instances[$classname] = new $classname(); 
        }
	}
	return isset(self::$_instances[$classname]) ? self::$_instances[$classname] : false;
}
Singleton::init(); // "startet" sich selbst beim laden
// end file







// ...
class MySite {
  public function getSite() {
  //... DB-Abfragen etc.
  	$smarty = Singleton::getInstance('smarty'); 
  	$smarty->assignByRef('bla', $bla);  
  	$smarty->display('MySite.tpl');




        // ... alles, was nur einmal instanziert werden soll, wird per Singelton aufgerufen
        // (du kannst auch sicherstellen, dass zB MySqlClass nicht doch irgendwo instanziert wird -- siehe Bsp unten)
        $MySqlClass = Singleton::getInstance('MySqlClass'); 
  }
}

Alles anzeigen

Auf diese Weise ist
- Singleton vom überall erreichbar (global)
- zB smarty nur ein mal instanziert

hier mal ein ausführliches Bsp / Tests:
(hatte das Thema vor paar Wochen =)

PHP

<?php




/**
 * Class Singleton
 * this singleton class does not allow you to
 *      create instance of Singleton (abstract)
 *      create instance of a class that extends Singleton
 *
 * @method ::getInstance()
 *          requires PHP 5.6.x
 *              ... operator (splat operator)
 *              see "Argument unpacking": http://php.net/manual/en/migration56.new-features.php#migration56.new-features.splat
 */
abstract class Singleton
{
    /**
     * protected: cannot access from outside (ofc)
     *
     * @var array contains instances [class name => obj]
     *
     */
    private static $_instances;




    /**
     * private: cannot create instance of child (also cannot create instance of Singleton)
     *
     * @return null
     *
     */
    private function __construct()
    {
    }




    /**
     * private: cannot clone instance of child
     *
     * @return null
     *
     */
    private function __clone()
    {
    }




    /**
     * final ... function: cannot overwrite method
     *
     * requires PHP 5.6.x
     *          ... operator (splat operator)
     *          see "Argument unpacking": http://php.net/manual/en/migration56.new-features.php#migration56.new-features.splat
     *
     * @param array $args
     *          optional args submitted to $classname __construct()
     * @param null $classname
     *          optional class name to get
     * @return object|bool
     */
    final public static function getInstance(array $args = array(), $classname = null)
    {
        if ($classname === null) {
            /* if no $classname given use called class
                example: A:getInstance() results in $classname === 'A'
            */
            $classname = get_called_class();
        }
        /* static $_instances; -- wont work!
            this __METHOD__ called from A is another context than called from B!
                using self::$_instances instead
        */
        if (!isset(self::$_instances[$classname])) {
            echo PHP_EOL . '+++ new ' . $classname . ' +++' . PHP_EOL;
            self::$_instances[$classname] = new $classname(...$args);
            /* ... operator (splat operator)
                see "Argument unpacking":
                    http://php.net/manual/en/migration56.new-features.php#migration56.new-features.splat
            */
        }
        return isset(self::$_instances[$classname]) ? self::$_instances[$classname] : false;
    }
}




class A extends Singleton
{
    public $var = 'A';
}




class B extends A
{
    public $var = 'B';
}




class C extends B
{
    public $var = 'C';
}




class D extends C
{
    public $var = 'D';




    public function test($classname = null)
    {
        return self::getInstance(array(), $classname);
    }
}




class E extends D
{
    public $var = 'E';
    #public static function getInstance(){} // Fatal error: Cannot override final method Singleton::getInstance() in ...
}




class F extends E
{
    public $var = 'F';
    protected $file, $resource;




    public function __construct($file, $arg2, $agr3, $arg4)
    {
        $this->args = func_get_args();
        $this->resource = fopen($file, 'r');
    }




    public function __wakeup()
    {
        $this->__construct(...$this->args);
    }




    public function read()
    {
        return fread($this->resource, filesize($this->args[0]));
    }
}




foreach (
    array(
        // array(class, array args, classname, expected)
        array('A', null, null, 'A'),
        array('B', null, null, 'B'),
        array('C', array(), 'C', 'C'),
        array('D', null, null, 'D'),
        array('E', null, null, 'E'),
        array('F', array(__DIR__ . DIRECTORY_SEPARATOR . 'test.txt', 'given $arg2', 'given $agr3', 'given $arg4'), null, 'F'),
        array('A', array(), 'E', 'E'),
        array('D', array(), 'F', 'F'),
    )
    as $array
) {
    $class = $array[0];
    $args = $array[1];
    $classname = $array[2];
    $expected = $array[3];
    if ($args === null and $classname === null) {
        $obj = $class::getInstance();
    } elseif ($args === null and $classname !== null) {
        $obj = $class::getInstance(array(), $classname);
    } else {
        $obj = $class::getInstance($args, $classname);
    }
    $chk = ($expected === $obj->var) ? 'OK' : 'ERR';
    echo "test:\t$class\t(expected)$expected === (\$obj->var){$obj->var}\t- $chk\r\n-------------\r\n";
}




echo PHP_EOL . PHP_EOL;




$obj = D::getInstance();
foreach (array('A', 'B', 'C', 'D', 'E', 'F') as $array) {
    $class = $array[0];
    $expected = $array[0];
    $chk = ($expected === $obj->test($class)->var) ? 'OK' : 'ERR';
    echo "test:\t$class\t(expected)$expected === (\$obj->test(\$class)->var){$obj->test($class)->var}\t- $chk\r\n-------------\r\n";
}




echo PHP_EOL . PHP_EOL;




$classname = 'F';
$args = array(__DIR__ . DIRECTORY_SEPARATOR . 'test.txt', 'given $arg2', 'given $agr3', 'given $arg4');
$f = Singleton::getInstance($args, $classname);
var_dump($f);
$f = serialize($f);
var_dump($f);
$f = unserialize($f);
var_dump($f);
var_dump($f->read());




echo PHP_EOL . PHP_EOL;







class X extends Singleton
{
    public function xself()
    {
        var_dump(self::$instances); // Fatal error: Cannot access  property X::$instances in
        // btw: seems a bit "broken" -> access  property ... ? access[][]property ... =)
    }




    public function xparent()
    {
        var_dump(parent::$instances); // Fatal error: Cannot access  property X::$instances in
    }
}




$x = X::getInstance();
#$x->xself(); // Fatal error: Cannot access  property X::$instances in
#$x->xparent(); // Fatal error: Cannot access private property Singleton::$instances in







#$s = new Singleton(); // Fatal error: Cannot instantiate abstract class Singleton in ...
#$g = clone $f; // Fatal error: Call to private F::__clone() from context '' in ...
#$a = new A(); // Fatal error: Call to private Singleton::__construct() from invalid context in ...

Alles anzeigen

ZappelPhillip · 18. November 2015

Ich danke Dir vielmals. Es funktioniert klasse.

Hab mir Dein langes Beispielscript auch eben mal angeschaut. Da ist mir aufgefallen, in Zeile 30 und 40 sind die Funktionen __construct() und __clone() leer, hat das einen tieferen Sinn? Wenn ja warum macht man das so?

cottton · 18. November 2015

Ja, die sind private -- können nicht aufgerufen werden. (siehe comments im code)

ZappelPhillip · 18. November 2015

Ok danke schonmal.

Jetzt habe ich noch eine andere Frage zum Autload bzw. spl_autoload_register.
Welchen Sinn genau soll das haben? Was ich erst darunter verstand war: Ich geb der Funktion einen Pfad unter der sie die Klassen finden kann um sie dann - wenn sie benötigt werden - automatisch zu laden.
Stattdessen muss ich die Klasse im Grunde ja jedesmal selber laden (muss die Funktion ja aufrufen und ihr die zu ladende Klasse mitteilen). Wo ist da der Sinn? Da kann ich doch auch bei der Methode bleiben, einfach die benötigten Klassen direkt über include_once zu laden?
Gibts das irgendwelche Gründe, Vorteile oder irgendeinen Sinn (außer 42), warum ich irgendeine Autload-Funktion nutzen sollte?
Oder hab ich da einfach nur was falsch verstanden bei der Verwendung?

cottton · 18. November 2015

autoload ist kein kleines Thema, aber ich versuchs mal kurz:

Es gibt verschiedene Wege -- google mal nach "php autoload psr-0" oder guck hier http://www.php-fig.org/psr/psr-0/
Hier erstmal die spl_autoload_register():

PHP

spl_autoload_register(
    function($classname){}, // die eigtliche funktion zum auto-laden
    true, // throw exception wenn nicht möglich klasse zu laden
    false // prepend (vorn anhängen) diese autoload funktion (es kann mehrere geben)
);

Ich persönlich hatte immer eigene autoloads geschrieben - also nicht psr-0 o.ä. genutzt.
Das sah dann zB so aus:

PHP

define('INC_PATH_CLASS_BSP_A', 'inc/class/whatever/path/A/');
define('INC_PATH_CLASS_BSP_B', 'inc/class/whatever/path/B/');




spl_autoload_register(
    function($classname){ // die eigtliche funktion zum auto-laden
        foreach(array(
                INC_PATH_CLASS_BSP_A,
                INC_PATH_CLASS_BSP_B, 
            ) as $path
        ){
            if(file_exists($path . $classname . '.php')){
                require_once $path . $classname . '.php'; 
                if(class_exists($classname)){ // das file konnte geladen werden, aber es könnte ja eine andere klasse "drin stecken"
                    return true;
                }
            }
        }
    }, 
    true, // throw exception wenn nicht möglich klasse zu laden
    false // prepend (vorn anhängen) diese autoload funktion (es kann mehrere geben)
);

Alles anzeigen

Das kann aber bissl kaotisch werden, um so mehr Pfade hinzukommen. (nicht empfohlen)

Seit dem ich mit Magento arbeite find ich deren autoload ziemlich geil:

PHP

// Magento autoload-ähnlich
spl_autoload_register(
    function($classname){ // die eigtliche funktion zum auto-laden
        $file = str_replace(' ', '/', ucwords(str_replace('_', ' ', $classname))) . '.php';
        require_once $file;
        if(class_exists($classname)){ // das file konnte geladen werden, aber es könnte ja eine andere klasse "drin stecken"
        	return true;
        }
    }, 
    true, // throw exception wenn nicht möglich klasse zu laden
    false // prepend (vorn anhängen) diese autoload funktion (es kann mehrere geben)
);

Alles anzeigen

Was passiert da:
Jede Klasse hat im Name den Pfad (keine Namespaces -- die sind undynamisch und braucht kein Sack).
Unterstriche werden in Slashes umgewandelt, woraus sich der Pfad ergibt.

PHP

class Das_Hier_Ist_Also_Meine_Class {}
// ergibt also den Pfad: 
// Das/Hier/Ist/Also/Meine/Class.php

Wenn Du nun also einen Ordner für alle includes hast, dann kannst Du:

PHP

define('PATH_INC', 'my/path/to/inc/');




spl_autoload_register(
    function($classname){ 
        $file = str_replace(' ', '/', ucwords(str_replace('_', ' ', $classname))) . '.php';
        require_once PATH_INC . $file;
        if(class_exists($classname)){
        	return true;
        }
    }, 
    true,
    false 
);

Alles anzeigen

Das gibt lange Klassennamen, was aber auch gleich wieder von Vorteil ist:

PHP

// macht keinen Sinn, dient nur der "show"
$obj = new Mage_Adminhtml_CustomerController();
// es wird sicherlich 
// eine Datei CustomerController.php in 
// {inc path} Mage/Adminhtml/
// liegen.

Ich wette Du kannst Dir jetzt zusammenreimen, wo die Klasse Mage_Admin_Model_Resource_User_Collection liegt =)

ZappelPhillip · 19. November 2015

Ich danke Dir erneut sehr herzlich.
Jetzt hab ich es auch verstanden. Dann ergibt das doch alles Sinn und ist ziemlich praktisch.

Zwei Fragen zu Klassen/Funktionen/...

Jetzt mitmachen!

Teilen