php - template laravel 5 free




Meilleures pratiques pour les assistants personnalisés dans Laravel 5 (14)

Cours sur mesure à Laravel 5, le moyen le plus simple

Cette réponse est applicable aux classes personnalisées générales au sein de Laravel. Pour une réponse plus spécifique à la lame, voir Directives de lame personnalisées dans Laravel 5 .

Étape 1: Créez votre fichier Helpers (ou une autre classe personnalisée) et attribuez-lui un espace de noms correspondant. Ecrivez votre classe et votre méthode:

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

namespace App\Helpers;

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

Étape 2: Créez un alias:

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

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

Étape 3: Exécutez composer dump-autoload à la racine du projet

Étape 4: Utilisez-le dans votre modèle de lame:

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

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

Extra Credit: Utilisez cette classe n'importe où dans votre application 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!!');
    }
    ...

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

Pourquoi cela fonctionne: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

D'où le chargement automatique provient de: http://php.net/manual/en/language.oop5.autoload.php

J'aimerais créer des fonctions d'assistance pour éviter de répéter le code entre les vues dans Laravel 5:

view.blade.php

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

Ce sont essentiellement des fonctions de formatage de texte. Où et comment puis-je créer un fichier avec ces fonctions?


Directives de lames personnalisées dans Laravel 5

Oui, il y a une autre façon de faire ça!

Étape 1: Enregistrez une directive de lame personnalisée:

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

Étape 2: Utilisez votre directive Blade personnalisée:

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

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

Les sorties:

C’EST CELA MON DIRECTIVE DE LAME SUR MESURE !!
Lien personnalisé

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

Lecture supplémentaire: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives

Si vous souhaitez apprendre à créer des classes personnalisées que vous pouvez utiliser n'importe où , voir Classes personnalisées dans Laravel 5, la méthode la plus simple.


Créer Helpers.php dans app / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Ajouter compositeur et mise à jour du compositeur

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

utiliser dans le contrôleur

use App\Helper\Helpers

utiliser en vue changer dans le fichier config-> app.php

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

appeler en vue

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

Il y a quelques bonnes réponses ici mais je pense que c'est la plus simple. Dans Laravel 5.4 (et les versions antérieures prob aussi), vous pouvez créer une classe quelque part qui vous convienne, par exemple App / Libraries / Helper.php.

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

Ensuite, vous pouvez simplement l'appeler dans votre modèle de lame comme suit:

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

Si vous ne souhaitez pas utiliser @inject, il vous suffit alors de rendre la fonction 'uppercasePara' statique et d'intégrer l'appel dans votre modèle de lame de la manière suivante:

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

Pas besoin de pseudonymes. Laravel résout la classe concrète automatiquement.


**

  • Statut assistant

** créer un nouvel assistant

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

Utiliser pour le contrôleur et tout fichier de vue

use App\Helpers\StatusHelper;

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

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

Après avoir passé au crible une variété de réponses sur SO et Google, je ne pouvais toujours pas trouver une approche optimale. La plupart des réponses suggèrent de quitter l'application et de faire appel à un outil tiers, Composer, mais je ne suis pas convaincu que le couplage à un outil, juste pour inclure un fichier, est judicieux.

La réponse d'Andrew Brown était la plus proche de la manière dont, à mon avis, il fallait le traiter, mais (au moins en 5.1), l'étape du fournisseur de service est inutile. La réponse de Heisian met en évidence l'utilisation du PSR-4 qui nous rapproche un peu plus. Voici ma dernière implémentation pour les assistants dans les vues:

Commencez par créer un fichier d'assistance n'importe où dans votre répertoire d'applications, avec un espace de noms:

namespace App\Helpers;

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

Ensuite, alias votre classe dans config\app.php , dans le tableau aliases :

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

Et cela devrait être tout ce que vous devez faire. PSR-4 et l'alias devraient exposer l'assistant à vos points de vue, donc à votre avis, si vous tapez:

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

Il devrait produire:

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

Créez d’abord le fichier helpers.php dans le répertoire App \ Http. Puis ajoutez le code suivant dans le composer.json

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

Ensuite, exécutez la commande suivante

composer dump-autoload

Vous pouvez maintenant définir votre fonction personnalisée dans le fichier helpers.php.


Créez un fichier helpers.php dans votre dossier d'application et chargez-le avec composer:

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

Après avoir ajouté cela à votre fichier composer.json , exécutez la commande suivante:

composer dump-autoload

Si vous n'aimez pas garder votre fichier helpers.php dans votre répertoire d' app (car ce n'est pas un fichier de classe d'espaces de noms PSR-4), vous pouvez faire ce que fait le site Web laravel.com : stockez le helpers.php dans le répertoire de démarrage . N'oubliez pas de le définir dans votre fichier composer.json :

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

La meilleure pratique pour écrire des aides personnalisées est

1) Dans le répertoire app de la racine du projet, créez un dossier nommé Helpers (séparez et structurez le code).

2) Dans le dossier, écrivez des fichiers psr-4 ou php normaux

Si les fichiers PHP sont au format psr-4, ils seront automatiquement chargés. Sinon, ajoutez la ligne suivante dans composer.json, qui se trouve dans le répertoire racine du projet.

Dans la clé de autoload , créez une nouvelle clé nommée files pour charger les fichiers au moment du chargement automatique. Dans l’objet files , ajoutez le chemin à partir du répertoire app., Voici un exemple.

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

PS: essayez d’exécuter composer dump-autoload si le fichier n’est pas chargé.


Ma pensée initiale était aussi le chargement automatique du compositeur, mais je ne me sentais pas très bien avec Laravel. L5 fait un usage intensif des fournisseurs de services, ce sont eux qui amorcent votre application.

Pour commencer, j'ai créé un dossier dans mon répertoire d' app appelé Helpers . Ensuite, dans le dossier Helpers , j'ai ajouté des fichiers pour les fonctions que je voulais ajouter. Avoir un dossier avec plusieurs fichiers nous permet d'éviter un gros fichier qui devient trop long et ingérable.

Ensuite, j'ai créé un HelperServiceProvider.php en exécutant la commande artisan:

artisan make:provider HelperServiceProvider

Dans la méthode du register , j'ai ajouté cet extrait.

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

enfin, enregistrez le fournisseur de services dans votre config/app.php dans le tableau des fournisseurs

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

maintenant, tous les fichiers de votre répertoire Helpers sont chargés et prêts à être utilisés.

MISE À JOUR 2016-02-22

Il y a beaucoup de bonnes options ici, mais si ma réponse fonctionne pour vous, je suis allé de l'avant et j'ai créé un paquet pour inclure des aides de cette façon. Vous pouvez utiliser le package pour obtenir de l'inspiration ou vous pouvez également le télécharger avec Composer. Il a quelques aides intégrées que j'utilise souvent (mais qui sont toutes inactives par défaut) et vous permet de créer vos propres aides personnalisées avec un simple générateur Artisan. Il répond également à la suggestion d'un répondeur d'utiliser un mappeur et vous permet de définir explicitement les aides personnalisées à charger ou, par défaut, de charger automatiquement tous les fichiers PHP dans votre répertoire d'assistance. Les commentaires et les relations publiques sont très appréciés!

composer require browner12/helpers

Github: browner12/helpers


Une autre manière que j’ai utilisée était: 1) de créer un fichier dans app \ FolderName \ fileName.php et d’avoir ce code à

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

2) Après cela dans notre lame

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

c'est ça. et il fonctionne


Voici mon fichier 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;
            }
        }
    }
}

Vous devez créer un dossier appelé Helpers sous le dossier de l' app , puis créer un fichier appelé whatever.php dedans et ajouter la chaîne à l'intérieur du tableau $ helpers.

Terminé!

Modifier

Je n'utilise plus cette option, j'utilise actuellement composer pour charger des fichiers statiques tels que des assistants.

Vous pouvez ajouter les aides directement à:

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

au lieu d'inclure votre classe d'assistance personnalisée, vous pouvez en fait ajouter à votre fichier config/app.php sous des alias.

devrait ressembler à ceci.

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

et ensuite à votre contrôleur, incluez Helper en utilisant la méthode 'use Helper' afin que vous puissiez simplement appeler une partie de la méthode sur votre classe Helper.

eg. Helper::some_function();

ou dans la vue des ressources, vous pouvez déjà appeler directement la classe Helper.

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

Mais c’est toujours l’approche du style de codage à suivre. Nous pouvons avoir différentes façons de résoudre les problèmes, et je veux juste partager ce que j'ai aussi pour les débutants.


Créer un répertoire de helpers personnalisé: Créez d'abord un répertoire de helpers dans le répertoire app. Créer une définition de classe hlper: Créons maintenant une fonction d'assistance simple qui concaténera deux chaînes. Créez un nouveau fichier MyFuncs.php dans /app/Helpers/MyFuncs.php Ajoutez le code suivant

<?php

namespace App\Helpers;

class MyFuncs {

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

espace de noms App \ Helpers; définit l'espace de noms Helpers sous l'espace de noms App. La classe MyFuncs {…} définit la classe d'assistance MyFuncs. fonction statique publique full_name ($ first_name, $ last_name) {…} définit une fonction statique qui accepte deux paramètres de chaîne et renvoie une chaîne concaténée

Helpers service fournit la classe

Les fournisseurs de services sont utilisés pour charger automatiquement les classes. Nous devrons définir un fournisseur de services qui chargera toutes nos classes d'assistance dans le répertoire / app / Helpers.

Exécutez la commande artisan suivante:

Fabricant artisanal php: fournisseur HelperServiceProvider

Le fichier sera créé dans /app/Providers/HelperServiceProvider.php

Open /app/Providers/HelperServiceProvider.php

Ajoutez le code suivant:

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

ICI,

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.

Nous devons maintenant enregistrer HelperServiceProvider et créer un alias pour nos assistants.

Ouvrir le fichier /config/app.php

Localiser la variable du tableau providers

Ajouter la ligne suivante

App\Providers\HelperServiceProvider::class,

Localisez la variable du tableau d'alias

Ajouter la ligne suivante

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

Enregistrez les modifications à l'aide de notre aide personnalisée

Nous allons créer un itinéraire qui appellera notre fonction d'assistance personnalisée Ouvrir /app/routes.php

Ajouter la définition de route suivante

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

ICI,

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




laravel-helper