Meilleures pratiques pour les assistants personnalisés dans Laravel 5
Je voudrais 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?
Créez un fichier helpers.php dans votre dossier d'applications 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 app (car ce n'est pas un fichier de classe d'espaces de noms PSR-4), vous pouvez faire ce que le site Web laravel.com: stocke le helpers.phpdans le répertoire bootstrap) . N'oubliez pas de le définir dans votre fichier composer.json:
"files": [
"bootstrap/helpers.php"
]
Classes personnalisées dans Laravel 5, la solution de facilité
Cette réponse est applicable aux classes personnalisées générales dans 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!!') !!}
Crédit supplémentaire: 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 ça marche: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php
Origine du chargement automatique: http://php.net/manual/fr/language.oop5.autoload.php
ma pensée initiale était aussi le composer autoload, mais il ne me semblait pas très Laravel 5. 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 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.
Ensuite, j'ai 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, enregistrez le fournisseur de services dans votre config/app.php dans le tableau providers
'providers' => [
'App\Providers\HelperServiceProvider',
]
maintenant, tout fichier de votre répertoire Helpers est chargé et prêt à être utilisé.
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 de votre répertoire d'assistance. Les commentaires et les relations publiques sont très appréciés!
composer require browner12/helpers
Github: browner12/helpers
C’est ce qui est suggéré par JeffreyWay dans ceci Discussion sur les Laracastes .
- Dans votre répertoire
app/Http, créez un fichierhelpers.phpet ajoutez vos fonctions. - Dans
composer.json, dans le blocautoload, ajoutez"files": ["app/Http/helpers.php"]. - Exécutez
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 quitter l'application et de faire appel à un outil tiers Composer pour effectuer le travail, mais je ne suis pas convaincu que le couplage à un outil simplement pour inclure un fichier est judicieux.
Réponse d'Andrew Brown s'est le plus proche de la façon dont, à mon avis, il convient de l'aborder, mais (au moins en 5.1), l'étape du fournisseur de service est inutile. réponse de Heisian souligne l'utilisation de 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 vues, donc à votre vue, si vous tapez:
{!! BobFinder::bob() !!}
Il devrait produire:
<strong>Bob?! Is that you?!</strong>
Directives de lames personnalisées dans Laravel 5
Oui, il existe une autre façon de procéder!
Étape 1: Enregistrez une directive Blade 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
Sorties:
CECI IS MA 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 voulez apprendre comment créer au mieux des classes personnalisées que vous pouvez utiliser n'importe où , voir Classes personnalisées dans Laravel 5, la méthode simplifiée
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 app, puis créer un fichier nommé whatever.php inside et ajouter la chaîne whatever à 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",
...
]
},
...
Pour les bibliothèques d'assistance personnalisées de mon projet Laravel, j'ai créé un dossier portant le nom Libraries dans mon répertoire Laravel/App et dans le répertoire Libraries, j'ai créé divers fichiers pour différentes bibliothèques d'assistance.
Après avoir créé mes fichiers d'assistance, j'inclus simplement tous ces fichiers dans mon fichier composer.json comme ceci
...
"autoload": {
"classmap": [
"database"
],
"files": [
"app/Libraries/commonFunctions.php"
],
"psr-4": {
"App\\": "app/"
}
},
...
et exécuter
composer dump-autoload
Puisque OP a demandé les meilleures pratiques , je pense que nous manquons encore de bons conseils.
Un seul fichier helpers.php est loin d’être une bonne pratique. Tout d'abord parce que vous mélangez de nombreuses fonctions différentes, vous êtes donc contre les bons principes de codage. De plus, cela pourrait blesser non seulement la documentation de code mais également les métriques de code telles que la complexité cyclomatique , Indice de maintenabilité et Volume de Halstead . Plus vous avez de fonctions, plus cela empire.
La documentation du code serait Ok utilisant des outils tels que phpDocumentor , mais utilisant Sami it ne rendra pas les fichiers de procédure . Laravel La documentation de l'API en est un exemple. Aucune documentation sur les fonctions d'assistance n'existe: https://laravel.com/api/5.4
Les métriques de code peuvent être analysées avec des outils tels que PhpMetrics . Utiliser PhpMetrics version 1.x pour analyser Laravel 5.4 vous donnera de très mauvaises métriques CC/MI/HV pour les deux src/Illuminate/Foundation/helpers.php et src/Illuminate/Support/helpers.php des dossiers.
Plusieurs fichiers d'assistance contextuelle (par exemple string_helpers.php , array_helpers.php , etc.) améliorerait certainement ces mauvaises mesures, ce qui rendrait le code plus facile à conserver. Selon le générateur de documentation de code utilisé, cela serait suffisant.
Il peut être encore amélioré en utilisant des classes auxiliaires avec des méthodes statiques afin qu'elles puissent être contextualisées à l'aide d'espaces de noms. Tout comme Laravel fait déjà avec Illuminate\Support\Str et Illuminate\Support\Arr classes. Cela améliore à la fois les métriques de code/organisation et la documentation. Les alias de classe pourraient être utilisés pour les rendre plus faciles à utiliser.
La structuration avec des classes améliore l'organisation du code et la documentation, mais d'un autre côté, nous finissons par perdre ces grandes fonctions globales courtes et faciles à mémoriser. Nous pouvons améliorer encore cette approche en créant des alias de fonction pour ces méthodes de classes statiques. Cela peut être fait manuellement ou dynamiquement.
Laravel utilise en interne la première approche en déclarant des fonctions dans les fichiers auxiliaires procéduraux mappés aux méthodes de classes statiques. Ce n'est peut-être pas la solution idéale, car vous devez redéclarer tous les éléments (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 dire que c'est trop d'ingénierie, mais je ne le pense pas. Cela fonctionne plutôt bien et contrairement à ce à quoi on pourrait s’attendre, il ne coûte pas de temps d’exécution pertinent au moins lorsqu’on utilise PHP 7.x.
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.
Voici un script de shell bash que j'ai créé pour créer très rapidement Laravel 5 façades.
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 exécutez cet exemple, il créera les répertoires Facades et Providers sous 'rép_installation_larlar_laravel/app/MonApp'.
Il créera 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
Une fois cette opération terminée, un message semblable au suivant s'affichera:
===========================
Finished
===========================
Add these lines to config/app.php:
----------------------------------
Providers: App\MyApp\Providers\HelperServiceProvider,
Alias: 'Helper' => 'App\MyApp\Facades\HelperFacade',
Donc, mettez à jour la liste des fournisseurs et des alias dans 'config/app.php'
Exécuter composer -o dumpautoload
Le fichier "./app/MyApp/Facades/Helper.php" ressemblera à l'origine à ceci:
<?php
namespace App\MyApp\Facades;
class Helper
{
//
}
Ajoutez maintenant vos méthodes dans "./app/MyApp/Facades/Helper.php".
Voici à quoi ressemble "./app/MyApp/Facades/Helper.php" après l’ajout d’une fonction Helper.
<?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 modèle et peut accepter un deuxième argument booléen facultatif.
Si l'URL actuelle correspond au modèle qui lui a été transmis, le résultat sera "actif" (ou "class =" active "" si vous ajoutez "true" en tant que second argument de l'appel de fonction).
Je l'utilise pour mettre en évidence le menu qui est actif.
Vous trouverez ci-dessous 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 cela.
#!/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 ""
Créer un répertoire d’aides personnalisé: Créez d’abord un répertoire d’aides dans le répertoire app. Créer une définition de classe hlper: Créons maintenant une fonction d’aide 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
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 à l’intérieur i.e
<?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
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 chargés automatiquement. Sinon, ajoutez la ligne suivante dans le fichier composer.json, situé dans le répertoire racine du projet.
Dans la clé 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 de lancer composer dump-autoload si le fichier n'est pas chargé.
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.
dans répertoire bootstrap\autoload.php
require __DIR__.'/../vendor/autoload.php';
require __DIR__.'/../app/Helpers/function.php'; //add
ajouter ce fichier
app\Helpers\function.php
Créer Helpers.php dans app/Helper/Helpers.php
namespace App\Helper
class Helpers
{
}
Ajouter dans composer et composer update
"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
utiliser App\Helper\Helpers
utiliser en vue changer dans le fichier config-> app.php
'aliases' => [
...
'Helpers' => 'App\Helper\Helpers'
],
appel en vue
<?php echo Helpers::function_name(); ?>
**
- Status Helper
** 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'));
}
}
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.
Dans laravel 5.3 et versions ultérieures, l'équipe laravel a déplacé tous les fichiers de procédure (routes.php) hors du répertoire app/ et l'intégralité du app/ Le dossier est psr-4 Autoloaded. La réponse acceptée fonctionnera dans ce cas mais cela ne me convient pas.
Donc, ce que j'ai fait, c'est que j'ai créé un répertoire helpers/ à la racine de mon projet et que j'ai placé les fichiers d'assistance à 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 toujours chargé automatiquement par psr-4 et les assistants sont un peu mieux organisés.
J'espère que ça aide quelqu'un.