Meilleures pratiques pour les assistants personnalisés dans Laravel 5 [fermé]


472

Je voudrais créer des fonctions d'aide pour éviter de répéter du code entre les vues dans Laravel 5:

view.blade.php

<p>Foo Formated text: {{ fooFormatText($text) }}</p>

Ce sont essentiellement des fonctions de formatage de texte. Où et comment puis-je créer un fichier avec ces fonctions?

Réponses:


595

Créez un helpers.phpfichier dans votre dossier d'application et chargez-le avec composer:

"autoload": {
    "classmap": [
        ...
    ],
    "psr-4": {
        "App\\": "app/"
    },
    "files": [
        "app/helpers.php" // <---- ADD THIS
    ]
},

Après avoir ajouté cela à votre composer.jsonfichier, exécutez la commande suivante:

composer dump-autoload

Si vous n'aimez pas conserver votre helpers.phpfichier dans votre apprépertoire (car il ne s'agit pas d'un fichier de classe PSR-4 à espace de noms), vous pouvez faire ce que fait le laravel.comsite Web: stocker le helpers.php dans le répertoire bootstrap . N'oubliez pas de le mettre dans votre composer.jsonfichier:

"files": [
    "bootstrap/helpers.php"
]

86
Astuce pour les noobs: utilisez cette commande après avoir modifié composer.json. compositeur dump-autoload
Allfarid Morales García

11
@ AllfaridMoralesGarcía Ou peut-être simplement "Un conseil utile, car la réponse ne précise pas que vous devez le faire par la suite".
Matt McDonald

8
J'approuve les fonctions d'aide pour faciliter l'écriture des vues, mais je déteste à quel point cette réponse est référencée dans d'autres réponses. Ne vous méprenez pas, c'est une bonne réponse et correcte, je crains juste que les gens en abusent et recommencent à écrire des tonnes de PHP fonctionnel mal écrit et mal organisé.
andrewtweber

40
Je ne comprends pas cette approche. Composer est censé être un outil pour inclure des bibliothèques: Laravel fonctionnerait parfaitement bien sans lui et Composer sans Laravel. Cette suggestion nous dit de créer un fichier dans notre application, de quitter notre application, d'aller à Composer, de dire au compositeur de revenir dans notre application et d'inclure un fichier. Laravel gère clairement l'inclusion de fichiers, non? Pourquoi renoncerions-nous à l'implémentation native de Laravel et utiliserions-nous cet outil externe pour inclure un fichier pour nous, couplant ainsi davantage notre application à Composer? Est-ce de la paresse ou manque-t-il quelque chose?
dKen

6
Laravel utilise le chargeur automatique du compositeur pour savoir où inclure toutes les bibliothèques et les fichiers sur lesquels il s'appuie. Ceci référencé dans bootstrap / autoload.php. Lisez le commentaire dans ce fichier. L'approche consiste à ajouter la référence au fichier dans le fichier composer.json, puis «dump autoload», qui régénère l'autochargeur du compositeur afin que Laravel puisse le trouver. L'utilisation de la collection "files" de Composer est un bon moyen d'ajouter des bibliothèques ou des fichiers de fonctions uniques qui ne sont pas soigneusement emballés dans des packages Composer. C'est agréable d'avoir une place pour toutes les situations «au fait, je dois inclure ce fichier bizarre».
Phillip Harrington

370

Cours personnalisés dans Laravel 5, la voie facile

Cette réponse est applicable aux classes personnalisées générales au sein de Laravel. Pour une réponse plus spécifique à la lame, voir les directives de lame personnalisées dans Laravel 5 .

Étape 1: créez votre fichier Helpers (ou autre classe personnalisée) et donnez-lui un espace de noms correspondant. Écrivez votre classe et votre méthode:

<?php // Code within app\Helpers\Helper.php

namespace App\Helpers;

class Helper
{
    public static function shout(string $string)
    {
        return strtoupper($string);
    }
}

Étape 2: créez un alias:

<?php // Code within config/app.php

    'aliases' => [
     ...
        'Helper' => App\Helpers\Helper::class,
     ...

Étape 3: exécuter composer dump-autoloaddans la racine du projet

Étape 4: utilisez-le dans votre modèle de lame:

<!-- Code within resources/views/template.blade.php -->

{!! Helper::shout('this is how to use autoloading correctly!!') !!}

Crédit supplémentaire: utilisez cette classe n'importe où dans votre application Laravel:

<?php // Code within app/Http/Controllers/SomeController.php

namespace App\Http\Controllers;

use Helper;

class SomeController extends Controller
{

    public function __construct()
    {
        Helper::shout('now i\'m using my helper class in a controller!!');
    }
    ...

Source: http://www.php-fig.org/psr/psr-4/

Pourquoi cela fonctionne: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

Origine du chargement automatique: http://php.net/manual/en/language.oop5.autoload.php


35
Pour être clair, cette réponse ne traite pas réellement des assistants, qui sont des fonctions à espace de nom global. Au lieu de cela, il encourage la conversion des aides en méthodes de classe. C'est généralement la meilleure approche, mais ne répond pas réellement à la question posée ici, c'est pourquoi d'autres réponses sont si complexes en comparaison.
Dan Hunsaker

1
L'assistant de fonction signifie qu'il est également disponible dans Blade. Comment rendre cette fonction disponible dans Blade? Vous ne pouvez pas appeler Helper :: prettyJason (paramètres) dans Blade.
MaXi32

@ MaXi32, vous pouvez ajouter la classe sous le aliasestableau dans app/config.php: 'Helper' => App\Helpers\Helper::class, vous pourrez alors appeler la Helper::prettyJson();lame très bien.
heisian

@DanHunsaker a été édité pour répondre directement à la question, et c'est toujours la même approche simple. Vous pouvez également écrire vos propres directives de lame personnalisées: stackoverflow.com/questions/28290332/…
heisian

1
Ouais, j'ai fouillé le cadre une fois et j'ai trouvé où ils ont attiré les assistants. Et encore une fois, je suis complètement d'accord que les méthodes des classes statiques à espace de noms sont bien plus propres que ce qui est demandé - ou recommandé - la plupart du temps. Le fait est que les assistants ne sont pas vraiment The Laravel Way en premier lieu, mais plutôt un résidu de CodeIgniter 2.x qui n'a toujours pas été supprimé. Donc, mon pédantisme à propos de cette approche qui ne répond pas exactement au PO tel que demandé est plutôt une tentative de souligner le fait que vous n'obtenez pas d'aide, mais plutôt quelque chose de mieux.
Dan Hunsaker

315

ma pensée initiale était aussi le chargement automatique du compositeur, mais cela ne me semblait pas très Laravel 5ish. L5 fait un usage intensif des fournisseurs de services, c'est ce qui amorce votre application.

Pour commencer, j'ai créé un dossier dans mon apprépertoire appelé Helpers. Ensuite, dans le Helpersdossier, j'ai ajouté des fichiers pour les fonctions que je voulais ajouter. Avoir un dossier avec plusieurs fichiers nous permet d'éviter un gros fichier qui devient trop long et ingérable.

Ensuite, j'ai créé un HelperServiceProvider.phpen exécutant la commande artisan:

artisan make:provider HelperServiceProvider

Dans la registerméthode, j'ai ajouté cet extrait

public function register()
{
    foreach (glob(app_path().'/Helpers/*.php') as $filename){
        require_once($filename);
    }
}

enregistrez enfin le fournisseur de services dans votre config/app.phptableau des fournisseurs

'providers' => [
    'App\Providers\HelperServiceProvider',
]

maintenant, n'importe quel fichier de votre Helpersrépertoire est chargé et prêt à l'emploi.

MISE À JOUR 2016-02-22

Il y a beaucoup de bonnes options ici, mais si ma réponse fonctionne pour vous, j'ai continué et j'ai fait un package pour inclure les aides de cette façon. Vous pouvez soit utiliser le package pour vous inspirer, soit le télécharger gratuitement avec Composer. Il a des assistants intégrés que j'utilise souvent (mais qui sont tous inactifs par défaut) et vous permet de créer vos propres assistants personnalisés avec un simple générateur Artisan. Il répond également à la suggestion d'un répondant d'utiliser un mappeur et vous permet de définir explicitement les assistants personnalisés à charger ou, par défaut, de charger automatiquement tous les fichiers PHP dans votre répertoire d'assistance. Les commentaires et les RP sont très appréciés!

composer require browner12/helpers

Github: browner12 / helpers


29
pour les personnes qui n'ont que quelques fonctions à ajouter, le chargement automatique du compositeur est parfaitement correct, mais pour ceux d'entre nous qui peuvent avoir beaucoup de fonctions d'aide, l'organisation de plusieurs fichiers est un must. cette solution est essentiellement ce que j'ai fait en L4 sauf que j'ai enregistré les fichiers dans mon start.phpfichier (ce qui n'était pas génial, mais a servi son objectif pour le moment). avez-vous une autre suggestion pour charger plusieurs fichiers?
Andrew Brown

7
Si vous avez plusieurs fichiers, ajoutez-les tous à votre fichier composer.json. Ajouter même 5-10 lignes là-bas est beaucoup plus logique que ce que vous avez ici.
Joseph Silber

22
Je pense que cette technique a beaucoup de mérite. Il est élégant et efficace car vous n'avez pas à vous rappeler de jouer avec le fichier composer.json chaque fois que vous créez un fichier d'aide.
impeto

8
Vraiment une bonne solution. La seule chose que je ne suis pas d'accord est la façon dont vous ajoutez les fichiers, je pense que devrait être un mappeur à la place, où nous ajoutons le nom du fichier que nous voulons charger. Pensez aux erreurs! s'il n'y a qu'un seul assistant dans l'un des fichiers qui échoue, vous devez tous les supprimer ou faire casser le site jusqu'à ce que vous le résolviez.
Pablo Ezequiel Leone

3
Utilisez-vous l'espace de noms App \ Providers? Comment j'appelle cet assistant depuis le contrôleur et la vue. Désolé, noob question.
Cengkaruk

79

C'est ce que suggère JeffreyWaycette discussion sur les Laracasts .

  1. Dans votre app/Httprépertoire, créez un helpers.phpfichier et ajoutez vos fonctions.
  2. À l'intérieur composer.json, dans le autoloadbloc, ajoutez "files": ["app/Http/helpers.php"].
  3. Courez composer dump-autoload.

15
Les assistants peuvent ne pas être uniquement HTTP. app/helpers.phpou app/Helpers/semble être un meilleur endroit.
sepehr

1
Et si nous sommes sur un serveur partagé et que nous n'avons pas la possibilité d'utiliser composer dump-autoload ?
user3201500

@ user3201500 qui est une autre question et vous devrez peut-être le faire manuellement si vous souhaitez suivre la réponse ci-dessus. Ou vous pouvez choisir parmi d'autres réponses. Et pour refléter manuellement le composer dump-autoloadvous pouvez suivre ceci: developpé.be
2014

55

Après avoir passé au crible une variété de réponses sur SO et Google, je n'ai toujours pas pu trouver une approche optimale. La plupart des réponses suggèrent que nous quittions l'application et que nous nous appuyions sur Composer d'outil tiers pour faire le travail, mais je ne suis pas convaincu que le couplage à un outil juste pour inclure un fichier soit judicieux.

La réponse d'Andrew Brown se rapproche le plus de la façon dont je pense qu'elle devrait être abordée, mais (au moins en 5.1), l'étape du fournisseur de services n'est pas nécessaire. La réponse de Heisian met en évidence l'utilisation PSR-4qui nous rapproche un peu plus. Voici ma dernière implémentation pour les assistants dans les vues:

Tout d'abord, créez un fichier d'aide n'importe où dans le répertoire de vos applications, avec un espace de noms:

namespace App\Helpers;

class BobFinder
{
    static function bob()
    {
        return '<strong>Bob?! Is that you?!</strong>';
    }
}

Ensuite, alias votre classe dans config\app.php, dans le aliasestableau:

'aliases' => [
    // Other aliases
    'BobFinder' => App\Helpers\BobFinder::class
]

Et cela devrait être tout ce que vous devez faire. PSR-4et l'alias doit exposer l'assistant à vos vues, donc dans votre vue, si vous tapez:

{!! BobFinder::bob() !!}

Il devrait produire:

<strong>Bob?! Is that you?!</strong>

merci d'avoir posté ça. comme @ Dan-Hunsaker l'a souligné dans ma solution, nous n'avons toujours pas fini avec une fonction à espacement de nom global, c'est-à-dire être capable d'écrire simplement {!! bob() !!}. va faire un peu plus de recherche et voir si c'est possible
heisian

1
J'y ai réfléchi davantage et tenter de devenir bob()véritablement mondial ne serait pas une chose sage à faire. Les espaces de noms sont là pour une raison et nous ne devrions pas appeler à bob()côté des fonctions PHP de base. Je vais ajouter votre bit d'alias à mon code - merci!
heisian

1
Je trouve que c'est le meilleur de tous
Jimmy Obonyo Abor

Pourquoi y a- extends Helpert- il ? Cela ne me semble pas nécessaire.
bernie

@bernie @ user3201500 Désolé équipe, j'avais ma propre classe d'aide de base dont tous mes assistants héritent; le extends Helpern'est en effet pas nécessaire. Merci pour l'information.
dKen

32

Directives de lame personnalisées dans Laravel 5

Oui, il existe une autre façon de procéder!

Étape 1: enregistrer une directive Blade personnalisée:

<?php // code in app/Providers/AppServiceProvider.php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

use Blade; // <-- This is important! Without it you'll get an exception.

class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
     public function boot()
     {
         // Make a custom blade directive:
         Blade::directive('shout', function ($string) {
             return trim(strtoupper($string), '(\'\')');
         });

         // And another one for good measure:
         Blade::directive('customLink', function () {
             return '<a href="#">Custom Link</a>';
         });
     }
    ...

Étape 2: utilisez votre directive Blade personnalisée:

<!-- // code in resources/views/view.blade.php -->

@shout('this is my custom blade directive!!')
<br />
@customLink

Les sorties:

CECI EST MA DIRECTIVE DE LAME PERSONNALISÉE !!
Lien personnalisé


Source: https://laravel.com/docs/5.1/blade#extending-blade

Lecture supplémentaire: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives


Si vous voulez savoir comment créer au mieux des classes personnalisées que vous pouvez utiliser n'importe où , consultez Classes personnalisées dans Laravel 5, la méthode simple


Cela devrait être marqué comme la meilleure réponse, car la question était "d'éviter de répéter le code entre certaines vues". Le mot clé est VIEWS. :)
Aleksandrs

23

Voici mon fichier HelpersProvider.php:

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class HelperServiceProvider extends ServiceProvider
{
    protected $helpers = [
        // Add your helpers in here
    ];

    /**
     * Bootstrap the application services.
     */
    public function boot()
    {
        //
    }

    /**
     * Register the application services.
     */
    public function register()
    {
        foreach ($this->helpers as $helper) {
            $helper_path = app_path().'/Helpers/'.$helper.'.php';

            if (\File::isFile($helper_path)) {
                require_once $helper_path;
            }
        }
    }
}

Vous devez créer un dossier appelé Helperssous le appdossier, puis créer un fichier appelé à l' whatever.phpintérieur et ajouter la chaîne whateverà l'intérieur du tableau $ helpers.

Terminé!

Éditer

Je n'utilise plus cette option, j'utilise actuellement le compositeur pour charger des fichiers statiques comme des aides.

Vous pouvez ajouter les assistants directement à:

...
"autoload": {
    "files": [
        "app/helpers/my_helper.php",
        ...
    ]
},
...

Existe-t-il d'autres raisons que les performances pour créer un mappeur au lieu de charger tous les fichiers du répertoire avec glob()comme l'a écrit Andrew Brown? Si vous voulez pouvoir spécifier les fichiers que vous souhaitez inclure, pourquoi ne pas spécifier les fichiers dans le composer.jsonpour les charger automatiquement comme Joseph Silber l'a écrit? Pourquoi préférez-vous cette solution? Je ne dis pas que c'est une mauvaise solution, je suis juste curieux.
Pelmered

3
Il est plus facile, avec une approche mappée, d'activer / désactiver sélectivement les assistants si, par exemple, l'un des fichiers d'assistance contient une erreur de rupture. Cela dit, le mappage de fichiers dans un fournisseur de services n'est pas très différent de le faire à l' composer.jsonexception de deux points - tout d'abord, il conserve la carte à l'intérieur de l'application elle-même, plutôt qu'un fichier de métadonnées; deuxièmement, il ne vous oblige pas à réexécuter composer dump-autoloadchaque fois que vous modifiez la liste des fichiers à charger.
Dan Hunsaker

Pas besoin de includeou require, Laravel a déjà un chargement automatique PSR-4 intégré
heisian

1
l'utilisation de PSR-4 et de composer ne vous permettra pas d'activer / désactiver les assistants.
Pablo Ezequiel Leone

@PabloEzequielLeone et comment l'utiliser dans un contrôleur ou un fichier blade? Cela semble être la meilleure option si vous ne souhaitez pas charger tous les assistants pour tous les contrôleurs à chaque fois, mais ce n'est pas bon pour les débutants à Laravel (comme moi).
VinGarcia

12

Pour les bibliothèques d'assistance personnalisées dans mon projet Laravel, j'ai créé un dossier avec un nom Librariesdans mon Laravel/Apprépertoire et dans le répertoire des bibliothèques, j'ai créé divers fichiers pour différentes bibliothèques d'assistance.

Après avoir créé mes fichiers d'aide, j'inclus simplement tous ces fichiers dans mon fichier composer.json comme ceci

...
"autoload": {
        "classmap": [
            "database"
        ],
        "files": [
            "app/Libraries/commonFunctions.php"
        ],
        "psr-4": {
            "App\\": "app/"
        }
    },
...

et exécuter

composer dump-autoload

composer dump-autoloadet composer dumpautoloadfonctionne également en fait fonctionnera composer duégalement ...
Akshay Khale

10

Depuis qu'OP a demandé les meilleures pratiques , je pense qu'il nous manque encore quelques bons conseils ici.

Un seul fichier helpers.php est loin d'être une bonne pratique. Tout d'abord parce que vous mélangez beaucoup de types de fonctions différents, vous êtes donc contre les bons principes de codage. De plus, cela pourrait nuire non seulement à la documentation du code, mais également aux mesures de code comme la complexité cyclomatique , l' indice de maintenabilité et le volume Halstead . Plus vous avez de fonctions, plus cela empire.

La documentation du code serait OK en utilisant des outils comme phpDocumentor , mais en utilisant Sami, il ne rendra pas les fichiers procéduraux . La documentation de l'API Laravel est un tel cas - il n'y a pas de documentation sur les fonctions d'assistance: https://laravel.com/api/5.4

Les métriques de code peuvent être analysées avec des outils comme PhpMetrics . L'utilisation de PhpMetrics version 1.x pour analyser le code du framework Laravel 5.4 vous donnera de très mauvaises métriques CC / MI / HV pour les fichiers src / Illuminate / Foundation / helpers.php et src / Illuminate / Support / helpers.php .

Plusieurs fichiers d'aide contextuelle (par exemple , string_helpers.php , array_helpers.php , etc.) amélioreraient certainement ces mauvaises mesures, ce qui rendrait le code plus facile à maintenir. Selon le générateur de documentation de code utilisé, cela serait suffisant.

Il peut être encore amélioré en utilisant des classes d'assistance avec des méthodes statiques afin qu'elles puissent être contextualisées à l'aide d'espaces de noms. Tout comme la façon dont Laravel déjà fait avec Illuminate\Support\Stret Illuminate\Support\Arrclasses. Cela améliore à la fois les mesures / organisation du code et la documentation. Les alias de classe pourraient être utilisés pour les rendre plus faciles à utiliser.

Structurer avec des classes améliore l'organisation et la documentation du code, mais d'un autre côté, nous finissons par perdre ces fonctions globales courtes et faciles à mémoriser. Nous pouvons encore améliorer cette approche en créant des alias de fonction pour ces méthodes de classes statiques. Cela peut être fait manuellement ou dynamiquement.

Laravel utilise en interne la première approche en déclarant des fonctions dans les fichiers d'assistance procédurale qui sont mappées aux méthodes des classes statiques. Ce n'est peut-être pas l'idéal car vous devez redéclarer tous les éléments (docblocks / arguments).
J'utilise personnellement une approche dynamique avec une HelperServiceProviderclasse qui crée ces fonctions dans le temps d'exécution:

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class HelperServiceProvider extends ServiceProvider
{
    /**
     * The helper mappings for the application.
     *
     * @var array
     */
    protected $helpers = [
        'uppercase' => 'App\Support\Helpers\StringHelper::uppercase',
        'lowercase' => 'App\Support\Helpers\StringHelper::lowercase',
    ];

    /**
     * Bootstrap the application helpers.
     *
     * @return void
     */
    public function boot()
    {
        foreach ($this->helpers as $alias => $method) {
            if (!function_exists($alias)) {
                eval("function {$alias}(...\$args) { return {$method}(...\$args); }");
            }
        }
    }

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}

On peut dire que c'est de l'ingénierie mais je ne pense pas. Cela fonctionne plutôt bien et contrairement à ce que l'on pourrait attendre, il ne coûte pas de temps d'exécution pertinent au moins lors de l'utilisation de PHP 7.x.


8

Voici un script shell bash que j'ai créé pour créer des façades Laravel 5 très rapidement.

Exécutez-le dans votre répertoire d'installation de Laravel 5.

Appelez ça comme ceci:

make_facade.sh -f <facade_name> -n '<namespace_prefix>'

Exemple:

make_facade.sh -f helper -n 'App\MyApp'

Si vous exécutez cet exemple, il créera les répertoires Facadeset Providerssous «your_laravel_installation_dir / app / MyApp».

Il créera les 3 fichiers suivants et les affichera également à l'écran:

./app/MyApp/Facades/Helper.php
./app/MyApp/Facades/HelperFacade.php
./app/MyApp/Providers/HelperServiceProvider.php

Une fois cela fait, il affichera un message similaire au suivant:

===========================
    Finished
===========================

Add these lines to config/app.php:
----------------------------------
Providers: App\MyApp\Providers\HelperServiceProvider,
Alias: 'Helper' => 'App\MyApp\Facades\HelperFacade',

Mettez donc à jour la liste des fournisseurs et alias dans 'config / app.php'

Courir composer -o dumpautoload

Le "./app/MyApp/Facades/Helper.php" ressemblera à l'origine à ceci:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Maintenant, ajoutez simplement vos méthodes dans "./app/MyApp/Facades/Helper.php".

Voici à quoi ressemble "./app/MyApp/Facades/Helper.php" après avoir ajouté une fonction d'assistance.

<?php

namespace App\MyApp\Facades;

use Request;

class Helper
{
    public function isActive($pattern = null, $include_class = false)
    {
        return ((Request::is($pattern)) ? (($include_class) ? 'class="active"' : 'active' ) : '');
    }
}

This is how it would be called:
===============================

{!!  Helper::isActive('help', true) !!}

Cette fonction attend un modèle et peut accepter un deuxième argument booléen facultatif.

Si l'URL actuelle correspond au modèle qui lui a été transmis, elle affichera 'active' (ou 'class = "active"' si vous ajoutez 'true' comme deuxième argument à l'appel de fonction).

Je l'utilise pour mettre en évidence le menu qui est actif.

Voici le code source de mon script. J'espère que vous le trouverez utile et faites-le moi savoir si vous avez des problèmes avec celui-ci.

#!/bin/bash

display_syntax(){
    echo ""
    echo "  The Syntax is like this:"
    echo "  ========================"
    echo "      "$(basename $0)" -f <facade_name> -n '<namespace_prefix>'"
    echo ""
    echo "  Example:"
    echo "  ========"
    echo "      "$(basename $0) -f test -n "'App\MyAppDirectory'"
    echo ""
}


if [ $# -ne 4 ]
then
    echo ""
    display_syntax
    exit
else
# Use > 0 to consume one or more arguments per pass in the loop (e.g.
# some arguments don't have a corresponding value to go with it such
# as in the --default example).
    while [[ $# > 0 ]]
    do
        key="$1"
            case $key in
            -n|--namespace_prefix)
            namespace_prefix_in="$2"
            echo ""
            shift # past argument
            ;;
            -f|--facade)
            facade_name_in="$2"
            shift # past argument
            ;;
            *)
                    # unknown option
            ;;
        esac
        shift # past argument or value
    done
fi
echo Facade Name = ${facade_name_in}
echo Namespace Prefix = $(echo ${namespace_prefix_in} | sed -e 's#\\#\\\\#')
echo ""
}


function display_start_banner(){

    echo '**********************************************************'
    echo '*          STARTING LARAVEL MAKE FACADE SCRIPT'
    echo '**********************************************************'
}

#  Init the Vars that I can in the beginning
function init_and_export_vars(){
    echo
    echo "INIT and EXPORT VARS"
    echo "===================="
    #   Substitution Tokens:
    #
    #   Tokens:
    #   {namespace_prefix}
    #   {namespace_prefix_lowerfirstchar}
    #   {facade_name_upcase}
    #   {facade_name_lowercase}
    #


    namespace_prefix=$(echo ${namespace_prefix_in} | sed -e 's#\\#\\\\#')
    namespace_prefix_lowerfirstchar=$(echo ${namespace_prefix_in} | sed -e 's#\\#/#g' -e 's/^\(.\)/\l\1/g')
    facade_name_upcase=$(echo ${facade_name_in} | sed -e 's/\b\(.\)/\u\1/')
    facade_name_lowercase=$(echo ${facade_name_in} | awk '{print tolower($0)}')


#   Filename: {facade_name_upcase}.php  -  SOURCE TEMPLATE
source_template='<?php

namespace {namespace_prefix}\Facades;

class {facade_name_upcase}
{
    //
}
'


#  Filename: {facade_name_upcase}ServiceProvider.php    -   SERVICE PROVIDER TEMPLATE
serviceProvider_template='<?php

namespace {namespace_prefix}\Providers;

use Illuminate\Support\ServiceProvider;
use App;


class {facade_name_upcase}ServiceProvider extends ServiceProvider {

    public function boot()
    {
        //
    }

    public function register()
    {
        App::bind("{facade_name_lowercase}", function()
        {
            return new \{namespace_prefix}\Facades\{facade_name_upcase};
        });
    }

}
'

#  {facade_name_upcase}Facade.php   -   FACADE TEMPLATE
facade_template='<?php

namespace {namespace_prefix}\Facades;

use Illuminate\Support\Facades\Facade;

class {facade_name_upcase}Facade extends Facade {

    protected static function getFacadeAccessor() { return "{facade_name_lowercase}"; }
}
'
}


function checkDirectoryExists(){
    if [ ! -d ${namespace_prefix_lowerfirstchar} ]
    then
        echo ""
        echo "Can't find the namespace: "${namespace_prefix_in}
        echo ""
        echo "*** NOTE:"
        echo "           Make sure the namspace directory exists and"
        echo "           you use quotes around the namespace_prefix."
        echo ""
        display_syntax
        exit
    fi
}

function makeDirectories(){
    echo "Make Directories"
    echo "================"
    mkdir -p ${namespace_prefix_lowerfirstchar}/Facades
    mkdir -p ${namespace_prefix_lowerfirstchar}/Providers
    mkdir -p ${namespace_prefix_lowerfirstchar}/Facades
}

function createSourceTemplate(){
    source_template=$(echo "${source_template}" | sed -e 's/{namespace_prefix}/'${namespace_prefix}'/g' -e 's/{facade_name_upcase}/'${facade_name_upcase}'/g' -e 's/{facade_name_lowercase}/'${facade_name_lowercase}'/g')
    echo "Create Source Template:"
    echo "======================="
    echo "${source_template}"
    echo ""
    echo "${source_template}" > ./${namespace_prefix_lowerfirstchar}/Facades/${facade_name_upcase}.php
}

function createServiceProviderTemplate(){
    serviceProvider_template=$(echo "${serviceProvider_template}" | sed -e 's/{namespace_prefix}/'${namespace_prefix}'/g' -e 's/{facade_name_upcase}/'${facade_name_upcase}'/g' -e 's/{facade_name_lowercase}/'${facade_name_lowercase}'/g')
    echo "Create ServiceProvider Template:"
    echo "================================"
    echo "${serviceProvider_template}"
    echo ""
    echo "${serviceProvider_template}" > ./${namespace_prefix_lowerfirstchar}/Providers/${facade_name_upcase}ServiceProvider.php
}

function createFacadeTemplate(){
    facade_template=$(echo "${facade_template}" | sed -e 's/{namespace_prefix}/'${namespace_prefix}'/g' -e 's/{facade_name_upcase}/'${facade_name_upcase}'/g' -e 's/{facade_name_lowercase}/'${facade_name_lowercase}'/g')
    echo "Create Facade Template:"
    echo "======================="
    echo "${facade_template}"
    echo ""
    echo "${facade_template}" > ./${namespace_prefix_lowerfirstchar}/Facades/${facade_name_upcase}Facade.php
}


function serviceProviderPrompt(){
    echo "Providers: ${namespace_prefix_in}\Providers\\${facade_name_upcase}ServiceProvider,"
}

function aliasPrompt(){
    echo "Alias: '"${facade_name_upcase}"' => '"${namespace_prefix_in}"\Facades\\${facade_name_upcase}Facade'," 
}

#
#   END FUNCTION DECLARATIONS
#


###########################
## START RUNNING SCRIPT  ##
###########################

display_start_banner

init_and_export_vars
makeDirectories 
checkDirectoryExists
echo ""

createSourceTemplate
createServiceProviderTemplate
createFacadeTemplate
echo ""
echo "==========================="
echo "  Finished TEST"
echo "==========================="
echo ""
echo "Add these lines to config/app.php:"
echo "----------------------------------"
serviceProviderPrompt
aliasPrompt
echo ""

8

au lieu d'inclure votre classe d'assistance personnalisée, vous pouvez réellement ajouter à votre config/app.phpfichier sous des alias.

devrait ressembler à ceci.

 'aliases' => [ 
    ...
    ...
    'Helper' => App\Http\Services\Helper::class,
 ]

puis à votre contrôleur, incluez l'assistant en utilisant la méthode 'use Helper' afin que vous puissiez simplement appeler une partie de la méthode sur votre classe d'assistance.

eg. Helper::some_function();

ou dans la vue des ressources, vous pouvez déjà appeler directement la classe Helper.

eg. {{Helper::foo()}}

Mais c'est toujours l'approche de style de codage du développeur à suivre. Nous pouvons avoir différentes manières de résoudre les problèmes, et je veux juste partager ce que j'ai aussi pour les débutants.


4

Créer un répertoire d'aide personnalisé: créez d'abord un répertoire d'aide dans le répertoire de l'application. Créer une définition de classe hlper: Créons maintenant une fonction d'assistance simple qui concaténera deux chaînes. Créez un nouveau fichier MyFuncs.php dans /app/Helpers/MyFuncs.php Ajoutez le code suivant

<?php

namespace App\Helpers;

class MyFuncs {

    public static function full_name($first_name,$last_name) {
        return $first_name . ', '. $last_name;   
    }
}

espace de noms App \ Helpers; définit l'espace de noms Helpers sous l'espace de noms App. La classe MyFuncs {…} définit la classe d'assistance MyFuncs. fonction statique publique full_name ($ first_name, $ last_name) {…} définit une fonction statique qui accepte deux paramètres de chaîne et renvoie une chaîne concaténée

Le service des aides fournit la classe

Les fournisseurs de services sont habitués à charger automatiquement les classes. Nous devrons définir un fournisseur de services qui chargera toutes nos classes d'assistance dans le répertoire / app / Helpers.

Exécutez la commande artisan suivante:

php artisan make: fournisseur HelperServiceProvider

Le fichier sera créé dans /app/Providers/HelperServiceProvider.php

Open /app/Providers/HelperServiceProvider.php

Ajoutez le code suivant:

<?php 

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class HelperServiceProvider extends ServiceProvider {

   /**
    * Bootstrap the application services.
    *
    * @return void
    */
   public function boot()
   {
      //
   }

   /**
    * Register the application services.
    *
    * @return void
    */
   public function register()
   {
        foreach (glob(app_path().'/Helpers/*.php') as $filename){
            require_once($filename);
        }
   }
}

ICI,

namespace App\Providers; defines the namespace provider
use Illuminate\Support\ServiceProvider; imports the ServiceProvider class namespace
class HelperServiceProvider extends ServiceProvider {…} defines a class HelperServiceProvider that extends the ServiceProvider class
public function boot(){…} bootstraps the application service
public function register(){…} is the function that loads the helpers
foreach (glob(app_path().'/Helpers/*.php') as $filename){…} loops through all the files in /app/Helpers directory and loads them.

Nous devons maintenant enregistrer HelperServiceProvider et créer un alias pour nos assistants.

Ouvrir un /config/app.phpfichier

Localisez la variable du tableau des fournisseurs

Ajoutez la ligne suivante

App\Providers\HelperServiceProvider::class,

Localisez la variable de tableau d'alias

Ajoutez la ligne suivante

'MyFuncs' => App\Helpers\MyFuncs::class,

Enregistrez les modifications à l'aide de notre aide personnalisée

Nous allons créer un itinéraire qui appellera notre fonction d'assistance personnalisée Open /app/routes.php

Ajoutez la définition d'itinéraire suivante

Route::get('/func', function () {
    return MyFuncs::full_name("John","Doe");
});

ICI,

return MyFuncs::full_name("John","Doe"); calls the static function full_name in MyFuncs class

4

Créez d'abord helpers.php dans le répertoire App \ Http. Ajoutez ensuite le code suivant dans le composer.json

"autoload": {
        "classmap": [
            "database"
        ],
        "files": [
            "app/Http/helpers.php"
        ],
        "psr-4": {
            "App\\": "app/"
        }
    },

Exécutez ensuite la commande suivante

composer dump-autoload

Vous pouvez maintenant définir votre fonction personnalisée dans le fichier helpers.php.


3

Une autre façon que j'ai utilisée était: 1) créé un fichier dans app \ FolderName \ fileName.php et avait ce code à l'intérieur c'est-à-dire

<?php
namespace App\library
{
 class hrapplication{
  public static function libData(){
   return "Data";
  }
 }
}
?>

2) Après cela dans notre lame

 $FmyFunctions = new \App\FolderName\classsName;
  echo $is_ok = ($FmyFunctions->libData());

c'est ça. et il fonctionne


3

La meilleure pratique pour écrire des assistants personnalisés est

1) Dans le apprépertoire de la racine du projet, créez un dossier nommé Helpers (juste pour séparer et structurer le code).

2) Dans le dossier, écrivez des fichiers psr-4 ou des fichiers php normaux

Si les fichiers PHP sont au format psr-4, il sera automatiquement chargé, sinon ajoutez la ligne suivante dans le fichier composer.json qui se trouve dans le répertoire racine du projet

À l'intérieur de la autoloadclé, créez une nouvelle clé nommée filespour charger les fichiers au moment du chargement automatique, à l'intérieur de l' filesobjet ajoutez le chemin à partir du répertoire de l'application., Voici un exemple.

"autoload": {
    "classmap": [
        "database"
    ],
    "psr-4": {
        "App\\": "app/"
    },
    "files": [
        "app/Helpers/customHelpers.php"
    ]
},
"autoload-dev": {
    "classmap": [
        "tests/TestCase.php"
    ]
},

PS: essayez de lancer composer dump-autoloadsi le fichier n'est pas chargé.


3

Créez Helpers.php dans app / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Ajouter le compositeur et la mise à jour du compositeur

 "autoload": {
        "classmap": [
            "database/seeds",
            "database/factories",
            "database","app/Helper/Helpers.php"
        ],
        "psr-4": {
            "App\\": "app/"
        },
         "files": ["app/Helper/Helpers.php"]
    },

utiliser dans le contrôleur

utilisez App \ Helper \ Helpers

utiliser dans le changement de vue dans le fichier config-> app.php

   'aliases' => [
    ...
    'Helpers'   => 'App\Helper\Helpers'
    ],

appeler en vue

<?php echo Helpers::function_name();  ?>

Merci, pourriez-vous développer un peu votre explication?
Felipe Valdes

2
Si la classe est à espace de noms, l'ajout du fichier composer.jsonest inutile, car le chargement automatique de psr-4 fera le travail.
Arcesilas

2

dans dir bootstrap \ autoload.php

require __DIR__.'/../vendor/autoload.php';
require __DIR__.'/../app/Helpers/function.php'; //add

ajouter ce fichier

app\Helpers\function.php

2

**

  • Aide au statut

** créer un nouvel assistant

<?php

namespace App\Helpers;

use Illuminate\Database\Eloquent\Collection;

class StatusHelper
{
 protected static $_status = [
        1=> [
            'value' => 1,
            'displayName' => 'Active',
        ],
        2 => [
            'value' => 2,
            'displayName' => 'Inactive',
        ],
        3 => [
            'value' => 3,
            'displayName' => 'Delete',
        ],

    ];

     public static function getStatusesList()
    {
        $status = (new Collection(self::$_status))->pluck('displayName', 'value')->toArray();


        return $status;
    }
}

Utiliser pour le contrôleur et tout fichier d'affichage

use App\Helpers\StatusHelper;

class ExampleController extends Controller
{
        public function index()
        {
            $statusList = StatusHelper::getStatusesList();

            return view('example.index', compact('statusList'));
        }
}

0

Dans laravel 5.3 et supérieur, l'équipe laravel a déplacé tous les fichiers procéduraux ( routes.php) hors du app/répertoire, et le app/dossier entier est psr-4chargé automatiquement. La réponse acceptée fonctionnera dans ce cas, mais elle ne me semble pas juste.

Donc ce que j'ai fait, c'est que j'ai créé un helpers/répertoire à la racine de mon projet et que j'ai mis les fichiers d'aide à l'intérieur, et dans mon composer.jsonfichier, j'ai fait ceci:

...
"autoload": {
    "classmap": [
        "database"
    ],
    "psr-4": {
        "App\\": "app/"
    },
    "files": [
        "helpers/ui_helpers.php"
    ]
},
...

De cette façon, mon app/répertoire est toujours un psr-4 chargé automatiquement, et les assistants sont un peu mieux organisés.

J'espère que cela aide quelqu'un.


0

Il y a quelques bonnes réponses ici mais je pense que c'est la plus simple. Dans Laravel 5.4 (et probablement dans les versions antérieures), vous pouvez créer une classe dans un endroit qui vous convient, par exemple App / Libraries / Helper.php

class Helper() {
    public function uppercasePara($str) {
        return '<p>' .strtoupper($str). '<p>;
    }
}

Ensuite, vous pouvez simplement l'appeler dans votre modèle de lame comme ceci:

@inject('helper', \App\Libraries\Helper)
{{ $helper->drawTimeSelector() }}

Si vous ne voulez pas utiliser @inject, il vous suffit de rendre la fonction 'uppercasePara' statique et d'incorporer l'appel dans votre modèle de lame comme ceci:

{{ \App\Libraries\Helper::drawTimeSelector() }}

Pas besoin d'alias. Laravel résout automatiquement la classe concrète.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.