How to use Macroable macros in Laravel

This article mainly introduces the usage of Macroable macros in Laravel. It has certain reference value. Now I share it with you. Friends in need can refer to

Baidu Encyclopedia’s definition:
Macro in computer science is a term for batch processing. Generally speaking, a macro is a rule or pattern, or syntax substitution, that is used to explain how a specific input (usually a string) is converted into a corresponding output (usually a string) according to predefined rules. This replacement occurs at precompilation time and is called macro expansion.

• I first came into contact with macros when I was taking a basic computer course in college and the teacher talked about office. At that time, the teacher didn't pay much attention when he introduced the macro operation. He only remembered that this operation was very powerful and it could make daily work easier.

• Today we talk about macro operations in Laravel

---

First of all, the complete source code

<?php

namespace Illuminate\Support\Traits;

use Closure;
use ReflectionClass;
use ReflectionMethod;
use BadMethodCallException;

trait Macroable
{
    /**
     * The registered string macros.
     *
     * @var array
     */
    protected static $macros = [];

    /**
     * Register a custom macro.
     *
     * @param  string $name
     * @param  object|callable  $macro
     *
     * @return void
     */
    public static function macro($name, $macro)
    {
        static::$macros[$name] = $macro;
    }

    /**
     * Mix another object into the class.
     *
     * @param  object  $mixin
     * @return void
     */
    public static function mixin($mixin)
    {
        $methods = (new ReflectionClass($mixin))->getMethods(
            ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED
        );

        foreach ($methods as $method) {
            $method->setAccessible(true);

            static::macro($method->name, $method->invoke($mixin));
        }
    }

    /**
     * Checks if macro is registered.
     *
     * @param  string  $name
     * @return bool
     */
    public static function hasMacro($name)
    {
        return isset(static::$macros[$name]);
    }

    /**
     * Dynamically handle calls to the class.
     *
     * @param  string  $method
     * @param  array   $parameters
     * @return mixed
     *
     * @throws \BadMethodCallException
     */
    public static function __callStatic($method, $parameters)
    {
        if (! static::hasMacro($method)) {
            throw new BadMethodCallException("Method {$method} does not exist.");
        }

        if (static::$macros[$method] instanceof Closure) {
            return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
        }

        return call_user_func_array(static::$macros[$method], $parameters);
    }

    /**
     * Dynamically handle calls to the class.
     *
     * @param  string  $method
     * @param  array   $parameters
     * @return mixed
     *
     * @throws \BadMethodCallException
     */
    public function __call($method, $parameters)
    {
        if (! static::hasMacro($method)) {
            throw new BadMethodCallException("Method {$method} does not exist.");
        }

        $macro = static::$macros[$method];

        if ($macro instanceof Closure) {
            return call_user_func_array($macro->bindTo($this, static::class), $parameters);
        }

        return call_user_func_array($macro, $parameters);
    }
}

• Macroable::macroMethod

public static function macro($name, $macro)
{
    static::$macros[$name] = $macro;
}

Very simple code, according to the comments of the parameters, $macroYou can pass a closure or object. The reason why you can pass an object is thanks to the magic method in PHP

class Father
{
    // 通过增加魔术方法**__invoke**我们就可以把对象当做闭包来使用了。
    public function __invoke()
    {
        echo __CLASS__;
    }
}

class Child
{
    use \Illuminate\Support\Traits\Macroable;
}

// 增加了宏指令之后，我们就能调用 Child 对象中不存在的方法了
Child::macro('show', new Father);
// 输出:Father
(new Child)->show();

• ##Macroable::mixinMethod

This method is to inject the return result of an object's method into the original object

public static function mixin($mixin)
{
    // 通过反射获取该对象中所有公开和受保护的方法
    $methods = (new ReflectionClass($mixin))->getMethods(
        ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED
    );

    foreach ($methods as $method) {
        // 设置方法可访问，因为受保护的不能在外部调用
        $method->setAccessible(true);
        
        // 调用 macro 方法批量创建宏指令
        static::macro($method->name, $method->invoke($mixin));
    }
}

// 实际使用
class Father
{
    public function say()
    {
        return function () {
            echo 'say';
        };
    }

    public function show()
    {
        return function () {
            echo 'show';
        };
    }

    protected function eat()
    {
        return function () {
            echo 'eat';
        };
    }
}

class Child
{
    use \Illuminate\Support\Traits\Macroable;
}

// 批量绑定宏指令
Child::mixin(new Father);

$child = new Child;
// 输出:say
$child->say();
// 输出:show
$child->show();
// 输出:eat
$child->eat();

As can be seen from the above code

mixinYou can bind a class method to a macro class. It should be noted that the method must return a closure type.

• Macroable::hasMacroMethod

public static function hasMacro($name)
{
    return isset(static::$macros[$name]);
}

This method is relatively simple and nothing complicated. It just determines whether it exists. Macros. It's usually a good idea to check before using macros.

• Macroable::__call and Macroable::__callStaticmethod

It is precisely because of this Only through two methods can we perform macro operations. Except for the different execution methods, the codes of the two methods are similar. Let’s talk about

__call

public function __call($method, $parameters)
{
    // 如果不存在这个宏指令，直接抛出异常
    if (! static::hasMacro($method)) {
        throw new BadMethodCallException("Method {$method} does not exist.");
    }

    // 得到存储的宏指令
    $macro = static::$macros[$method];

    // 闭包做一点点特殊的处理
    if ($macro instanceof Closure) {
        return call_user_func_array($macro->bindTo($this, static::class), $parameters);
    }

    // 不是闭包，比如对象的时候，直接通过这种方法运行，但是要确保对象有`__invoke`方法
    return call_user_func_array($macro, $parameters);
}


class Child
{
    use \Illuminate\Support\Traits\Macroable;

    protected $name = 'father';
}

// 闭包的特殊处理，需要做的就是绑定 $this, 如
Child::macro('show', function () {
    echo $this->name;
});

// 输出:father
(new Child)->show();

In the above operation, when we bind the macro, we can call

Child## through $this in the closure. # attribute is because we use the Closure::bindTo method in the __call method. The official website explains

Closure::bindTo

: Copy the current closure object and bind the specified $this object and class scope. Adding macros to classes in Laravel

Many classes in Laravel

use macrostrait

For example, Illuminate\Filesystem\Filesystem::class
, we want to add a method to this class, but The code inside will not be touched.

We only need to add macro instructions to the
1. App\Providers\AppServiceProvider::register

   method (you can also create a new service provider specifically for processing)

   
   

   # 1. Then add a test route to test our newly added method

2. Then open the browser and run it, and you will find that our code can run normally and output the results

The above is the entire content of this article. I hope it will be helpful to everyone's study. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

Analysis of Laravel’s Eloquent ORM

Analysis of Laravel’s basic Migrations

The above is the detailed content of How to use Macroable macros in Laravel. For more information, please follow other related articles on the PHP Chinese website!