Alle methods van een class uitlezen en uitvoeren

Door Ariën op 14-04-2018 17:16

2.555 views

Van de week kreeg ik een idee om de template-parser in mijn CMS te voorzien van een speciale functie-class waarbij zodat ik de functies voor mijn site eenvoudig mooi in methods in een class kan onderscheiden. Ik heb al geprobeerd om zoiets te bouwen, maar blijkbaar is PHP niet zo intelligent om dit te begrijpen:

Fatal error: Uncaught Error: Access to undeclared static property: myClass::$method_name in /bla/scriptje.php:29

 
<?php
class myClass {
    // constructor
    public static function __constructor()
    {
        return "Ik ben de constructor";
    }

    // method 1
    public static function myFunction2()
    {
        return "Functie 1";
    }

    // method 2
    public static function myFunction2()
    {
        return "Functie 2";
    }
}



$class_methods = get_class_methods('myClass');

print_r($class_methods);

foreach ($class_methods as $method_name) {
    echo  myClass::$method_name;
}
?>

Zijn er mogelijkheden zodat je de waardes van de methods in een variabele kan plaatsen?

Thomas van den Heuvel

14-04-2018 17:32 gewijzigd op 14-04-2018 18:05

Yes we can! Voor het aanroepen-van-een-dynamische-static-method-naam zou je call_user_func() kunnen gebruiken.

Maar misschien moest je hier nog () achter gooien? Er staat "property", het is geen property, maar een methode.

Ariën

14-04-2018 17:34

Kijk, dat zou mooi zijn! :-)

Ik ga weer even verder klussen!

Thomas van den Heuvel

14-04-2018 17:35 gewijzigd op 14-04-2018 17:39

Mogelijk werkt $method_name[color=#ff0000]()[/color] ook?

Ariën

14-04-2018 17:38

Jep, toch wel :-)

Rob Doemaarwat

14-04-2018 18:38

Als je ook de argumenten wil weten kun je eens kijken naar Reflection: http://php.net/manual/en/class.reflectionparameter.php en het voorbeeld hiero http://php.net/manual/en/class.reflectionfunction.php

Ward van der Put

14-04-2018 19:46

Ik gebruik een variant waarbij argumenten optioneel zijn. Ingekort:


<?php
/**
 * HMVC Route
 */
class Route
{
    /**
     * @var string      $Controller
     * @var null|string $Method
     * @var null|array  $Parameters
     * @var string      $Path
     */
    private $Controller;
    private $Method;
    private $Parameters;
    private $Path;

    /**
     * @param string $path
     * @param string $controller
     * @param string|null $method
     * @param mixed|null $parameters
     * @return self
     */
    public function __construct($path, $controller, $method = null, $parameters = null)
    {
        $this->setPath($path);
        $this->setController($controller);

        if ($method !== null) {
            $this->setMethod($method);
            if ($parameters !== null) {
                $this->setParameters($parameters);
            }
        }
    }

    /**
     * Instantiate a controller and optionally call a method.
     *
     * @param void
     * @return void
     */
    public function dispatch()
    {
        $controller = $this->Controller;
        $thread = new $controller();

        if ($this->Method !== null) {
            $method = $this->Method;
            if ($this->Parameters !== null) {
                $thread->$method($this->Parameters);
            } else {
                $thread->$method();
            }
        }
    }

    /**
     * @param void
     * @return string
     */
    public function getPath()
    {
        return $this->Path;
    }

    /**
     * @param string $controller
     * @return void
     */
    private function setController($controller)
    {
        $this->Controller = $controller;
    }

    /**
     * @param string $method
     * @return void
     */
    private function setMethod($method)
    {
        $this->Method = $method;
    }

    /**
     * @param mixed $parameters
     * @return void
     */
    private function setParameters($parameters)
    {
        $this->Parameters = $parameters;
    }

    /**
     * @param string $path
     * @return void
     */
    private function setPath($path)
    {
        $path = '/' . ltrim($path, '/');
        $path = mb_strtolower($path, 'UTF-8');
        $this->Path = $path;
    }
}
?>

Zonder deze kromme bocht kreeg ik het destijds niet aan de praat, maar misschien werkt het inmiddels beter in een nieuwe versie van PHP:


<?php
        $controller = $this->Controller;
        $thread = new $controller();
?>

Ozzie PHP

15-04-2018 00:58

Aar, even voor de zekerheid ... deze ken je toch?

http://php.net/manual/en/class.reflectionclass.php

Reageren

Inloggen om te reageren