php - 在每个函数之前调用函数

Question

是否可以创建一个在调用每个函数时自动调用的函数？我希望结果是这样的:

before_functions()
function_1()
before_functions()
function_2()
before_functions()
function_3()

但我想要一个具有以下功能的文件:

function before_functions(){} -> call before each function

还有另一个我调用函数的文件:

function_1()
function_2()
function_3()

但我不会在每个函数中调用before_functions..

Answer 1

有不同的方法可以解决您的问题。其中一些已经在评论中提到了。让我们采用最简单的方法来解决您的问题。

魔法方法__call()

正如 lovelace 在评论中所说，对于您在 another stack overflow article 中所述的问题，已经有一个简单的解决方案。 .它使用 PHP 自己的魔术方法 __call()。让我们看一个简单的例子。

class Foo
{
    protected function before() : void
    {
        echo "before";
    }

    public function after() : void
    {
        echo "after";
    }

    public function __call($method, $arguments)
    {
        if (method_exists($this, $method)) {
            $this->before();
            return call_user_func_array(array($this, $method), $arguments);
        }
    }
}

// Testing
$class = new Foo();
$class->after(); // echoes "before->after"

如您所见，魔术方法 __call 为您的目的提供了适当的处理。首先它检查被调用的方法是否存在，然后在执行被调用的方法之前执行 before 方法。 before 方法会在您调用存在的类方法时自动调用。

回调方法

正如评论中还提到的，回调函数可能是一种无需处理类实例的可能解决方案。让我们看一下回调示例。

$callback = function()
{
    echo "before->";
}

function foo(callable $callback, $bla)
{
    $callback();
    echo $bla;
}

// example code
foo($callback, 'go and make some coffee');
// output: "before->go and make some coffee"

这种方法比使用 __call 方法更简单，因为您只需要一个可调用函数作为函数的参数。容易，嗯？

观察者模式

观察者模式是php5中标准php库自带的，比较复杂。我想对于您的用例来说太复杂了。为了保持完整，这里有一个简短的示例，说明观察者模式如何成为您问题的可用解决方案。

class Group implements SplSubject
{
    /**
     * persons in this group
     * @var \SplObjectStorage
     */
    protected $persons;

    /**
     * observer active in this group
     * @var \SplObjectStorage
     */
    protected $observers;

    /**
     * the person, which actually speaks
     * @var Person
     */
    protected $speaker;

    /**
     * Initializes our class members and sets an observer for this group
     */
    public function __construct() 
    {
        $this->persons = new \SplObjectStorage();
        $this->observers = new \SplObjectStorage();

        $onSpeakObserver = new OnSpeakObserver($who, $what);
        $this->attach($onSpeakObserver);
    }

    public function add(Person $person) {
         $this->persons->attach($person);
    }

    public function speak(Person $who, $what) {
        echo $who . " says: " . $what . "<br>";

        $this->speaker = $who;  
        $this->notify();
    } 
    
    public function getSpeaker() {
        return $this->speaker;
    }

    public function getGroup() {
        return $this->persons;
    }

    public function attach(\SplObserver $observer) {
        $this->observers->attach($observer);
    }

    public function detach(\SplObserver $observer) {
        $this->observers->attach($observer);
    }

    public function notify() {
        foreach ($this->observers as $observer) {
             $observer->update($this);
        }
    }
}

这是我们的基础类group，应该遵守。应观察的类总是称为“主题”。一个主题接受一个或多个观察者，这些观察者由主题的 notify 方法调用。一个小组由几个人和一个演讲者组成。总是有一个说话者，其他人是听众，当说话者说些什么时，他们可以使用react。对于听众的 react ，我们需要一个观察者。如果说话者说了什么，这个观察者就会倾听。观察者直接在组的构造函数中添加。

这个类实现了\SplSubject接口(interface)，为我们带来了方法attach、detach和notify处理观察者，我们附加到组中。接下来我们需要一个人和观察者本身的类。

class Person 
{
    protected $name = '';

    public function __construct(string $name) : void
    {
        $this->name = $name;
    }

    public function __toString() : string
    {
        return $this->name;
    }
}

一个有名字的简单人。

class OnSpeakObserver implements \SplObserver 
{
    public function update(\SplSubject $subject) 
    {
        foreach ($subject->getGroup() as $person) {
            if ($person !== $subject->getSpeaker()) {
                echo $person . " says: me!<br>";
            }
        }
    }
}

这是我们的观察者，它实现了原生的 \SplObserver 接口(interface)，这迫使我们使用更新方法。每次当群组中有人发言时，都会调用此方法。

有了这些类，我们就有了一个简单的观察者模式。在这个简单的示例中，观察者会在群体中的某个人每次说某事时强制使用react。

// open a group (the subject, which is observed)
$friends = new Group();

// add some persons to our group
$sarah = new Person('Sarah');
$friends->add($sarah);    

$nicole = new Person('Nicole');
$friends->add($nicole);

$marcel = new Person('Marcel');
$friends->add($marcel);

$steffen = new Person('Steffen');
$friends->add($steffen);

// Marcel says ...
$friends->speak($marcel, 'Who likes the observer pattern?');

// result:
// Marcel says: Who likes the observer pattern?
// Sarah says: me!
// Nicole says: me!
// Steffen says: me!

你可以转移这个小例子来解决你的问题。观察者可以监听您的函数的执行情况，并且每次调用您的一个函数时，观察者都可以先执行另一个函数。如本例所示，在一群人说了些什么之后，观察者只是执行。你的问题也一样。这完全取决于何时调用主题的通知方法。

如果您有任何问题，请随时提出。