[[11]} początkowo myślałem, że kompozytor autoload, jak również, ale nie czułem się zbyt Laravel 5ish dla mnie. L5 intensywnie korzysta z dostawców usług, to oni są tym, co uruchamia Twoją aplikację.

Na początek utworzyłem w moim katalogu app folder o nazwie Helpers. Następnie w folderze Helpers dodałem pliki dla 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 stworzyłem HelperServiceProvider.php uruchamiając polecenie rzemieślnika:

artisan make:provider HelperServiceProvider

W metodzie register dodałem ten fragment

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

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

Teraz każdy plik w katalogu Helpers jest załadowany i gotowy do użycia.

Aktualizacja 2016-02-22

Istnieje wiele dobrych opcji tutaj, ale jeśli moja odpowiedź działa dla Ciebie, poszedłem do przodu i zrobiłem Pakiet Dla tym pomocników w ten sposób. Możesz użyć pakietu do inspiracji lub Zapraszam do pobrania go z Composer, jak również. Ma kilka wbudowanych helperów, których często używam (ale które są domyślnie nieaktywne) i pozwala na tworzenie własnych niestandardowych helperów za pomocą prostego generatora Artisan. Odnosi się również do sugestii, jaką miał JEDEN responder, aby użyć mapera i pozwala jawnie zdefiniować niestandardowe helpery do załadowania lub domyślnie automatycznie załadować wszystkie pliki PHP w katalogu helpera. Feedback i PRs są dużo doceniam to!

composer require browner12/helpers

Github: browner12 / helpers

Niestandardowe klasy w Laravel 5, łatwy sposób

Ta odpowiedź ma zastosowanie do ogólnych klas niestandardowych w Laravel. Aby uzyskać bardziej szczegółową odpowiedź, zobacz niestandardowe dyrektywy ostrza w Laravel 5.

Krok 1: Utwórz plik Helpers (lub innej niestandardowej klasy) 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: użyj go w swoim ostrzu szablon:

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

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

Dodatkowe podziękowania: Użyj tej klasy gdziekolwiek 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 autoloading: http://php.net/manual/en/language.oop5.autoload.php

To właśnie sugeruje JeffreyWay w tejdyskusji Laracasts .

1. w katalogu app/Http Utwórz plik helpers.php i dodaj swoje funkcje.
2. wewnątrz composer.json, w bloku autoload dodaj "files": ["app/Http/helpers.php"].
3. Run composer dump-autoload.

Po przejrzeniu różnych odpowiedzi NA SO I Google, nadal nie mogłem znaleźć optymalnego podejścia. Większość odpowiedzi sugeruje, że opuszczamy aplikację i polegamy na 3rd party tool Composer, aby wykonać zadanie, ale nie jestem przekonany, łączenie się z narzędziem po prostu 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 usługodawcy jest niepotrzebny. odpowiedź Heisiana podkreśla użycie Co przybliża nas o krok. Oto moja ostateczna implementacja dla helperów w views:

Najpierw Utwórz plik pomocniczy 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ępny, alias twojej klasy w config\app.php, w tablicy aliases:

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

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

Powinno wyjść:

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

Custom Blade Directives in Laravel 5

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 własnej dyrektywy Ostrza:

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

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

Wyjścia:

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

Dodatkowe Czytanie: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives

Jeśli chcesz dowiedzieć się, jak najlepiej tworzyć niestandardowe klasy, z których możesz korzystać w dowolnym miejscu, Zobacz niestandardowe klasy w Laravel 5, w łatwy sposób {7]}

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

Należy utworzyć folder o nazwie Helpers w folderze app, następnie utworzyć plik o nazwie whatever.php wewnątrz i dodać łańcuch whatever wewnątrz tablicy $helpers.

Edit

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

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

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

Dla własnych bibliotek pomocniczych w moim projekcie Laravel, utworzyłem folder o nazwie Libraries w moim katalogu Laravel/App, a w katalogu Libraries utworzyłem Różne Pliki dla różnych bibliotek pomocniczych.

Po utworzeniu plików pomocniczych po prostu dołączam wszystkie te pliki do mojego composera.json plik taki jak ten

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

I wykonać

composer dumpautoload

Zamiast dołączać własną klasę pomocniczą, możesz dodać do pliku config/app.php pod aliasami.

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

A następnie do kontrolera Dołącz Helper używając metody 'use Helper', dzięki czemu możesz po prostu wywołać niektóre metody na swojej klasie Helper.

eg. Helper::some_function();

Lub w widoku resources można już bezpośrednio wywołać klasę pomocniczą.

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

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

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

Pojedynczy pomocnicy.plik php nie jest dobrą praktyką. Po pierwsze dlatego, że mieszasz wiele różnych funkcji, więc jesteś przeciwny dobrym zasadom kodowania. Co więcej, to Może zaszkodzić nie tylko dokumentacji kodu, ale także metrykom kodu, takim jak Cyclomatic Complexity, indeks nośności i Objętość Halsteada. Im więcej funkcje, które masz, tym bardziej się pogarsza.

Dokumentacja kodu byłaby w porządku używając narzędzi takich jak phpDocumentor , ale używając Sami to nie wyrenderuje plików proceduralnych . Taka jest dokumentacja API Laravel - nie ma dokumentacji funkcji pomocniczych: https://laravel.com/api/5.4

Metryki kodu mogą być analizowane za pomocą narzędzi takich jak PhpMetrics . Korzystanie z PhpMetrics w wersji 1.x do analizy kodu frameworka Laravel 5.4 da ci bardzo zły Wskaźniki CC / MI / HV dla obu src / Illuminate / Foundation / helpers.php oraz src / Illuminate / Support / helpers.php pliki.

Wiele kontekstowych plików pomocniczych (np. string_helpers.php, array_helpers.php , itd.) z pewnością poprawiłoby te złe metryki, co skutkowałoby łatwiejszym kodem do mantain. W zależności od używanego generatora dokumentacji kodowej byłoby to wystarczająco dobre.

Można go jeszcze ulepszyć używając klas pomocniczych z statyczne metody, dzięki czemu mogą być kontekstualizowane za pomocą przestrzeni nazw. Tak jak Laravel już robi z Illuminate\Support\Str oraz Illuminate\Support\Arr klasy. Poprawia to zarówno metrykę/organizację kodu, jak i dokumentację. Aliasy klas mogą być używane, aby ułatwić ich użycie.

Strukturyzacja za pomocą klas sprawia, że organizacja kodu i dokumentacja są lepsze, ale z drugiej strony tracimy te wielkie krótkie i łatwe do zapamiętania funkcje globalne. Możemy jeszcze bardziej udoskonalić to podejście poprzez tworzenie aliasów funkcji do tych metod klas statycznych. Można to zrobić ręcznie lub dynamicznie.

Laravel wewnętrznie używa pierwszego podejścia, deklarując funkcje w plikach pomocniczych proceduralnych, które odwzorowują metody klas statycznych. Może to nie być idealna rzecz, ponieważ musisz ponownie zgłosić wszystkie rzeczy (docblocks/arguments).
Ja osobiście używam dynamicznego podejścia z klasą HelperServiceProvider, 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 tak powiedzieć to koniec inżynierii, ale nie sądzę. Działa całkiem dobrze i wbrew temu, czego można się spodziewać, nie kosztuje odpowiedniego czasu wykonania przynajmniej przy użyciu PHP 7.x.

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

Uruchom to w 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 Facades i Providers Pod 'your_laravel_installation_dir / app / MyApp'.

Utworzy następujące 3 pliki i wyświetli je na ekranie:

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

Po zakończeniu wyświetli wiadomość podobna do następującej:

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

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

Więc zaktualizuj listę dostawców i aliasów w ' config / app.php "

Run composer -o dumpautoload

"./ app / MyApp / fasady / Helper.php " będzie oryginalnie wyglądać tak:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Teraz po prostu dodaj swoje metody w "./ app / MyApp / fasady / Helper.php".

Oto co "./ app / MyApp / fasady / Helper.php " wygląda jak po dodaniu funkcji pomocniczej.

<?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 boolean kłótnia.

Jeśli bieżący adres URL pasuje do wzorca przekazanego do niego, wyświetli"active" (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 ""

Utwórz własny katalog helperów: Najpierw Utwórz katalog Helpers w katalogu aplikacji. Utwórz definicję klasy hlper: Stwórzmy teraz prostą funkcję pomocniczą, która połączy dwa ciągi znaków. 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 Helpers w obszarze App namespace. Klasa MyFuncs { ... } definiuje klasę pomocniczą MyFuncs. public static function full_name ($first_name, $ last_name) { ... } definiuje statyczną funkcję, która akceptuje dwa parametry łańcuchowe i zwraca skonkatenowany łańcuch

Helpers service provide class

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

Uruchom następujące polecenie:

Php artisan Marka: provider HelperServiceProvider

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

Open /app/Providers/HelperServiceProvider.php

Dodać 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.php Plik

Locate the providers array variable

Dodaj następujący wiersz

App\Providers\HelperServiceProvider::class,

Zlokalizuj zmienną tablicy aliases

Dodaj następujący wiersz

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

Zapisz zmiany Korzystanie z naszego custom helpera

Stworzymy trasę, która będzie zadzwoń do naszej niestandardowej funkcji pomocnika 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

Innym sposobem, który użyłem był: 1) utworzono plik w aplikacji \ Nazwa folderu\nazwa pliku.php i miał w sobie ten kod tj.

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

2) Po tym w naszym ostrzu

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

Najlepszą praktyką pisania niestandardowych pomocników jest

1) wewnątrz katalogu app głównego projektu, utwórz folder o nazwie Helpers(aby oddzielić i uporządkować kod).

2) wewnątrz folderu Zapisz pliki psr-4 lub zwykłe pliki php

Jeśli pliki PHP są w formacie psr-4, to zostanie załadowany automatycznie, w przeciwnym razie dodaj następującą linię w kompozytorze.json, który znajduje się w głównym katalogu projektu

Wewnątrz klucza autoload Utwórz nowy klucz o nazwie files, aby załaduj pliki w momencie automatycznego załadowania, wewnątrz obiektu files Dodaj ścieżkę zaczynającą się 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-autoload Jeśli plik nie zostanie załadowany.

W katalogu bootstrap\autoload.php

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

Dodaj ten plik

app\Helpers\function.php

Najpierw Utwórz helpery.php w katalogu App \ Http. Następnie dodaj następujący kod wewnątrz kompozytora.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ć własną funkcję wewnątrz helperów.plik php. Tutaj możesz uzyskać pełny przewodnik

Nie zgadzam się z każdą inną odpowiedzią na to pytanie!

Po pierwsze, nie ma nic złego w posiadaniu kilku globalnych funkcji pomocniczych. Na przykład aplikacja, nad którą obecnie pracuję, ma pięć lat (zaczęła się na Laravel 3!) i ma w sumie tylko sześć globalnych funkcji, które są często używane do formatowania i debugowania dat. Nie ma żadnych kolizji z żadnymi innymi funkcjami w globalnej przestrzeni nazw, a ich rdzeniem są , a nie zorientowane obiektowo, więc po co robić z nich statyczne metody w klasie kontenera? Jedna rzecz, która moim zdaniem jest gorsza od polegania zbyt mocno na zwykłych starych funkcjach, to pakowanie ich jako klas i łudzenie się, że teraz robisz rzeczy we właściwy sposób . Ponadto, posiadanie prefiksu tych funkcji pomocniczych z nazwą klasy lub aliasem klasy jest po prostu strasznie bolesne, stąd moja preferencja, aby zachować je jako proste funkcje globalne.

Po drugie, jeśli chcemy rozmawiać o kodzie czystość, nie powinniśmy brać pod uwagę rozwiązania, które upuszcza plik helpers.php gdziekolwiek w obszarze app/, ponieważ folder app/ ma być przeznaczony tylko dla klas PSR-4.

Zauważyłem tylko jedną odpowiedź, która rozważa modyfikację bootstrap/autoload.php, która moim zdaniem jest absolutnie najbardziej odpowiednie miejsce do podłączenia. Nie ma żadnej reguły, pisanej lub innej, która mówi, że nie powinniśmy zmieniać tego pliku. Oczywiście, musisz sprawdzić, czy zmienia się z jednego wydania Laravela na następne, ale to samo dotyczy plików konfiguracyjnych, klas dostawców, kolejek itp.

Dlatego uważam, że najprostszym i najodpowiedniejszym rozwiązaniem jest utworzenie pliku w folderze bootstrap o nazwie helpers.php i dodanie następującej linijki na końcu boostrap/autoload.php:

require __DIR__.'/helpers.php';

Ta inna odpowiedź, która sugerowała zmianę autoload.php było prawie doskonałą odpowiedzią (IMO), z tym, że zasugerowali umieszczenie function.php w folderze app/Helpers. Jak wspomniano powyżej, folder app/ ma być przeznaczony dla klas PSR-4, więc nie jest to najlepsze miejsce na wrzucenie pliku z kilkoma funkcjami pomocniczymi.

Tworzenie Pomocników.php w app / Helper/Helpers.php

namespace App\Helper
class Helpers
{


}

Dodaj w composer i composer update

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

Użyj w kontrolerze

use App\Helper\Helpers

Użyj w widoku zmiana w config- > app.plik php

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

Call in view

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

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

Więc to, co zrobiłem, to stworzyłem helpers/ katalog w katalogu głównym mojego projektu i umieściłem w nim pliki pomocnicze, a w moim pliku composer.json zrobiłem tak:

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

W ten sposób mój app/ katalog jest nadal autoładowany psr-4, A pomocnikami są trochę lepiej zorganizowane.

Jest tu kilka świetnych odpowiedzi, ale myślę, że to najprostsze. W Laravel 5.4 (a także wcześniejszych wersjach prob) możesz utworzyć klasę w dogodnym dla Ciebie miejscu, np. App / Libraries / Helper.php

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

Wtedy możesz po prostu wywołać go w szablonie Blade tak:

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

Jeśli nie chcesz używać @ inject, po prostu wykonaj funkcję 'uppercasePara' jako statyczną i umieść wywołanie w szablonie ostrza w następujący sposób:

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

Nie potrzeba aliasów. Laravel rozwiązuje klasa betonu automatycznie.