it-swarm.com.de

Bewährte Methoden für benutzerdefinierte Helfer in Laravel 5

Ich möchte Hilfsfunktionen erstellen, um zu vermeiden, dass der Code zwischen den Ansichten in Laravel 5 wiederholt wird:

view.blade.php

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

Es handelt sich im Grunde genommen um Textformatierungsfunktionen. Wo und wie kann ich mit diesen Funktionen eine Datei erstellen?

397
Calebe Oliveira

Erstellen Sie eine helpers.php-Datei in Ihrem App-Ordner und laden Sie sie mit composer hoch:

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

Führen Sie den folgenden Befehl aus, nachdem Sie das zu Ihrer composer.json-Datei hinzugefügt haben:

composer dump-autoload

Wenn Sie Ihre helpers.php-Datei nicht in Ihrem app -Verzeichnis aufbewahren möchten (da es sich nicht um eine namengebundene PSR-4-Klassendatei handelt), können Sie Folgendes auf der laravel.com-Website tun: Speichern Sie den helpers.phpim bootstrap Verzeichnis . Denken Sie daran, es in Ihrer composer.json-Datei festzulegen:

"files": [
    "bootstrap/helpers.php"
]
509
Joseph Silber

Benutzerdefinierte Klassen in Laravel 5, der einfache Weg

Diese Antwort gilt für allgemeine benutzerdefinierte Klassen in Laravel. Eine spezifischere Antwort finden Sie unter Benutzerdefinierte Blade-Anweisungen in Laravel 5 .

Schritt 1: Erstellen Sie Ihre Helferdatei (oder eine andere benutzerdefinierte Klasse) und geben Sie ihr einen passenden Namespace. Schreiben Sie Ihre Klasse und Methode:

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

namespace App\Helpers;

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

Schritt 2: Erstellen Sie einen Alias:

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

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

Schritt 3: Führen Sie composer dump-autoload im Projektstamm aus

Schritt 4: Verwenden Sie es in Ihrer Blade-Vorlage:

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

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

Extra Credit: Verwenden Sie diese Klasse überall in Ihrer Laravel App:

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

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

Warum es funktioniert: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

Woher das automatische Laden stammt: http://php.net/manual/en/language.oop5.autoload.php

314
heisian

mein erster Gedanke war auch das automatische Laden von composer, aber es fühlte sich für mich nicht sehr Laravel schick an. L5 nutzt Service Provider in hohem Maße. Sie sind das, was Ihre Anwendung bootstrappt.

Zu Beginn habe ich einen Ordner in meinem app -Verzeichnis mit dem Namen Helpers erstellt. Dann habe ich im Ordner Helpers Dateien für Funktionen hinzugefügt, die ich hinzufügen wollte. Wenn Sie einen Ordner mit mehreren Dateien haben, können Sie vermeiden, dass eine große Datei zu lang und nicht mehr zu verwalten ist.

Als nächstes habe ich einen HelperServiceProvider.php erstellt, indem ich den handwerklichen Befehl ausgeführt habe:

artisan make:provider HelperServiceProvider

Innerhalb der register -Methode habe ich dieses Snippet hinzugefügt

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

registrieren Sie zuletzt den Dienstanbieter in Ihrem config/app.php im Provider-Array

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

jetzt ist jede Datei in Ihrem Helpers -Verzeichnis geladen und einsatzbereit.

UPDATE 22.02.2016

Hier gibt es viele gute Optionen, aber wenn meine Antwort für Sie funktioniert, habe ich ein Paket für die Einbeziehung von Helfern auf diese Weise erstellt. Sie können das Paket entweder als Inspiration verwenden oder es auch mit Composer herunterladen. Es hat einige eingebaute Helfer, die ich oft benutze (die aber standardmäßig alle inaktiv sind) und die es Ihnen ermöglichen, mit einem einfachen Artisan-Generator Ihre eigenen benutzerdefinierten Helfer zu erstellen. Außerdem wird der Vorschlag angesprochen, einen Mapper zu verwenden, und Sie können explizit die benutzerdefinierten Helfer definieren, die geladen werden sollen, oder standardmäßig alle PHP -Dateien in Ihrem Helfer-Verzeichnis automatisch laden. Feedback und PRs sind sehr willkommen!

composer require browner12/helpers

Github: browner12/helfer

295
Andrew Brown

Dies wird von JeffreyWay in dieser Laracasts-Diskussion vorgeschlagen.

  1. Erstellen Sie in Ihrem app/Http -Verzeichnis eine helpers.php -Datei und fügen Sie Ihre Funktionen hinzu.
  2. Fügen Sie in composer.json im Block autoload"files": ["app/Http/helpers.php"] hinzu.
  3. Führen Sie composer dump-autoload aus.
74
itsazzad

Nachdem ich verschiedene Antworten auf SO und Google durchgesehen hatte, konnte ich immer noch keinen optimalen Ansatz finden. Die meisten Antworten lassen darauf schließen, dass wir die Anwendung verlassen und uns auf das Drittanbieter-Tool Composer verlassen, um den Job zu erledigen. Ich bin jedoch nicht davon überzeugt, dass die Kopplung an ein Tool, nur um eine Datei einzuschließen, sinnvoll ist.

Andrew Browns Antwort kam meiner Meinung nach dem Ansatz am nächsten, aber (zumindest in 5.1) ist der Schritt des Dienstanbieters nicht erforderlich. Heisians Antwort hebt die Verwendung von PSR-4 hervor, was uns einen Schritt näher bringt. Hier ist meine letzte Implementierung für Helfer in Ansichten:

Erstellen Sie zunächst an einer beliebigen Stelle in Ihrem Anwendungsverzeichnis eine Hilfedatei mit einem Namespace:

namespace App\Helpers;

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

Alias ​​Ihrer Klasse in config\app.php im Array aliases:

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

Und das sollte alles sein, was Sie tun müssen. PSR-4 und der Alias ​​sollten den Helfer für Ihre Ansichten verfügbar machen. Geben Sie also in Ihrer Ansicht Folgendes ein:

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

Es sollte Folgendes ausgeben:

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

Benutzerdefinierte Blade-Anweisungen in Laravel 5

Ja, es gibt eine andere Möglichkeit, dies zu tun!

Schritt 1: Registrieren Sie eine benutzerdefinierte Blade-Direktive:

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

Schritt 2: Verwenden Sie Ihre benutzerdefinierte Blade-Direktive:

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

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

Ausgänge:

DIESES IS MEINE CUSTOM BLADE-RICHTLINIE !!
Benutzerdefinierter Link


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

Zusätzliche Lektüre: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives


Wenn Sie lernen möchten, wie Sie am besten benutzerdefinierte Klassen erstellen, die Sie verwenden können anywhere , lesen Sie Benutzerdefinierte Klassen in Laravel 5, the Easy Way

29
heisian

Dies ist meine HelpersProvider.php-Datei:

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

Sie sollten einen Ordner mit dem Namen Helpers unter dem Ordner app erstellen, dann eine Datei mit dem Namen whatever.php erstellen und die Zeichenfolge whatever in das $ helpers-Array einfügen.

Getan!

Bearbeiten

Ich verwende diese Option derzeit nicht mehr. Ich verwende composer, um statische Dateien wie Helfer zu laden.

Sie können die Helfer direkt hinzufügen unter:

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

Für benutzerdefinierte Hilfsbibliotheken in meinem Laravel Projekt habe ich einen Ordner mit dem Namen Libraries in meinem Laravel/App Verzeichnis erstellt. Innerhalb des Bibliotheksverzeichnisses habe ich verschiedene Dateien für verschiedene Hilfsbibliotheken erstellt.

Nach dem Erstellen meiner Hilfedateien füge ich einfach alle diese Dateien in meine composer.json -Datei ein

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

und ausführen

composer dump-autoload
10
Akshay Khale

Da OP nach Best Practices gefragt hat, fehlen hier meiner Meinung nach noch einige gute Ratschläge.

Eine einzelne helpers.php Datei ist keine gute Praxis. Erstens, weil Sie viele verschiedene Arten von Funktionen mischen und somit gegen die guten Codierungsprinzipien verstoßen. Darüber hinaus könnte nicht nur die Codedokumentation beeinträchtigen, sondern auch die Codemetriken wie Cyclomatic Complexity , Maintainability) Index und Halstead Volume . Je mehr Funktionen Sie haben, desto schlechter wird es.

Code-Dokumentation wäre Ok mit Tools wie phpDocumentor , aber mit Sami it keine prozeduralen Dateien rendern . Laravel API-Dokumentation ist ein solcher Fall - es gibt keine Hilfefunktionen-Dokumentation: https://laravel.com/api/5.4

Codemetriken können mit Tools wie PhpMetrics analysiert werden. Die Verwendung von PhpMetrics Version 1.x zum Analysieren von Laravel 5.4-Framework-Code liefert sehr schlechte CC/MI/HV-Metriken für beide src/Illuminate/Foundation/helpers.php und src/Illuminate/Support/helpers.php Dateien.

Mehrere kontextbezogene Hilfedateien (z. B. string_helpers.php , array_helpers.php usw.) würden diese schlechten Metriken mit Sicherheit verbessern Ein einfacher zu pflegender Code. Abhängig vom verwendeten Codedokumentationsgenerator wäre dies ausreichend.

Es kann weiter verbessert werden, indem Hilfsklassen mit statischen Methoden verwendet werden, damit sie mithilfe von Namespaces kontextualisiert werden können. Genau wie Laravel es bereits mit Illuminate\Support\Str und Illuminate\Support\Arr macht. Dies verbessert sowohl die Codemetriken/-organisation als auch die Dokumentation. Klassenaliase können verwendet werden, um die Verwendung zu vereinfachen.

Die Strukturierung mit Klassen verbessert die Code-Organisation und -Dokumentation. Andererseits verlieren wir die großen, kurzen und leicht zu merkenden globalen Funktionen. Wir können diesen Ansatz weiter verbessern, indem wir Funktionsaliasnamen für diese statischen Klassenmethoden erstellen. Dies kann entweder manuell oder dynamisch erfolgen.

Laravel verwendet intern den ersten Ansatz, indem Funktionen in den prozeduralen Hilfedateien deklariert werden, die den statischen Klassenmethoden zugeordnet sind. Dies ist möglicherweise nicht die ideale Sache, da Sie alle Informationen (docblocks/arguments) neu deklarieren müssen.
Ich persönlich benutze einen dynamischen Ansatz mit einer HelperServiceProvider -Klasse, die diese Funktionen in der Ausführungszeit erstellt:

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

Man kann sagen, dass dies über das Engineering hinausgeht, aber ich denke nicht. Es funktioniert ziemlich gut und kostet entgegen aller Erwartung zumindest bei Verwendung von PHP 7.x keine relevante Ausführungszeit.

8
Paulo Freitas

anstatt Ihre benutzerdefinierte Helferklasse einzuschließen, können Sie Ihre config/app.php -Datei tatsächlich unter Aliases hinzufügen.

sollte so aussehen.

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

fügen Sie dann den Helper zu Ihrem Controller hinzu, indem Sie die Methode 'use Helper' verwenden, damit Sie einfach einen Teil der Methode für Ihre Helper-Klasse aufrufen können.

eg. Helper::some_function();

in der Ressourcenansicht können Sie die Helper-Klasse bereits direkt aufrufen.

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

Dies ist jedoch immer noch der Ansatz für Entwickler-Codierungsstile, der befolgt werden muss. Wir haben vielleicht eine andere Art, Probleme zu lösen, und ich möchte nur mitteilen, was ich auch für Anfänger habe.

8
Kenneth Sunday

Hier ist ein Bash-Shell-Skript, das ich erstellt habe, um Laravel 5 Fassaden sehr schnell zu erstellen.

Führen Sie dies in Ihrem Laravel 5 Installationsverzeichnis aus.

Nenne es so:

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

Beispiel:

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

Wenn Sie dieses Beispiel ausführen, werden die Verzeichnisse Facades und Providers unter "Ihr_laravel_Installationsverzeichnis/app/MyApp" erstellt.

Es werden die folgenden 3 Dateien erstellt und auch auf dem Bildschirm ausgegeben:

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

Anschließend wird eine Meldung angezeigt, die der folgenden ähnelt:

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

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

Also aktualisiere die Provider und Alias ​​Liste in 'config/app.php'

composer -o dumpautoload ausführen

Die "./app/MyApp/Facades/Helper.php" sieht ursprünglich so aus:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Fügen Sie jetzt einfach Ihre Methoden in "./app/MyApp/Facades/Helper.php" hinzu.

So sieht "./app/MyApp/Facades/Helper.php" aus, nachdem ich eine Hilfsfunktion hinzugefügt habe.

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

Diese Funktion erwartet ein Muster und kann ein optionales zweites boolesches Argument akzeptieren.

Wenn die aktuelle URL mit dem übergebenen Muster übereinstimmt, wird 'active' ausgegeben (oder 'class = "active", wenn Sie' true 'als zweites Argument zum Funktionsaufruf hinzufügen).

Ich benutze es, um das Menü zu markieren, das aktiv ist.

Unten ist der Quellcode für mein Skript. Ich hoffe, Sie finden es nützlich und bitte lassen Sie mich wissen, wenn Sie irgendwelche Probleme damit haben.

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

Benutzerdefiniertes Hilfeverzeichnis erstellen: Zuerst das Hilfeverzeichnis im App-Verzeichnis erstellen. hlper-Klassendefinition erstellen: Erstellen wir jetzt eine einfache Hilfsfunktion, die zwei Zeichenfolgen verkettet. Erstellen Sie eine neue Datei MyFuncs.php in /app/Helpers/MyFuncs.php. Fügen Sie den folgenden Code hinzu

<?php

namespace App\Helpers;

class MyFuncs {

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

namespace App\Helpers; Definiert den Helfer-Namespace unter App-Namespace. class MyFuncs {…} definiert die Hilfsklasse MyFuncs. public static function full_name ($ first_name, $ last_name) {…} definiert eine statische Funktion, die zwei Zeichenfolgenparameter akzeptiert und eine verkettete Zeichenfolge zurückgibt

Helfer-Service bieten Klasse

Dienstanbieter werden zum automatischen Laden von Klassen verwendet. Wir müssen einen Dienstanbieter definieren, der alle unsere Hilfsklassen im Verzeichnis/app/Helpers lädt.

Führen Sie den folgenden handwerklichen Befehl aus:

pHP-Handwerker machen: Anbieter HelperServiceProvider

Die Datei wird in /app/Providers/HelperServiceProvider.php erstellt.

Open /app/Providers/HelperServiceProvider.php

Fügen Sie den folgenden Code hinzu:

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

HIER,

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.

Jetzt müssen wir den HelperServiceProvider registrieren und einen Alias ​​für unsere Helfer erstellen.

Öffnen Sie die Datei /config/app.php

Suchen Sie die Provider-Array-Variable

Fügen Sie die folgende Zeile hinzu

App\Providers\HelperServiceProvider::class,

Suchen Sie die Alias-Array-Variable

Fügen Sie die folgende Zeile hinzu

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

Speichern Sie die Änderungen mit unserem benutzerdefinierten Helfer

Wir werden eine Route erstellen, die unsere benutzerdefinierte Hilfefunktion Open /app/routes.php aufruft

Fügen Sie die folgende Routendefinition hinzu

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

HIER,

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

Ein anderer Weg, den ich benutzte, war: 1) eine Datei in app\FolderName\fileName.php erstellt und diesen Code darin gehabt, d.h.

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

2) Danach in unserer Klinge

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

das ist es. und es funktioniert

3
Dee

Best Practice, benutzerdefinierte Helfer zu schreiben, ist

1) Erstellen Sie im Verzeichnis app des Projektstamms einen Ordner mit dem Namen Helpers (nur um den Code zu trennen und zu strukturieren).

2) In den Ordner schreiben PSR-4-Dateien oder normale PHP-Dateien

Wenn die PHP -Dateien das Format psr-4 haben, werden sie automatisch geladen. Fügen Sie andernfalls die folgende Zeile in der Datei composer.json hinzu, die sich im Stammverzeichnis des Projekts befindet

Erstellen Sie im Schlüssel autoload einen neuen Schlüssel mit dem Namen files, um Dateien zum Zeitpunkt des automatischen Ladens zu laden. Fügen Sie im Objekt files den Pfad ab dem Anwendungsverzeichnis hinzu. Hier ein Beispiel .

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

PS: Versuchen Sie, composer dump-autoload auszuführen, wenn die Datei nicht geladen wurde.

3
Reiah Paul Sam

Erstellen Sie zuerst die Datei helpers.php im Verzeichnis App\Http. Fügen Sie dann den folgenden Code in die Datei composer.json ein

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

Führen Sie als nächstes den folgenden Befehl aus

composer dump-autoload

Jetzt können Sie Ihre benutzerdefinierte Funktion in der Datei helpers.php definieren.

3
ujjal

in dir bootstrap\autoload.php

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

füge diese Datei hinzu

app\Helpers\function.php
2
panqingqiang

Erstellen Sie Helpers.php in app/Helper/Helpers.php

namespace App\Helper
class Helpers
{


}

Fügen Sie in composer und composer update hinzu

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

im Controller verwenden

verwenden Sie App\Helper\Helpers

in Ansicht verwenden ändere in der config-> app.php Datei

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

Aufruf in Sicht

<?php echo Helpers::function_name();  ?>
2
abhishek kumar

**

  • Status Helper

** Neuen Helfer anlegen

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

Verwenden Sie für den Controller und eine beliebige Ansichtsdatei

use App\Helpers\StatusHelper;

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

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

Hier gibt es einige gute Antworten, aber ich denke, das ist die einfachste. In Laravel 5.4 (und möglicherweise auch in früheren Versionen) können Sie eine für Sie geeignete Klasse erstellen, z. B. App/Libraries/Helper.php

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

Dann können Sie es einfach in Ihrer Blade-Vorlage wie folgt aufrufen:

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

Wenn Sie @inject nicht verwenden möchten, müssen Sie nur die Funktion 'uppercasePara' als statisch definieren und den Aufruf wie folgt in Ihre Blade-Vorlage einbetten:

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

Es sind keine Aliase erforderlich. Laravel löst die konkrete Klasse automatisch auf.

0
omarjebari

In laravel 5.3 und höher hat das laravel-Team alle prozeduralen Dateien (routes.php) aus dem app/-Verzeichnis und dem gesamten app/ verschoben. Ordner ist psr-4 automatisch geladen. Die akzeptierte Antwort funktioniert in diesem Fall, fühlt sich aber für mich nicht richtig an.

Also habe ich ein helpers/ -Verzeichnis im Stammverzeichnis meines Projekts erstellt und die Hilfedateien darin abgelegt. In meiner composer.json -Datei habe ich Folgendes ausgeführt:

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

Auf diese Weise ist mein app/ -Verzeichnis immer noch ein von PSR-4 geladenes Verzeichnis, und die Helfer sind etwas besser organisiert.

Hoffe das hilft jemandem.

0
Mubashar Abbas