Vorrei creare funzioni di supporto per evitare di ripetere il codice tra le visualizzazioni in Laravel 5:

view.blade.php

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

Sono sostanzialmente funzioni di formattazione del testo. Dove e come posso creare un file con queste funzioni?

Crea un helpers.phpfile nella cartella dell'app e caricalo con il compositore:

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

Dopo averlo aggiunto al tuo composer.jsonfile, esegui il seguente comando:

composer dump-autoload

Se non ti piace conservare il tuo helpers.phpfile nella tua appdirectory (perché non è un file di classe con spazio dei nomi PSR-4), puoi fare ciò che fa il laravel.comsito Web: memorizzalo helpers.php nella directory bootstrap . Ricorda di impostarlo nel tuo composer.jsonfile:

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

Classi personalizzate in Laravel 5, il modo più semplice

Questa risposta è applicabile alle classi personalizzate generali all'interno di Laravel. Per una risposta più specifica per Blade, vedi Direttive Blade personalizzate in Laravel 5 .

Passaggio 1: crea il tuo file Helpers (o altra classe personalizzata) e assegnagli uno spazio dei nomi corrispondente. Scrivi la tua classe e metodo:

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

namespace App\Helpers;

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

Passaggio 2: creare un alias:

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

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

Passaggio 3: eseguire composer dump-autoloadnella radice del progetto

Passaggio 4: utilizzalo nel modello Blade:

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

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

Credito extra: usa questa classe ovunque nell'app 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!!');
    }
    ...

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

Perché funziona: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

Da dove proviene il caricamento automatico: http://php.net/manual/en/language.oop5.autoload.php

il mio pensiero iniziale era anche il caricamento automatico del compositore, ma non mi sembrava molto Laravel 5ish. L5 fa un uso intensivo dei provider di servizi, sono ciò che avvia la tua applicazione.

Per iniziare ho creato una cartella nella mia appdirectory chiamata Helpers. Quindi all'interno della Helperscartella ho aggiunto i file per le funzioni che volevo aggiungere. Avere una cartella con più file ci consente di evitare un file di grandi dimensioni che diventa troppo lungo e ingestibile.

Successivamente ho creato un HelperServiceProvider.phpeseguendo il comando artigianale:

artisan make:provider HelperServiceProvider

Nel registermetodo ho aggiunto questo frammento

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

infine registra il fornitore di servizi nel tuo config/app.phparray di fornitori

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

ora qualsiasi file nella tua Helpersdirectory è caricato e pronto per l'uso.

AGGIORNAMENTO 2016-02-22

Ci sono molte buone opzioni qui, ma se la mia risposta funziona per te, sono andato avanti e ho creato un pacchetto per includere gli aiutanti in questo modo. Puoi usare il pacchetto come ispirazione o sentirti libero di scaricarlo anche con Composer. Ha alcuni helper integrati che uso spesso (ma che sono tutti inattivi di default) e ti consente di creare i tuoi helper personalizzati con un semplice generatore Artisan. Risolve anche il suggerimento di un risponditore di utilizzare un mapper e consente di definire esplicitamente gli helper personalizzati da caricare o, per impostazione predefinita, caricare automaticamente tutti i file PHP nella directory dell'helper. Feedback e PR sono molto apprezzati!

composer require browner12/helpers

Github: browner12 / helpers

Questo è ciò che viene suggerito da JeffreyWayquesta discussione sui Laracasts .

1. Nella tua app/Httpdirectory, crea un helpers.phpfile e aggiungi le tue funzioni.
2. All'interno composer.json, nel autoloadblocco, aggiungi "files": ["app/Http/helpers.php"].
3. Corri composer dump-autoload.

Dopo aver setacciato una varietà di risposte su SO e Google, non riuscivo ancora a trovare un approccio ottimale. La maggior parte delle risposte suggerisce che lasciamo l'applicazione e facciamo affidamento sullo strumento di terze parti Composer per fare il lavoro, ma non sono convinto che l'accoppiamento a uno strumento solo per includere un file sia saggio.

La risposta di Andrew Brown è arrivata il più vicino a come penso che dovrebbe essere affrontata, ma (almeno in 5.1), il passaggio del fornitore di servizi non è necessario. La risposta di Heisian evidenzia l'uso di ciò PSR-4che ci avvicina di un passo. Ecco la mia implementazione finale per gli helper nelle viste:

Innanzitutto, crea un file di supporto ovunque nella directory delle app, con uno spazio dei nomi:

namespace App\Helpers;

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

Successivamente, alias la tua classe config\app.php, aliasesnell'array:

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

E questo dovrebbe essere tutto ciò che devi fare. PSR-4e l'alias dovrebbe esporre l'helper alle tue viste, quindi a tuo avviso, se digiti:

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

Dovrebbe produrre:

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

Direttive sulle lame personalizzate in Laravel 5

Sì, c'è un altro modo per farlo!

Passaggio 1: registra una direttiva Blade personalizzata:

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

Passaggio 2: utilizzare la direttiva Blade personalizzata:

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

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

Uscite:

QUESTA È LA MIA DIRETTIVA LAMA PERSONALIZZATA !!
Link personalizzato

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

Letture aggiuntive: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives

Se vuoi imparare come creare classi personalizzate che puoi usare ovunque , vedi Classi personalizzate in Laravel 5, il modo più semplice

Questo è il mio file 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;
            }
        }
    }
}

Dovresti creare una cartella chiamata Helperssotto la appcartella, quindi creare il file chiamato whatever.phpinside e aggiungere la stringa whateverall'interno dell'array $ helpers.

Fatto!

modificare

Non sto più usando questa opzione, attualmente sto utilizzando Composer per caricare file statici come helper.

Puoi aggiungere gli helper direttamente su:

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

Per le librerie helper personalizzate nel mio progetto Laravel, ho creato una cartella con nome Librariesnella mia Laravel/Appdirectory e all'interno della directory Libraries, ho creato vari file per diverse librerie helper.

Dopo aver creato i miei file di supporto, includo semplicemente tutti questi file nel mio file composer.json in questo modo

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

ed eseguire

composer dump-autoload

Dato che l'OP ha chiesto le migliori pratiche , penso che qui manchino ancora dei buoni consigli.

Un singolo file helpers.php è tutt'altro che una buona pratica. Innanzitutto perché mescoli molti tipi diversi di funzioni, quindi sei contrario ai buoni principi di codifica. Inoltre, ciò potrebbe danneggiare non solo la documentazione del codice, ma anche le metriche del codice come Complessità ciclomatica , Indice di manutenibilità e Volume di Halstead . Più funzioni hai, più peggiora.

Documentazione del codice sarebbe Ok utilizzando strumenti come phpDocumentor , ma usando Sami che non renderà i file procedurali . La documentazione dell'API di Laravel è un caso del genere: non esiste alcuna documentazione sulle funzioni di supporto: https://laravel.com/api/5.4

Le metriche del codice possono essere analizzate con strumenti come PhpMetrics . L'uso di PhpMetrics versione 1.x per analizzare il codice del framework Laravel 5.4 ti fornirà metriche CC / MI / HV pessime per i file src / Illuminate / Foundation / helpers.php e src / Illuminate / Support / helpers.php .

I file di supporto contestuali multipli (ad es. String_helpers.php , array_helpers.php , ecc.) Migliorerebbero sicuramente quelle metriche errate con un codice più semplice da mantenere. A seconda del generatore di documentazione del codice utilizzato, questo sarebbe abbastanza buono.

Può essere ulteriormente migliorato utilizzando le classi di supporto con metodi statici in modo che possano essere contestualizzati utilizzando gli spazi dei nomi. Proprio come Laravel fa già con Illuminate\Support\Stre Illuminate\Support\Arrclassi. Ciò migliora sia le metriche / l'organizzazione del codice sia la documentazione. Gli alias di classe potrebbero essere utilizzati per facilitarne l'utilizzo.

Strutturare con le classi rende l'organizzazione del codice e la documentazione migliori, ma d'altra parte finiamo per perdere quelle grandi funzioni globali brevi e facili da ricordare. Possiamo migliorare ulteriormente tale approccio creando alias di funzioni per quei metodi di classi statiche. Questo può essere fatto manualmente o dinamicamente.

Laravel utilizza internamente il primo approccio dichiarando le funzioni nei file di supporto procedurali associati ai metodi delle classi statiche. Questo potrebbe non essere l'ideale in quanto è necessario dichiarare nuovamente tutto (documenti / argomenti).
Personalmente utilizzo un approccio dinamico con una HelperServiceProviderclasse che crea tali funzioni nel tempo di esecuzione:

<?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()
    {
        //
    }
}

Si può dire che è finita l'ingegneria, ma io non la penso così. Funziona abbastanza bene e contrariamente a quanto ci si potrebbe aspettare, non costa tempo di esecuzione rilevante almeno quando si utilizza PHP 7.x.

Ecco uno script di shell bash che ho creato per rendere molto rapidamente le facciate di Laravel 5.

Esegui questo nella directory di installazione di Laravel 5.

Chiamalo così:

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

Esempio:

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

Se esegui questo esempio, creerà le directory Facadese Providersin "directory_installazione_dir_utente / app / MyApp".

Creerà i seguenti 3 file e li emetterà anche sullo schermo:

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

Al termine, verrà visualizzato un messaggio simile al seguente:

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

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

Quindi aggiorna l'elenco dei provider e degli alias in 'config / app.php'

Correre composer -o dumpautoload

"./App/MyApp/Facades/Helper.php" apparirà inizialmente così:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Ora aggiungi i tuoi metodi in "./app/MyApp/Facades/Helper.php".

Ecco come appare "./app/MyApp/Facades/Helper.php" dopo aver aggiunto una funzione Helper.

<?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) !!}

Questa funzione prevede uno schema e può accettare un secondo argomento booleano facoltativo.

Se l'URL corrente corrisponde al modello passato ad esso, verrà generato 'active' (o 'class = "active"' se si aggiunge 'true' come secondo argomento alla chiamata della funzione).

Lo uso per evidenziare il menu attivo.

Di seguito è riportato il codice sorgente per il mio script. Spero che lo trovi utile e per favore fatemi sapere se avete problemi con esso.

#!/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 ""

invece di includere la tua classe di supporto personalizzata, puoi effettivamente aggiungere il tuo config/app.phpfile con gli alias.

dovrebbe essere così.

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

e poi al tuo controller, includi l'helper usando il metodo "usa l'helper" in modo da poter semplicemente chiamare parte del metodo sulla tua classe helper.

eg. Helper::some_function();

o nella vista risorse puoi già chiamare direttamente la classe Helper.

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

Ma questo è ancora l'approccio dello stile di programmazione degli sviluppatori da seguire. Potremmo avere un modo diverso di risolvere i problemi e voglio solo condividere quello che ho anche per i principianti.

Crea directory degli helper personalizzati: prima crea la directory degli helper nella directory delle app. Crea la definizione della classe hlper: creiamo ora una semplice funzione di supporto che concatenerà due stringhe. Crea un nuovo file MyFuncs.php in /app/Helpers/MyFuncs.php Aggiungi il seguente codice

<?php

namespace App\Helpers;

class MyFuncs {

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

app namespace \ Helpers; definisce lo spazio dei nomi degli helper nello spazio dei nomi dell'app. class MyFuncs {…} definisce la classe helper MyFuncs. funzione statica pubblica full_name ($ first_name, $ last_name) {…} definisce una funzione statica che accetta due parametri di stringa e restituisce una stringa concatenata

Il servizio di assistenza fornisce lezioni

I fornitori di servizi vengono utilizzati per caricare automaticamente le classi. Dovremo definire un fornitore di servizi che caricherà tutte le nostre classi di supporto nella directory / app / Helpers.

Esegui il seguente comando artigianale:

php artisan make: provider HelperServiceProvider

Il file verrà creato in /app/Providers/HelperServiceProvider.php

Open /app/Providers/HelperServiceProvider.php

Aggiungi il seguente codice:

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

QUI,

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.

Ora dobbiamo registrare HelperServiceProvider e creare un alias per i nostri aiutanti.

Apri il /config/app.phpfile

Individua la variabile dell'array del provider

Aggiungi la seguente riga

App\Providers\HelperServiceProvider::class,

Individua la variabile di matrice degli alias

Aggiungi la seguente riga

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

Salva le modifiche utilizzando il nostro aiuto personalizzato

Creeremo un percorso che chiamerà la nostra funzione di supporto personalizzata Apri /app/routes.php

Aggiungi la seguente definizione di percorso

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

QUI,

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

Per prima cosa crea helpers.php nella directory App \ Http. Quindi aggiungere il seguente codice all'interno di composer.json

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

Quindi eseguire il comando seguente

composer dump-autoload

Ora puoi definire la tua funzione personalizzata all'interno del file helpers.php.

Un altro modo che ho usato è stato: 1) creato un file in app \ FolderName \ fileName.php e con questo codice al suo interno cioè

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

2) Dopo quello nella nostra lama

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

questo è tutto. e funziona

La migliore pratica per scrivere helper personalizzati è

1) All'interno della appdirectory della radice del progetto, creare una cartella denominata Helpers (solo per separare e strutturare il codice).

2) All'interno della cartella scrivere file psr-4 o normali file php

Se i file PHP sono nel formato di psr-4, verranno caricati automaticamente, altrimenti aggiungere la seguente riga in composer.json che si trova all'interno della directory root del progetto

All'interno della autoloadchiave, crea una nuova chiave denominata filesper caricare i file al momento del caricamento automatico, all'interno filesdell'oggetto aggiungi il percorso a partire dalla directory dell'app., Ecco un esempio.

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

PS: prova a eseguire composer dump-autoloadse il file non è stato caricato.

Crea Helpers.php in app / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Aggiungi il compositore e l'aggiornamento del compositore

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

utilizzare nel controller

usa App \ Helper \ Helpers

utilizzare per visualizzare le modifiche nel file config-> app.php

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

chiama in vista

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

in dir bootstrap \ autoload.php

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

aggiungi questo file

app\Helpers\function.php

**

• Assistente di stato

** crea un nuovo aiutante

<?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;
    }
}

Utilizzare per il controller e qualsiasi file di visualizzazione

use App\Helpers\StatusHelper;

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

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

In laravel 5.3 e versioni successive, il team di laravel ha spostato tutti i file procedurali ( routes.php) fuori dalla app/directory e l'intera app/cartella viene psr-4caricata automaticamente. La risposta accettata funzionerà in questo caso, ma non mi sembra giusto.

Quindi quello che ho fatto è stato creare una helpers/directory alla radice del mio progetto e inserire al suo interno i file di supporto, e nel mio composer.jsonfile ho fatto questo:

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

In questo modo la mia app/directory è ancora caricata automaticamente su psr-4 e gli helper sono organizzati un po 'meglio.

Spero che questo aiuti qualcuno.

Ci sono alcune ottime risposte qui, ma penso che questa sia la più semplice. In Laravel 5.4 (e anche nelle versioni precedenti) è possibile creare una classe in qualche posto conveniente per te, ad esempio App / Librerie / Helper.php

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

Quindi puoi semplicemente chiamarlo nel tuo modello Blade in questo modo:

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

Se non vuoi usare @inject, rendi la funzione 'uppercasePara' come statica e incorpora la chiamata nel tuo modello Blade in questo modo:

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

Non c'è bisogno di alias. Laravel risolve automaticamente la classe concreta.