Chciałbym utworzyć funkcje pomocnicze, aby uniknąć powtarzania kodu między widokami w Laravel 5:

view.blade.php

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

Są to w zasadzie funkcje formatowania tekstu. Gdzie i jak mogę utworzyć plik z tymi funkcjami?

Utwórz helpers.phpplik w folderze aplikacji i załaduj go za pomocą kompozytora:

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

Po dodaniu tego do composer.jsonpliku uruchom następujące polecenie:

composer dump-autoload

Jeśli nie lubisz przechowywać swojego helpers.phppliku w appkatalogu (ponieważ nie jest to plik klasy z przestrzenią nazw PSR-4), możesz zrobić to, co laravel.comrobi strona internetowa: zapisać go helpers.php w katalogu bootstrap . Pamiętaj, aby ustawić go w swoim composer.jsonpliku:

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

Klasy niestandardowe w Laravel 5, prosty sposób

Ta odpowiedź dotyczy ogólnych klas niestandardowych w Laravel. Aby uzyskać odpowiedź bardziej specyficzną dla ostrzy, zobacz Niestandardowe dyrektywy dotyczące ostrzy w Laravel 5 .

Krok 1: Utwórz plik Helpers (lub inną klasę niestandardową) i nadaj mu pasującą przestrzeń nazw. Napisz swoją klasę i metodę:

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

namespace App\Helpers;

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

Krok 2: Utwórz alias:

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

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

Krok 3: Uruchom composer dump-autoloadw katalogu głównym projektu

Krok 4: Użyj go w szablonie Blade:

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

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

Dodatkowy kredyt: użyj tej klasy w dowolnym miejscu w aplikacji 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!!');
    }
    ...

Źródło: http://www.php-fig.org/psr/psr-4/

Dlaczego to działa: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

Skąd pochodzi automatyczne ładowanie: http://php.net/manual/en/language.oop5.autoload.php

moją pierwszą myślą było również automatyczne ładowanie kompozytora, ale nie wydawało mi się to bardzo Laravel 5ish. L5 intensywnie korzysta z usług dostawców, są one tym, co uruchamia twoją aplikację.

Na początek stworzyłem folder w moim appkatalogu o nazwie Helpers. Następnie w Helpersfolderze dodałem pliki funkcji, które chciałem dodać. Posiadanie folderu z wieloma plikami pozwala nam uniknąć jednego dużego pliku, który staje się zbyt długi i niemożliwy do zarządzania.

Następnie utworzyłem a HelperServiceProvider.php, uruchamiając polecenie rzemieślnika:

artisan make:provider HelperServiceProvider

W ramach registermetody dodałem ten fragment kodu

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

na koniec zarejestruj dostawcę usług w swojej config/app.phptablicy dostawców

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

teraz dowolny plik w Helperskatalogu jest ładowany i gotowy do użycia.

AKTUALIZACJA 22.02.2016

Jest tu wiele dobrych opcji, ale jeśli moja odpowiedź będzie dla ciebie odpowiednia, poszedłem naprzód i przygotowałem pakiet obejmujący pomocników w ten sposób. Możesz użyć tego pakietu jako inspiracji lub pobrać go również w programie Composer. Ma wbudowane pomocniki, z których często korzystam (ale domyślnie wszystkie są nieaktywne) i pozwala tworzyć własne niestandardowe pomocniki za pomocą prostego generatora rzemieślnika. Odpowiada także na sugestię jednego z respondentów dotyczącą korzystania z programu mapującego i pozwala jawnie zdefiniować niestandardowe pomocniki do załadowania lub domyślnie automatycznie załadować wszystkie pliki PHP w katalogu pomocnika. Opinie i PR są mile widziane!

composer require browner12/helpers

Github: browner12 / helpers

To, co jest sugerowane przez JeffreyWaytą Laracasts dyskusja .

1. W swoim app/Httpkatalogu utwórz helpers.phpplik i dodaj swoje funkcje.
2. Wewnątrz composer.jsonw autoloadbloku dodaj "files": ["app/Http/helpers.php"].
3. Uruchom composer dump-autoload.

Po przejrzeniu różnych odpowiedzi w SO i Google nadal nie mogłem znaleźć optymalnego podejścia. Większość odpowiedzi sugeruje, że zostawiamy aplikację i polegamy na zewnętrznym narzędziu Composer, aby wykonać zadanie, ale nie jestem przekonany, czy połączenie z narzędziem, aby tylko dołączyć plik, jest mądre.

Odpowiedź Andrew Browna była najbliższa temu, jak myślę, że należy do niej podejść, ale (przynajmniej w 5.1) krok dostawcy usług jest zbędny. Odpowiedź Heisiana podkreśla, którego użycie PSR-4przybliża nas o krok. Oto moje końcowe wdrożenie dla pomocników w widokach:

Najpierw utwórz plik pomocnika w dowolnym miejscu w katalogu aplikacji z przestrzenią nazw:

namespace App\Helpers;

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

Następnie alias swojej klasie config\app.php, w aliasestablicy:

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

I to powinno być wszystko, co musisz zrobić. PSR-4i alias powinien wystawiać pomocnika na twoje widoki, więc w twoim widoku, jeśli wpiszesz:

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

Powinien generować:

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

Niestandardowe dyrektywy dotyczące ostrzy w Laravel 5

Tak, jest na to inny sposób!

Krok 1: Zarejestruj niestandardową dyrektywę Blade:

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

Krok 2: Użyj niestandardowej dyrektywy Blade:

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

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

Wyjścia:

TO JEST MOJA NIESTANDARDOWA DYREKTYWA OSTRZA !!
Link niestandardowy

Źródło: https://laravel.com/docs/5.1/blade#extending-blade

Dodatkowa lektura: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives

Jeśli chcesz dowiedzieć się, jak najlepiej tworzyć niestandardowe klasy, których możesz używać w dowolnym miejscu , zobacz Niestandardowe klasy w Laravel 5, Prosty sposób

To jest mój plik 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;
            }
        }
    }
}

Powinieneś utworzyć folder o nazwie Helperspod appfolderem, a następnie utworzyć plik o nazwie whatever.phpinside i dodać ciąg znaków whateverwewnątrz tablicy $ helpers.

Gotowy!

Edytować

Nie używam już tej opcji, obecnie używam kompozytora do ładowania plików statycznych, takich jak pomocniki.

Możesz dodać pomocników bezpośrednio na:

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

Dla niestandardowych bibliotek pomocniczych w moim projekcie Laravel utworzyłem folder o nazwie Librariesw moim Laravel/Appkatalogu i w katalogu bibliotek, utworzyłem różne pliki dla różnych bibliotek pomocniczych.

Po utworzeniu plików pomocniczych po prostu dołączam wszystkie te pliki do mojego pliku composer.json w ten sposób

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

i wykonać

composer dump-autoload

Ponieważ OP poprosił o najlepsze praktyki , myślę, że wciąż brakuje nam tutaj dobrych rad.

Pojedynczy plik helpers.php nie jest dobrą praktyką. Po pierwsze dlatego, że łączysz wiele różnych rodzajów funkcji, więc jesteś przeciwny dobrym zasadom kodowania. Co więcej, może to zaszkodzić nie tylko dokumentacji kodu, ale także metryk kodu, takich jak złożoność cykliczna , wskaźnik konserwacji i objętość Halsteada . Im więcej masz funkcji, tym bardziej się pogarsza.

Dokumentacja kodu byłoby ok za pomocą narzędzi takich jak phpDocumentor , ale przy użyciu Sami go nie odda plików proceduralnych . Tak wygląda dokumentacja interfejsu Laravel API - nie ma dokumentacji funkcji pomocniczych: https://laravel.com/api/5.4

Metryki kodu można analizować za pomocą narzędzi takich jak PhpMetrics . Użycie PhpMetrics w wersji 1.x do analizy kodu frameworku Laravel 5.4 da bardzo złe dane CC / MI / HV zarówno dla plików src / Illuminate / Foundation / helpers.php, jak i src / Illuminate / Support / helpers.php .

Wiele kontekstowych plików pomocniczych (np. String_helpers.php , array_helpers.php itp.) Z pewnością poprawiłoby te złe parametry, co ułatwiłoby utrzymanie kodu. W zależności od zastosowanego generatora dokumentacji kodu byłoby to wystarczająco dobre.

Można go jeszcze ulepszyć, stosując klasy pomocnicze przy użyciu metod statycznych, aby można je było kontekstualizować przy użyciu przestrzeni nazw. Tak jak już Laravel robi z Illuminate\Support\StriIlluminate\Support\Arr klas. Poprawia to zarówno wskaźniki / organizację kodu, jak i dokumentację. Aliasy klas mogą być użyte, aby były łatwiejsze w użyciu.

Strukturyzacja za pomocą klas poprawia organizację kodu i dokumentację, ale z drugiej strony tracimy te świetne krótkie i łatwe do zapamiętania funkcje globalne. Możemy dalej ulepszyć to podejście, tworząc aliasy funkcji do metod klas statycznych. Można to zrobić ręcznie lub dynamicznie.

Laravel wewnętrznie stosuje pierwsze podejście, deklarując funkcje w proceduralnych plikach pomocniczych, które są odwzorowane na metody klas statycznych. To może nie być idealna rzecz, ponieważ musisz ponownie sformułować wszystkie rzeczy (docblocks / arguments).
Osobiście używam dynamicznego podejścia z HelperServiceProviderklasą, która tworzy te funkcje w czasie wykonywania:

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

Można powiedzieć, że to już koniec inżynierii, ale nie sądzę. Działa całkiem dobrze i wbrew oczekiwaniom nie kosztuje odpowiedniego czasu wykonania przynajmniej przy użyciu PHP 7.x.

Oto skrypt powłoki bash, który stworzyłem, aby bardzo szybko wykonać fasady Laravel 5.

Uruchom to w swoim katalogu instalacyjnym Laravel 5.

Nazwij to tak:

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

Przykład:

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

Jeśli uruchomisz ten przykład, utworzy on katalogi FacadesiProviders pod „your_laravel_installation_dir / app / MojaApl”.

Stworzy następujące 3 pliki i wyświetli je również na ekranie:

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

Po zakończeniu wyświetli komunikat podobny do następującego:

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

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

Zaktualizuj więc listę dostawców i aliasów w „config / app.php”

Biegać composer -o dumpautoload

„./App/MyApp/Facades/Helper.php” będzie początkowo wyglądać następująco:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Teraz po prostu dodaj swoje metody w „./app/MyApp/Facades/Helper.php”.

Oto jak wygląda „./app/MyApp/Facades/Helper.php” po dodaniu funkcji Pomocnika.

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

Ta funkcja oczekuje wzorca i może zaakceptować opcjonalny drugi argument boolowski.

Jeśli bieżący adres URL pasuje do przekazanego mu wzorca, wyświetli „aktywny” (lub „class =„ active ””, jeśli dodasz „true” jako drugi argument do wywołania funkcji).

Używam go, aby podświetlić aktywne menu.

Poniżej znajduje się kod źródłowy mojego skryptu. Mam nadzieję, że uznasz to za przydatne i daj mi znać, jeśli masz z tym jakieś problemy.

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

zamiast dołączać niestandardową klasę pomocnika, możesz dodać do config/app.phppliku aliasy.

powinno wyglądać tak.

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

a następnie do kontrolera dołącz pomocnika za pomocą metody „użyj pomocnika”, abyś mógł po prostu wywołać niektóre metody z klasy pomocnika.

eg. Helper::some_function();

lub w widoku zasobów możesz już bezpośrednio wywołać klasę Pomocnika.

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

Ale nadal jest to podejście programistyczne, które należy stosować. Możemy mieć inny sposób rozwiązywania problemów i chcę po prostu podzielić się tym, co mam dla początkujących.

Utwórz niestandardowy katalog pomocników: Najpierw utwórz katalog Pomocników w katalogu aplikacji. Utwórz definicję klasy hlper: Utwórzmy teraz prostą funkcję pomocniczą, która połączy dwa łańcuchy. Utwórz nowy plik MyFuncs.php w /app/Helpers/MyFuncs.php Dodaj następujący kod

<?php

namespace App\Helpers;

class MyFuncs {

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

przestrzeń nazw App \ Helpers; definiuje przestrzeń nazw Pomocników w obszarze Przestrzeń nazw aplikacji. klasa MyFuncs {…} definiuje klasę pomocniczą MyFuncs. publiczna funkcja statyczna pełna_nazwa ($ imię, $ ostatnia nazwa) {…} definiuje funkcję statyczną, która akceptuje dwa parametry ciągu i zwraca ciąg skonkatenowany

Usługa pomocników zapewnia zajęcia

Usługodawcy są przyzwyczajeni do automatycznego ładowania klas. Będziemy musieli zdefiniować dostawcę usług, który załaduje wszystkie nasze klasy pomocnicze do katalogu / app / Helpers.

Uruchom następujące polecenie rzemieślnika:

php artisan make: dostawca HelperServiceProvider

Plik zostanie utworzony w /app/Providers/HelperServiceProvider.php

Open /app/Providers/HelperServiceProvider.php

Dodaj następujący kod:

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

TUTAJ,

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.

Teraz musimy zarejestrować HelperServiceProvider i utworzyć alias dla naszych pomocników.

Otwórz /config/app.phpplik

Znajdź zmienną tablicową dostawcy

Dodaj następujący wiersz

App\Providers\HelperServiceProvider::class,

Znajdź zmienną tablicową aliasów

Dodaj następujący wiersz

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

Zapisz zmiany za pomocą naszego niestandardowego pomocnika

Stworzymy trasę, która wywoła naszą niestandardową funkcję pomocniczą Open /app/routes.php

Dodaj następującą definicję trasy

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

TUTAJ,

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

Najpierw utwórz helpers.php w katalogu App \ Http. Następnie dodaj następujący kod do pliku composer.json

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

Następnie uruchom następujące polecenie

composer dump-autoload

Teraz możesz zdefiniować swoją niestandardową funkcję w pliku helpers.php.

Innym sposobem, którego użyłem było: 1) utworzenie pliku w aplikacji \ FolderName \ fileName.php i umieszczenie w nim tego kodu, tj.

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

2) Następnie w naszym ostrzu

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

Otóż ​​to. i to działa

Najlepszą praktyką jest pisanie niestandardowych pomocników

1) W appkatalogu głównym projektu utwórz folder o nazwie Pomocnicy (aby oddzielić i ustrukturyzować kod).

2) W folderze napisz pliki psr-4 lub normalne pliki php

Jeśli pliki PHP mają format psr-4, zostaną one automatycznie załadowane, w przeciwnym razie dodaj następujący wiersz w pliku composer.json, który znajduje się w katalogu głównym projektu

Wewnątrz autoloadklucza utwórz nowy klucz o nazwie filesładującej pliki podczas automatycznego ładowania. Wewnątrz filesobiektu dodaj ścieżkę zaczynając od katalogu aplikacji. Oto przykład.

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

PS: spróbuj uruchomić, composer dump-autoloadjeśli plik nie został załadowany.

Utwórz Helpers.php w app / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Dodaj kompozytora i aktualizację kompozytora

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

używać w kontrolerze

użyj App \ Helper \ Helpers

użyj w widoku zmiany w pliku config-> app.php

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

zadzwoń w widoku

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

w katalogu bootstrap \ autoload.php

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

dodaj ten plik

app\Helpers\function.php

**

• Pomocnik stanu

** stwórz nowego pomocnika

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

Użyj dla kontrolera i dowolnego pliku widoku

use App\Helpers\StatusHelper;

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

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

W laravel 5.3 i nowszych zespół laravel przeniósł wszystkie pliki proceduralne ( routes.php) z app/katalogu, a cały app/folder jest psr-4ładowany automatycznie. Przyjęta odpowiedź zadziała w tym przypadku, ale nie wydaje mi się to właściwe.

Więc zrobiłem to, że utworzyłem helpers/katalog w katalogu głównym mojego projektu i umieściłem w nim pliki pomocnicze, aw moim composer.jsonpliku zrobiłem to:

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

W ten sposób mój app/ katalog jest nadal ładowany automatycznie przez PSR-4, a pomocnicy są nieco lepiej zorganizowani.

Mam nadzieję, że to komuś pomoże.

Jest tu kilka świetnych odpowiedzi, ale myślę, że to jest najprostsze. W Laravel 5.4 (i starszych wersjach również) możesz stworzyć klasę w dogodnym dla ciebie miejscu, np. App / Libraries / Helper.php

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

Następnie możesz po prostu nazwać to w szablonie Blade w następujący sposób:

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

Jeśli nie chcesz używać @inject, po prostu ustaw funkcję „wielkich liter” jako statyczną i umieść wywołanie w szablonie Blade w następujący sposób:

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

Nie ma potrzeby używania aliasów. Laravel automatycznie rozwiązuje konkretną klasę.