Najlepsze praktyki dla niestandardowych pomocników w Laravel 5 [zamknięte]

471

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?

Calebe Oliveira
źródło

Odpowiedzi:

594

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"
]
Joseph Silber
źródło
85
Wskazówka dla noobów: użyj tego polecenia po zmianie pliku composer.json. kompozytor dump-autoload
Allfarid Morales García
11
@ AllfaridMoralesGarcía Lub może po prostu „Przydatna wskazówka, ponieważ odpowiedź nie wyjaśnia, że ​​musisz to zrobić później”.
Matt McDonald,
8
Akceptuję funkcje pomocnicze, aby ułatwić pisanie widoków, ale nienawidzę, jak bardzo ta odpowiedź zawiera inne odpowiedzi. Nie zrozum mnie źle, jest to dobra odpowiedź i poprawna, po prostu obawiam się, że ludzie to wykorzystają i zaczną ponownie pisać mnóstwo źle napisanych, źle zorganizowanych funkcjonalnych PHP.
andrewtweber
39
Nie rozumiem tego podejścia. Kompozytor ma być narzędziem do włączania bibliotek: Laravel bez niego działałby doskonale, a Kompozytor bez Laravela. Ta sugestia każe nam utworzyć plik w naszej aplikacji, opuścić naszą aplikację, przejść do Kompozytora, powiedzieć kompozytorowi, aby wrócił do naszej aplikacji i załączył plik. Laravel wyraźnie obsługuje dołączanie plików, prawda? Dlaczego mielibyśmy zrezygnować z natywnej implementacji Laravela i użyć tego zewnętrznego narzędzia, aby załączyć dla nas plik, tym samym łącząc naszą aplikację z kompozytorem? Czy to lenistwo, czy coś mi brakuje?
dKen,
6
Laravel używa autoloadera kompozytora, aby wiedzieć, gdzie uwzględnić wszystkie biblioteki i pliki, na których polega. Dotyczy to bootstrap / autoload.php. Przeczytaj komentarz w tym pliku. Podejście polega na dodaniu odwołania do pliku do pliku composer.json, a następnie „zrzut autoload”, który regeneruje autoloader kompozytora, aby Laravel mógł go znaleźć. Korzystanie z kolekcji plików „Composer” jest dobrym sposobem na dodanie bibliotek lub plików funkcji jednorazowych, które nie są starannie opakowane w pakiety kompozytora. Fajnie jest mieć miejsce na wszystkie „przy okazji, muszę załączyć ten jeden dziwny plik”.
Phillip Harrington,
370

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

heisian
źródło
35
Dla jasności, ta odpowiedź w rzeczywistości nie dotyczy pomocników, które są funkcjami o globalnej przestrzeni nazw. Zamiast tego zachęca do konwersji pomocników na metody klasowe. Jest to ogólnie najlepsze podejście, ale tak naprawdę nie odpowiada na zadane tutaj pytanie, dlatego też inne odpowiedzi są tak złożone w porównaniu.
Dan Hunsaker,
1
Pomocnik funkcji oznacza, że ​​jest on również dostępny w Ostrzu. W jaki sposób udostępniasz tę funkcję w Ostrzu? Nie można wywołać Helper :: prettyJason (parametry) w bloku.
MaXi32,
@ MaXi32 możesz dodać klasę pod aliasestablicą w app/config.php: 'Helper' => App\Helpers\Helper::class, Wtedy będziesz w stanie dobrze zadzwonić do bloku Helper::prettyJson();.
heisian
@ DanHunsaker edytowany, aby bezpośrednio odpowiedzieć na pytanie, i nadal jest to to samo proste podejście. Możesz także napisać własne niestandardowe dyrektywy dotyczące ostrzy: stackoverflow.com/questions/28290332/...
heisian
1
Tak, raz przekopałem się przez platformę i znalazłem, gdzie wciągnęli pomocników. I znowu całkowicie się zgadzam, że metody klas statycznych z przestrzenią nazw są znacznie bardziej przejrzyste niż to, o co prosi się - lub zaleca się - przez większość czasu. Faktem jest, że pomocnicy nie są tak naprawdę The Laravel Way, ale raczej pozostałością po CodeIgniter 2.x, która wciąż nie została wycofana. Więc moja pedanteria na temat tego podejścia, polegającego na tym, że nie odpowiada dokładnie OP, o co pytano, jest raczej próbą uwypuklenia faktu, że nie otrzymujesz pomocników, a raczej coś lepszego.
Dan Hunsaker
315

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

Andrew Brown
źródło
29
dla ludzi, którzy mają tylko kilka funkcji, które muszą dodać, automatyczne ładowanie kompozytora jest w porządku, ale dla tych z nas, którzy mogą mieć wiele funkcji pomocniczych, organizacja wielu plików jest koniecznością. to rozwiązanie jest zasadniczo tym, co zrobiłem w L4, z wyjątkiem tego, że zarejestrowałem pliki w moim start.phppliku (co nie było świetne, ale spełniło swój cel jak na razie). masz inną sugestię dotyczącą ładowania wielu plików?
Andrew Brown,
7
Jeśli masz wiele plików, dodaj je wszystkie do pliku composer.json. Dodanie nawet 5-10 wierszy ma o wiele większy sens niż to, co masz tutaj.
Joseph Silber,
22
Myślę, że ta technika ma wiele zalet. Jest elegancki i wydajny, ponieważ nie musisz pamiętać o bałaganiu w pliku composer.json za każdym razem, gdy tworzysz plik pomocnika.
impeto
8
Naprawdę dobre rozwiązanie. Nie zgadzam się tylko ze sposobem dodawania plików. Myślę, że powinien to być program odwzorowujący, w którym dodajemy nazwę pliku, który chcemy załadować. Pomyśl o błędach! jeśli w jednym z plików występuje tylko jeden pomocnik, usuń je wszystkie lub zepsuj witrynę, dopóki nie rozwiążesz problemu.
Pablo Ezequiel Leone
3
Czy korzystasz z przestrzeni nazw App \ Providers? Jak nazywam tego pomocnika z kontrolera i widoku. Przepraszam, noob pytanie.
Cengkaruk
79

To, co jest sugerowane przez JeffreyWayLaracasts 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.
itsazzad
źródło
15
Pomocnicy mogą nie być tylko HTTP. app/helpers.phplub app/Helpers/wydaje się być lepszym miejscem.
sepehr
1
Co się stanie, jeśli będziemy na wspólnym serwerze i nie będziemy mieli opcji composer dump-autoload ?
user3201500
@ user3201500 to kolejne pytanie i może być konieczne zrobienie tego ręcznie, jeśli chcesz postępować zgodnie z powyższą odpowiedzią. Lub możesz wybrać spośród innych odpowiedzi. I aby ręcznie odzwierciedlić composer dump-autoload, możesz postępować zgodnie z poniższym: opracowano.be/2014/08/29/composer-dump-autoload-laravel
itsazzad
55

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>
dKen
źródło
dzięki za opublikowanie tego. jak zauważył @ Dan-Hunsaker w moim rozwiązaniu, nadal nie otrzymaliśmy funkcji o globalnej przestrzeni nazw, tj. możliwości pisania po prostu {!! bob() !!}. zamierzam jeszcze trochę poszukać i sprawdzić, czy to możliwe
heisian,
1
Myślałem o tym więcej, a próba uczynienia bob()prawdziwie globalnym nie byłaby mądra. Przestrzenie nazw istnieją z jakiegoś powodu i nie powinniśmy dzwonić bob()obok podstawowych funkcji PHP. Dodam twój bit aliasingu do mojego kodu - dzięki!
heisian
1
Uważam, że jest to najlepszy ze wszystkich
Jimmy Obonyo Abor,
Dlaczego tam extends Helperjest Nie wydaje mi się to konieczne.
bernie,
@bernie @ user3201500 Przepraszam zespół, miałem własną podstawową klasę pomocniczą, którą dziedziczą wszyscy moi pomocnicy; extends Helperrzeczywiście nie jest to konieczne. Dzięki za heads-upy.
dKen
31

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

heisian
źródło
Należy zaznaczyć najlepszą odpowiedź, ponieważ pytanie brzmiało: „aby uniknąć powtarzania kodu między niektórymi widokami”. Słowo kluczowe to WIDOKI. :)
Aleksandrs
23

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",
        ...
    ]
},
...
Pablo Ezequiel Leone
źródło
Czy istnieją inne powody poza wydajnością tworzenia programu odwzorowującego zamiast ładowania wszystkich plików w katalogu, glob()jak napisał Andrew Brown? Jeśli chcesz mieć możliwość określenia plików, które chcesz dołączyć, dlaczego nie określić plików w composer.jsoncelu ich automatycznego załadowania, jak napisał Joseph Silber? Dlaczego wolisz to rozwiązanie? Nie twierdzę, że to złe rozwiązanie, jestem po prostu ciekawy.
Pelmered
3
Dzięki podejściu odwzorowanemu łatwiej jest selektywnie włączać / wyłączać pomocników, jeśli na przykład jeden z plików pomocnika zawiera błąd zepsucia. To powiedziawszy, mapowanie plików u usługodawcy nie różni się tak bardzo, z composer.jsonwyjątkiem dwóch punktów - po pierwsze, utrzymuje mapę w samej aplikacji, a nie w pliku metadanych; po drugie, nie wymaga ponownego uruchamiania przy composer dump-autoloadkażdej zmianie listy plików do załadowania.
Dan Hunsaker,
Nie ma potrzeby includelub require, laravel ma już wbudowaną PSR-4 autoloading: php-fig.org/psr/psr-4
heisian
1
używanie PSR-4 i kompozytora nie pozwoli ci włączać / wyłączać pomocników.
Pablo Ezequiel Leone
@PabloEzequielLeone i jak mam go używać w kontrolerze lub w pliku bloku? To wydaje się najlepszą opcją, jeśli martwisz się, że nie ładujesz wszystkich pomocników dla wszystkich kontrolerów za każdym razem, ale nie jest to dobre dla początkujących w Laravel (jak ja).
VinGarcia
12

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
Akshay Khale
źródło
composer dump-autoloada composer dumpautoloadtakże działa infact composer dubędzie również działać ...
Akshay Khale
10

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.

Paulo Freitas
źródło
8

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 ""
Dziarskość
źródło
8

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.

Kenneth Sunday
źródło
4

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
Mizanur Rahman
źródło
4

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.

ujjal
źródło
3

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

Dee
źródło
3

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.

Reiah Paul Sam
źródło
3

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();  ?>
abhishek kumar
źródło
Dziękuję, czy mógłbyś rozwinąć nieco wyjaśnienia?
Felipe Valdes
2
Jeśli klasa ma przestrzeń nazw, dodanie pliku composer.jsonjest bezużyteczne, ponieważ psol-4 autoload wykona zadanie.
Arcesilas,
2

w katalogu bootstrap \ autoload.php

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

dodaj ten plik

app\Helpers\function.php
panqingqiang
źródło
2

**

  • 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'));
        }
}
Sunil
źródło
0

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.

Mubashar Abbas
źródło
0

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

omarjebari
źródło