L'utilisation des opérations de cha?ne de cha?nes peut améliorer la lisibilité au code, la maintenabilité et l'expérience de développement; 2. Une interface lisse est obtenue en construisant une méthode de cha?ne qui renvoie les instances; 3. La classe cha?née de Laravel a fourni des fonctions de traitement de cha?ne de cha?ne puissantes et largement utilisées. Il est recommandé d'utiliser ce type de modèle dans les projets réels pour améliorer l'expression du code et réduire la nidification des fonctions redondantes, ce qui rend finalement le traitement des cha?nes plus intuitif et plus efficace.

Lorsque vous travaillez avec des cordes en PHP, les développeurs se retrouvent souvent à écrire des appels de fonction répétitifs ou imbriqués, ce qui peut nuire à la lisibilité et à la maintenabilité. Une interface fluide - communément connue sous le nom de manipulation de cha?nes cha?nées - offre un moyen plus propre et plus expressif d'effectuer plusieurs opérations sur une cha?ne dans un seul flux lisible.

Au lieu de ceci:

 $ result = trim (strtolower (str_replace ('', '-', $ text)));

Vous pouvez écrire:

 $ result = str :: of ($ text) -> TRIM () -> inférieur () -> remplacer (',' - ') -> get ();

Cette approche améliore non seulement la clarté du code, mais améliore également l'expérience des développeurs en permettant l'achèvement automatique et le cha?nage de méthodes. Explorons comment implémenter et utiliser une interface de manipulation de cha?ne fluide dans PHP.

? Pourquoi utiliser une interface fluide pour les cha?nes?

Une interface fluide imite le langage naturel et permettra le cha?nage de la méthode en renvoyant l'instance ( $this ) de chaque méthode (sauf les terminaux). Les avantages comprennent:

• LIBIBILITé : Les opérations se lisent comme des phrases.
• Maintenabilité : étapes faciles à ajouter, supprimer ou réorganiser.
• Déstabilité : IDE Auto-Completion suggère des méthodes disponibles.
• Imutabilité : la plupart des implémentations renvoient de nouvelles instances, en évitant les effets secondaires.

Les projets PHP 8 (et Laravel's Illuminate\Support\Stringable ) utilisent déjà ce modèle efficacement.

? ? Construire une classe de cha?ne cha?ne simple

Voici une implémentation minimale pour démontrer le concept:

 Classe Str
{
    String privé $ valeur;

    Fonction publique __construct (String $ Value)
    {
        $ this-> value = $ valeur;
    }

    fonction statique publique de (String $ valeur): soi
    {
        retourner new self ($ valeur);
    }

    Trim de fonction publique (String $ charlist = "\ t \ n \ r \ 0 \ x0b"): self
    {
        $ this-> value = TRIM ($ this-> value, $ charlist);
        retourner $ ceci;
    }

    fonction publique inférieur (): soi
    {
        $ this-> value = strtolower ($ this-> value);
        retourner $ ceci;
    }

    fonction publique supérieure (): soi
    {
        $ this-> value = strtoupper ($ this-> value);
        retourner $ ceci;
    }

    Fonction publique Remplace (String $ Search, String $ remplace): Self
    {
        $ this-> value = str_replace ($ search, $ remplace, $ this-> value);
        retourner $ ceci;
    }

    Fonction publique Ajouter (String $ suffixe): Self
    {
        $ this-> valeur. = $ suffixe;
        retourner $ ceci;
    }

    Fonction publique Prend (String $ Prefix): Self
    {
        $ this-> value = $ prefix. $ this-> valeur;
        retourner $ ceci;
    }

    fonction publique get (): cha?ne
    {
        retourner $ this-> valeur;
    }

    fonction publique __toString (): cha?ne
    {
        retourner $ this-> valeur;
    }
}

Vous pouvez maintenant cha?ner les opérations:

 Echo Str :: of ("Hello World")
    -> TRIM ()
    -> inférieur ()
    -> remplacer ('world', 'php')
    -> Ajouter ('!')
    -> get ();
// Sortie: "Bonjour php!"

? Cas d'utilisation du monde réel

La manipulation de la cha?ne fluide brille dans des scénarios comme:

• Génération de limaces URL

   $ slug = str :: of ($ title) -> trim () -> inférieur () -> remplacer (',' - ') -> get ();

• Désinfecter la saisie des utilisateurs

   $ Clean = str :: of ($ entrée) -> TRIM () -> striptags () -> inférieur () -> get ();

• Construire des noms de fichiers dynamiques

   $ filename = str :: of ($ name)
      -> TRIM ()
      -> remplacer (['' ',' / '],' - ')
      -> Ajouter ('-'. Date ('ymd'))
      -> inférieur ()
      -> get ();

Ces modèles sont courants dans des cadres comme Laravel, où Stringable est largement utilisée dans le routage, la gestion des fichiers et les attributs du modèle.

?? Meilleures pratiques et pièges

Bien que les interfaces courantes soient puissantes, gardez ces points à l'esprit:

• évitez de muter involontairement des données d'origine - envisagez de rendre l'objet immuable en renvoyant de nouvelles instances au lieu de return $this .
• Utilisez les méthodes de terminal judicieusement - des méthodes comme get() , length() , ou contains() doivent renvoyer les valeurs, pas l'instance.
• Ne pas sur-ingénieurs - pour les cas simples, les fonctions PHP simples sont bien.
• Considérez les performances - une création d'objets excessive peut avoir d'importance en boucles (bien que généralement négligeables).

Exemple d'une version immuable:

 fonction publique inférieur (): soi
{
    return new self (strtolower ($ this-> value));
}

Cela empêche l'état partagé mais augmente légèrement l'utilisation de la mémoire.

? Bonus: Laravel's Stringable

Si vous utilisez Laravel ou illuminate/support , vous avez déjà accès à une API de cha?ne fluide robuste:

 Utiliser illuminate \ support \ Stringable;

$ s = Stringable :: of ('Laravel est génial')
    -> TRIM ()
    -> title ()
    -> Ajouter ('!');

Echo $ S; // "Laravel est génial!"

Il comprend des méthodes avancées comme slug() , after() , camel() , words() , etc.

Vous pouvez l'installer autonome:

 Le compositeur nécessite un éclairage / support

Fondamentalement, la manipulation de la cha?ne cha?née en PHP apporte l'élégance et la clarté au traitement des cha?nes. Que vous construisiez votre propre aide ou que vous tiriez parti des outils de Laravel, le modèle fluide rend le code plus intuitif et plus agréable à écrire.

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!