Laravel sous le capot - Un peu de macros

Bonjour ?

À quelle fréquence avez-vous souhaité une méthode qui n'existe pas sur les collections ou les string helpers ? Vous commencez à enchaîner les méthodes, pour ensuite vous heurter à un mur lorsque l’une d’entre elles s’avère manquante. Honnêtement, c'est compréhensible ; les frameworks, vous le savez, sont une solution universelle. Je me suis retrouvé dans cette situation à plusieurs reprises. À chaque fois, avant de plonger dans la façon d'étendre le framework, je vérifie si ce que je veux étendre est macroable ou non. Mais qu’est-ce que cela signifie ? C'est exactement ce que nous allons explorer !

WTF, ce sont des macros ? ?

Disons que nous avons ce JWT :

$jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';

Et nous devons extraire les en-têtes :

str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); // does not exist ?

//  BadMethodCallException  Method Illuminate\Support\Stringable::fromJson does not exist.

Le fromJson() n'existe pas ? Bien sûr, on pourrait simplement faire :

json_decode(str($jwt)->before('.')->fromBase64());

Mais où est le plaisir là-dedans ? En plus, c'est mon article ?

Nous avons donc besoin d'un moyen d'étendre la classe Stringable. Il existe plusieurs façons de procéder, mais Laravel a pensé à l'avance, il savait que les développeurs pourraient vouloir ajouter des méthodes personnalisées, il a donc rendu la classe macroable, ou comme j'aime l'appeler, extensible.

Si vous inspectez la classe IlluminateSupportStringable, vous verrez qu'elle utilise un trait Macroable.

Allons-y et prolongeons le cours. Dans AppServiceProvider, ajoutez ce qui suit :

<?php

namespace App\Providers;

use Illuminate\Support\Stringable;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::macro('fromJson', function (bool $associative = true) {
            return json_decode($this->value, $associative);
        });
    }
}

Maintenant, réexécutons le code :

str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson();

// ["alg" => "HS256", "typ" => "JWT"]

Ça fonctionne parfaitement ? Mais maintenant, vous vous demandez peut-être comment cela a fonctionné ? Et quelle est exactement $this->valeur ? Que se passe-t-il dans Harry Potter ?

Dévoiler la magie ?

Nous savons que la classe Stringable utilise le trait Macroable, qui fournit la méthode macro(). Regardons de plus près ce qu'il fait :

// src/Illuminate/Macroable/Traits/Macroable.php

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

C'est assez simple, cela enregistre simplement le rappel dans un tableau de macros statiques. Maintenant, si nous inspectons le trait plus en détail, nous trouverons la méthode __call, qui est déclenchée à chaque fois qu'une méthode inexistante est appelée. Dans notre cas, il s'agit de fromJson(). Allons-y :

/**
 * 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(sprintf(
            'Method %s::%s does not exist.', static::class, $method
        ));
    }

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

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

    return $macro(...$parameters);
}

Tout d'abord, il vérifie si une macro est enregistrée, ce qui est le cas avec fromJson(), il récupère ensuite le rappel (ou l'objet) du tableau de macros. Passons maintenant au tour de magie, si la macro est une fermeture (comme dans notre cas), elle appelle bindTo(), qui indique essentiellement à la fermeture que $this doit faire référence à tout ce qui est passé comme premier argument. Dans ce cas, il s'agit de l'instance Stringable, qui possède l'attribut $value.

// $this here is the stringable
// $this inside the closure is now referencing the stringable class
$macro->bindTo($this, static::class);

Et c'est pourquoi nous pouvons faire $this->value.

On peut faire mieux : Mixins ?

Il y a encore une chose que je veux vous montrer ! Lorsque nous prolongeons la même classe plusieurs fois, le fournisseur de services peut très rapidement se retrouver dans une situation compliquée. Nous pouvons extraire toutes nos macros personnalisées dans une classe appelée Mixin.

Créons un StringableMixin :

$jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';

Maintenant, dans AppServiceProvider, nous pouvons enregistrer ce mixin :

str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); // does not exist ?

//  BadMethodCallException  Method Illuminate\Support\Stringable::fromJson does not exist.

Et c'est tout ! Maintenant, nous pouvons faire :

json_decode(str($jwt)->before('.')->fromBase64());

Ce qui est fondamentalement le même, juste un peu plus propre.

Si vous êtes curieux de savoir comment cela fonctionne, la méthode mixin() sur le trait Macroable utilise l'API de réflexion. Il récupère toutes les méthodes publiques de la classe Mixin, s'attend à ce que chacune renvoie une fermeture, puis enregistre la fermeture en tant que macro, comme nous l'avons vu précédemment.

Le pauvre IDE ?

Eh bien, comme vous l'avez vu, il y a beaucoup de magie à l'œuvre et l'IDE ne connaîtrait pas les macros définies. Si vous travaillez au sein d'une équipe, les autres développeurs ne connaîtront pas non plus ces macros, ce qui n'est pas une bonne chose. Heureusement, il existe des outils pour vous aider. Une option gratuite et open source est le package d'assistance Laravel IDE.

Vous pouvez installer le package et générer le fichier _ide_helper.php, et vous devriez être prêt à partir.

Et ainsi ça se termine..

Notre exemple est assez simple, mais vous pouvez pousser les macros bien plus loin que cela, car la plupart des classes courantes fournies par Laravel sont macroables. Par exemple, vous pouvez ajouter une nouvelle macro apiResponse(), ou tout ce qui vous semble très courant dans la logique de votre application et qui est répété plus qu'il ne devrait l'être. Mais n'en faites pas trop. Les macros ajoutent une nouvelle couche de complexité et lorsque vous travaillez en équipe, elles peuvent prêter à confusion.

Alors, chaque fois que vous sentez qu'il manque quelque chose dans votre application, mais pas dans le framework lui-même, utilisez des macros ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!