Meilleures pratiques pour les assistants sur mesure sur Laravel 5
je voudrais créer quelques helpers (fonctions) pour éviter de répéter le code entre certaines vues, dans le style L5:
.lame.php
<p>Foo Formated text: {{ fooFormatText($text) }}</p>
ce sont essentiellement des fonctions de formatage de texte. Où et comment puis-je mettre un fichier avec ces fonctions?
20 réponses
créez un fichier helpers.php
dans votre dossier app 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
, lancez la commande suivante:
composer dump-autoload
si vous n'aimez pas garder votre fichier helpers.php
dans votre répertoire app
(parce que ce n'est pas un fichier de classe PSR-4 avec un nom), vous pouvez faire ce que le site laravel.com
fait: stocker le helpers.php
dans le répertoire bootstrap . N'oubliez pas de le mettre dans votre fichier composer.json
:
"files": [
"bootstrap/helpers.php"
]
ma pensée initiale était le compositeur autoload aussi, mais il ne se sentait pas très Laravel 5ish à moi. L5 utilise beaucoup les fournisseurs de services, ils sont ce qui bootstraps votre application.
pour commencer, j'ai créé un dossier dans mon répertoire app
appelé Helpers
. Puis, 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.
J'ai ensuite créé un HelperServiceProvider.php
en exécutant la commande artisan:
artisan make:provider HelperServiceProvider
dans la méthode register
j'ai ajouté cet extrait
public function register()
{
foreach (glob(app_path().'/Helpers/*.php') as $filename){
require_once($filename);
}
}
enfin enregistrer le fournisseur de services dans votre config/app.php
dans le tableau des fournisseurs
'providers' => [
'App\Providers\HelperServiceProvider',
]
maintenant, n'importe quel fichier dans votre Helpers
répertoire est chargé et prêt à l'emploi.
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 a fait un paquet pour inclure les helpers de cette façon. Vous pouvez utiliser le package comme source d'inspiration ou vous pouvez le télécharger avec Composer. Il a quelques helpers intégrés que j'utilise souvent (mais qui sont tous inactifs par défaut) et vous permet de faire vos propres helpers personnalisés avec un générateur artisanal simple. Il traite également de la suggestion d'un répondant: utiliser un mapper et vous permet de définir explicitement les helpers personnalisés à charger, ou par défaut, charger automatiquement tous les fichiers PHP dans votre répertoire helper. Commentaires et PRs sont très appréciés!
composer require browner12/helpers
Github: browner12/helpers
cours sur mesure dans Laravel 5, La voie facile
Cette réponse est applicable général des classes personnalisées dans Laravel. Pour une réponse plus spécifique à la lame, voir les Directives sur les lames personnalisées dans Laravel 5 .
Étape 1: créez votre fichier Helpers (ou autre classe personnalisée) et donnez-lui un espace de nom correspondant. Écrivez votre classe et 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éer un alias:
<?php // Code within config/app.php
'aliases' => [
...
'Helper' => App\Helpers\Helper::class,
...
Étape 3: utilisez-le dans votre modèle de lame:
<!-- Code within resources/views/template.blade.php -->
{!! Helper::shout('this is how to use autoloading correctly!!') !!}
crédit supplémentaire: utilisez cette classe où que vous soyez 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 œuvres: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php
dont l'autoloading est originaire: http://php.net/manual/en/language.oop5.autoload.php
C'est ce que suggère JeffreyWay
dans cette Discussion Laracasts .
- dans votre répertoire
app/Http
, créez un fichierhelpers.php
et ajoutez vos fonctions. - dans
composer.json
, dans le blocautoload
, ajouter"files": ["app/Http/helpers.php"]
. - Exécuter
composer dump-autoload
.
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 laisser l'application et de se fier à un tiers compositeur d'outils pour faire le travail, mais je ne suis pas convaincu couplage à un outil juste pour inclure un fichier est sage.
la réponse d'Andrew Brown se rapproche le plus de la façon dont je pense qu'il devrait être abordé, mais (au moins en 5.1), l'étape du fournisseur de services n'est pas nécessaire. Heisian's answer souligne l'utilisation de PSR-4
qui nous rapproche un peu. Voici ma mise en œuvre finale pour helpers in views:
tout d'abord, créez un fichier helper n'importe où dans votre répertoire apps, avec un namespace:
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 aliases
tableau:
'aliases' => [
// Other aliases
'BobFinder' => App\Helpers\BobFinder::class
]
et ça devrait être tout ce que vous avez à faire. PSR-4
et l'alias devrait exposer l'assistant à vos vues, donc dans votre vue, si vous tapez:
{!! BobFinder::bob() !!}
il devrait sortir:
<strong>Bob?! Is that you?!</strong>
directives sur les lames personnalisées dans Laravel 5
Oui, il y a l'autre façon de le faire!
Étape 1: enregistrer 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 de lame personnalisée:
<!-- // code in resources/views/view.blade.php -->
@shout('this is my custom blade directive!!')
<br />
@customLink
sorties:
C'EST MA DIRECTIVE SUR LES LAMES!!
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 voulez apprendre comment faire au mieux des classes personnalisées que vous pouvez utiliser n'importe où , voir des Classes Personnalisées dans Laravel 5, le Moyen le plus Facile
c'est mon assistant Provider.fichier 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 app
, puis créer un fichier appelé whatever.php
à l'intérieur et ajouter la chaîne de caractères whatever
à l'intérieur du tableau $helpers.
fait!
Modifier
Je n'utilise plus cette option, j'utilise actuellement composer pour charger des fichiers statiques comme helpers.
Vous pouvez ajouter les helpers directement à:
...
"autoload": {
"files": [
"app/helpers/my_helper.php",
...
]
},
...
pour les bibliothèques D'aide personnalisée dans mon projet Laravel, j'ai créé un dossier avec le nom Libraries
dans mon répertoire Laravel/App
et dans le répertoire des bibliothèques, j'ai créé divers fichiers pour différentes bibliothèques d'aide.
après avoir créé mes fichiers d'aide, j'inclus simplement tous ces fichiers dans mon compositeur .json fichier comme ceci
...
"autoload": {
"classmap": [
"database"
],
"files": [
"app/Libraries/commonFunctions.php"
],
"psr-4": {
"App\": "app/"
}
},
...
et exécuter
composer dumpautoload
au lieu d'inclure votre classe custom helper, vous pouvez en fait ajouter à votre fichier config/app.php
sous alias.
devrait ressembler à ceci.
'aliases' => [
...
...
'Helper' => App\Http\Services\Helper::class,
]
et ensuite à votre Controller, incluez L'Assistant en utilisant la méthode 'use Helper' de sorte que vous pouvez 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 de style de codage de développeur à suivre. On peut avoir différentes façon de résoudre les problèmes, et je veux juste partager ce que j'ai trop pour les débutants.
depuis que L'OP a demandé meilleures pratiques , je pense que nous manquons encore de bons conseils ici.
Un seul helpers.php fichier est loin d'être une bonne pratique. D'abord parce que vous mélangez beaucoup de différents types de fonctions, de sorte que vous êtes contre les bons principes du codage. De plus, ce pourrait nuire non seulement à la documentation du code, mais aussi aux paramètres du code comme complexité cyclomatique , l'Indice de Maintenabilité et Halstead Volume . Plus vous avez de fonctions, plus ça empire.
la documentation de Code serait Ok en utilisant des outils comme phpdocumenter , mais en utilisant Sami it ne rendra pas les dossiers de procédure . La documentation de l'API Laravel est un tel cas - il n'y a pas de documentation sur les fonctions d'assistance: https://laravel.com/api/5.4
Les mesures de Codepeuvent être analysées avec des outils comme PhpMetrics . Utilisation de la version 1 de PhpMetrics.x pour analyser Laravel 5.4 cadre code vous donnera de très mauvais CC/MI/HV métriques pour les deux src/Éclairer/Fondation/helpers.php et src/Éclairer/Support/helpers.php "1519220920 de fichiers".
Multiple fichiers d'aide contextuelle (p. ex. string_helpers.php , array_helpers.php , etc.) améliorerait certainement ces mauvaises mesures résultant en un code plus facile à mantain. Selon le générateur de documentation de code utilisé, cela suffirait.
il peut être encore amélioré en utilisant des classes helper avec des méthodes statiques afin qu'elles puissent être contextualisées en utilisant des espaces de noms. Tout comme Laravel le fait déjà avec Illuminate\Support\Str
et Illuminate\Support\Arr
des classes. Cela améliore à la fois les paramètres/organisation du code et la documentation. Classe alias peut être utilisé pour les rendre plus faciles à utiliser.
structurer avec des classes rend l'organisation du code et de la documentation meilleure, mais d'un autre côté nous finissons par perdre ces grandes fonctions globales courtes et faciles à mémoriser. Nous pouvons encore améliorer cette approche en créant des alias de fonctions pour ces méthodes de classes statiques. Ce peut être fait manuellement ou dynamiquement.
Laravel interne utiliser la première approche en déclarant des fonctions dans les fichiers d'aide procédurale qui correspond aux méthodes de classes statiques. Ce n'est peut-être pas la chose idéale car vous avez besoin de reclasser toutes les choses (docblocks/arguments).
Personnellement, j'utilise une approche dynamique avec une classe HelperServiceProvider
qui crée ces fonctions dans le temps d'exécution:
<?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()
{
//
}
}
on peut disons que c'est fini pour l'ingénierie, mais je ne pense pas. Il fonctionne assez bien et contrairement à ce qui pourrait être attendu, il ne coûte pas le temps d'exécution pertinent au moins lors de L'utilisation de PHP 7.x.
voici un script bash shell que j'ai créé pour faire des façades Laravel 5 très rapidement.
exécutez ceci dans votre répertoire D'installation Laravel 5.
appelez ça comme ça:
make_facade.sh -f <facade_name> -n '<namespace_prefix>'
exemple:
make_facade.sh -f helper -n 'App\MyApp'
si vous lancez cet exemple, il créera les répertoires Facades
et Providers
sous" your_laravel_installation_dir/app/MyApp".
il va créer les 3 fichiers suivants et les affichera également à l'écran:
./app/MyApp/Facades/Helper.php
./app/MyApp/Facades/HelperFacade.php
./app/MyApp/Providers/HelperServiceProvider.php
après qu'il est fait, il affichera un message similaire à ce qui suit:
===========================
Finished
===========================
Add these lines to config/app.php:
----------------------------------
Providers: App\MyApp\Providers\HelperServiceProvider,
Alias: 'Helper' => 'App\MyApp\Facades\HelperFacade',
mettez donc à jour la liste des fournisseurs et des Alias dans 'config/app.php '
Exécuter composer -o dumpautoload
La "./ app/MyApp/façades / Helper.php "ressemblera à l'origine à ceci:
<?php
namespace App\MyApp\Facades;
class Helper
{
//
}
maintenant, il suffit d'ajouter vos méthodes dans "./ app/MyApp/façades / Helper.php".
Voici ce que "./ app/MyApp/façades / Helper.php" ressemble après j'ai ajouté une fonction d'assistance.
<?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) !!}
cette fonction attend un motif et peut accepter un deuxième argument booléen optionnel.
Si l'URL correspond au modèle transmis, il sera sortie "active" (ou " classe="active" si vous ajoutez "vrai" comme deuxième argument de la fonction).
Je l'utilise pour mettre en évidence le menu qui est actif.
ci-dessous est le code source de mon script. J'espère que vous le trouverez utile et s'il vous plaît laissez-moi savoir si vous avez des problèmes avec elle.
#!/bin/bash
display_syntax(){
echo ""
echo " The Syntax is like this:"
echo " ========================"
echo " "$(basename "151960920")" -f <facade_name> -n '<namespace_prefix>'"
echo ""
echo " Example:"
echo " ========"
echo " "$(basename "151960920") -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=""
case $key in
-n|--namespace_prefix)
namespace_prefix_in=""
echo ""
shift # past argument
;;
-f|--facade)
facade_name_in=""
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/g')
facade_name_upcase=$(echo ${facade_name_in} | sed -e 's/\b\(.\)/\u/')
facade_name_lowercase=$(echo ${facade_name_in} | awk '{print tolower("151960920")}')
# 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 ""
créer le répertoire personnalisé des helpers: Créez d'abord le répertoire Helpers dans le répertoire app. créer définition de classe hlper: Créons maintenant une fonction d'aide simple qui concaténera deux chaînes. Créer un nouveau fichier MyFuncs.php in/app/Helpers / MyFuncs.ajouter le code suivant
<?php
namespace App\Helpers;
class MyFuncs {
public static function full_name($first_name,$last_name) {
return $first_name . ', '. $last_name;
}
}
namespace App\Helpers; définit le namespace Helpers sous App namespace. classe MyFuncs { ... } définit l'Assistant class MyFuncs. public static function 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
Assistants du service de classe
Les fournisseurs de servicessont utilisés pour les classes de chargement automatique. Nous aurons besoin de définir un fournisseur de services qui chargera toutes nos classes helper dans /app/Helpers directory.
exécuter la commande artisanale suivante:
php artisan faire:fournisseur de HelperServiceProvider
le fichier sera créé en /app/Providers/HelperServiceProvider.php
Open /app/Providers/HelperServiceProvider.php
ajouter 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 le HelperServiceProvider et créer un alias pour nos helpers.
ouvrir /config/app.php
fichier
Localisez la variable du tableau des fournisseurs
ajouter la ligne suivante
App\Providers\HelperServiceProvider::class,
Localiser les alias de la variable de matrice
ajouter la ligne suivante
'MyFuncs' => App\Helpers\MyFuncs::class,
Enregistrer les modifications En utilisant notre aide personnalisé
nous allons créer une route qui appellera notre fonction Helper personnalisée Open /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
une autre façon que j'ai utilisée était: 1) Création d'un fichier dans app\FolderName\fileName.php et avait ce code à l'intérieur I. e
<?php
namespace App\library
{
class hrapplication{
public static function libData(){
return "Data";
}
}
}
?>
2) Après que dans notre lame
$FmyFunctions = new \App\FolderName\classsName;
echo $is_ok = ($FmyFunctions->libData());
c'est ça. et ça marche
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 (juste pour séparer et structurer le code).
2) à l'intérieur du dossier écrire des fichiers psr-4 ou des fichiers php normaux
si les fichiers PHP sont au format psr-4, ils seront chargés automatiquement, sinon ajoutez la ligne suivante dans le composer.json qui est dans le répertoire racine du projet
à l'intérieur de la clé autoload
, créez une nouvelle clé appelée files
pour charger des fichiers au moment du chargement automatique,à l'intérieur de l'objet files
ajoutez le chemin à partir du répertoire app. ici est 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é.
dir bootstrap\autoload.151930920 php"
require __DIR__.'/../vendor/autoload.php';
require __DIR__.'/../app/Helpers/function.php'; //add
ajouter ce fichier
app\Helpers\function.php
créer d'abord helpers.php dans le répertoire App\Http. Puis ajoutez le code suivant à l'intérieur du compositeur.json
"autoload": {
"classmap": [
"database"
],
"files": [
"app/Http/helpers.php"
],
"psr-4": {
"App\": "app/"
}
},
exécuter la commande suivante
composer dump-autoload
maintenant vous pouvez définir votre fonction personnalisée à l'intérieur des helpers.fichier php. Ici vous pouvez obtenir le guide complet
Je ne suis pas d'accord avec toutes les autres réponses à cette question!
tout d'abord, il n'y a rien de mal à avoir quelques fonctions d'aide globale. A titre d'exemple, L'application sur laquelle je travaille actuellement a 5 ans (elle a démarré sur Laravel 3!) et a un total de seulement six fonctions globales qui sont utilisées fréquemment pour le formatage de date et les buts de débogage. Il n'y a aucun conflit avec d'autres fonctions dans l'Espace-nom mondial et, à leur base, ils sont pas orienté objet, alors pourquoi faire des méthodes statiques dans une classe de conteneur? Une chose qui, à mon avis, est pire que de trop compter sur de vieilles fonctions banales, c'est de les présenter comme des classes et de se faire des illusions en pensant que vous faites maintenant les choses de la bonne façon . Aussi, devoir préfixer ces fonctions d'aide avec un nom de classe ou un alias de classe est juste horriblement douloureux, d'où ma préférence pour les garder comme des fonctions globales simples.
deuxièmement, si nous voulons parler de la pureté du code, nous ne devrions pas envisager une solution qui laisse tomber un fichier helpers.php
n'importe où dans la zone app/
, car le dossier app/
est destiné à être réservé aux classes PSR-4.
aussi, je pense que beaucoup de réponses sont trop compliquées. Créer de nouvelles classes de fournisseurs juste pour autoload un tas d'autre code quand il y a déjà un endroit parfaitement bon pour autoload code est juste stupide.
Je n'ai remarqué qu'une seule réponse qui envisageait de modifier bootstrap/autoload.php
, qui, à mon avis, est absolument l'endroit le plus approprié pour s'y accrocher. Il n'y a pas de règle, écrite ou autre, qui dit que nous ne devrions pas changer ce fichier. Bien sûr, vous devez vérifier si elle change d'une version de Laravel à l'autre, mais il en va de même pour les fichiers de configuration, les classes de fournisseurs, les files d'attente, etc.
donc, je crois que la solution la plus simple et la plus appropriée est de créer un fichier dans le dossier bootstrap
appelé helpers.php
et ajouter la ligne suivante à la fin de boostrap/autoload.php
:
require __DIR__.'/helpers.php';
cette autre réponse qui suggérait de changer autoload.php
était presque la réponse parfaite (IMO), sauf qu'ils ont suggéré de mettre function.php
dans le dossier app/Helpers
. Comme mentionné ci-dessus, le dossier app/
est destiné à être pour les classes PSR-4, donc pas le meilleur endroit pour jeter un fichier avec un tas de fonctions d'aide.
Créer Des Helpers.php dans app/Helper / Helpers.php
namespace App\Helper
class Helpers
{
}
Ajouter au compositeur et compositeur de mise à jour
"autoload": {
"classmap": [
"database/seeds",
"database/factories",
"database","app/Helper/Helpers.php"
],
"psr-4": {
"App\": "app/"
},
"files": ["app/Helper/Helpers.php"]
},
utilisation dans le contrôleur
use App\Helper\Helpers
utilisation en vue changement dans config - > app.fichier php
'aliases' => [
...
'Helpers' => 'App\Helper\Helpers'
],
appel en vue
<?php echo Helpers::function_name(); ?>
dans laravel 5.3 et au-dessus, l'équipe de laravel a déplacé tous les fichiers de procédure ( routes.php
) hors du répertoire app/
, et le dossier entier app/
est psr-4
autoloadé. La réponse acceptée fonctionnera dans ce cas, mais elle ne me semble pas juste.
donc ce que j'ai fait c'est créer un répertoire helpers/
à la racine de mon projet et mettre les fichiers d'aide à l'intérieur de celui-ci, et dans mon fichier composer.json
j'ai fait ceci:
...
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\": "app/"
},
"files": [
"helpers/ui_helpers.php"
]
},
...
de cette façon, mon répertoire app/
est encore un répertoire psr-4 autoloadé, et les helpers sont un peu mieux organisés.
Espérons que cela aide quelqu'un.
Il y a quelques grandes réponses ici, mais je pense que c'est le plus simple. Dans Laravel 5.4 (et prob versions précédentes aussi), vous pouvez créer une classe quelque part qui vous convient, par exemple App/Libraries/Helper.php
class Helper() {
public function uppercasePara($str) {
return '<p>' .strtoupper($str). '<p>;
}
}
alors vous pouvez simplement l'appeler dans votre modèle de lame comme ceci:
@inject('helper', \App\Libraries\Helper)
{{ $helper->drawTimeSelector() }}
si vous ne voulez pas utiliser @inject alors juste faire la fonction 'uppercasePara' statique et intégrer l'appel dans votre modèle de lame comme ceci:
{{ \App\Libraries\Helper::drawTimeSelector() }}
pas besoin d'alias. Laravel résout automatiquement la classe béton.