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?

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"
]

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

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

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.

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>

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

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",
        ...
    ]
},
...

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

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.

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 ""

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.

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

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.

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

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é.

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();  ?>

dans dir bootstrap \ autoload.php

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

ajouter ce fichier

app\Helpers\function.php

**

• 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'));
        }
}

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.

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.