मैं Laravel 5 में विचारों के बीच कोड को दोहराने से बचने के लिए सहायक कार्य बनाना चाहूंगा:
view.blade.php
<p>Foo Formated text: {{ fooFormatText($text) }}</p>वे मूल रूप से पाठ स्वरूपण कार्य कर रहे हैं। मैं इन कार्यों के साथ फ़ाइल कहाँ और कैसे बना सकता हूँ?
जवाबों:
helpers.phpअपने एप्लिकेशन फ़ोल्डर में एक फ़ाइल बनाएं और इसे संगीतकार के साथ लोड करें:
"autoload": {
"classmap": [
...
],
"psr-4": {
"App\\": "app/"
},
"files": [
"app/helpers.php" // <---- ADD THIS
]
},उसे अपनी composer.jsonफ़ाइल में जोड़ने के बाद , निम्न कमांड चलाएँ:
composer dump-autoloadयदि आप अपनी helpers.phpफ़ाइल को अपनी appनिर्देशिका में रखना पसंद नहीं करते (क्योंकि यह PSR-4 नामस्थान श्रेणी की फ़ाइल नहीं है), तो आप यह कर सकते हैं कि laravel.comवेबसाइट क्या करती है: helpers.php बूटस्ट्रैप निर्देशिका में संग्रहीत करें । इसे अपनी composer.jsonफ़ाइल में सेट करना याद रखें :
"files": [
"bootstrap/helpers.php"
]यह उत्तर लारवेल के भीतर सामान्य कस्टम वर्गों के लिए लागू है । अधिक ब्लेड-विशिष्ट उत्तर के लिए, लारावेल 5 में कस्टम ब्लेड निर्देश देखें ।
चरण 1: अपने हेल्पर्स (या अन्य कस्टम वर्ग) फ़ाइल बनाएँ और इसे एक मिलान नामस्थान दें। अपनी कक्षा और विधि लिखें:
<?php // Code within app\Helpers\Helper.php
namespace App\Helpers;
class Helper
{
public static function shout(string $string)
{
return strtoupper($string);
}
}चरण 2: एक उपनाम बनाएं:
<?php // Code within config/app.php
'aliases' => [
...
'Helper' => App\Helpers\Helper::class,
...चरण 3:composer dump-autoload प्रोजेक्ट रूट में चलाएँ
चरण 4: अपने ब्लेड टेम्पलेट में इसका उपयोग करें:
<!-- Code within resources/views/template.blade.php -->
{!! Helper::shout('this is how to use autoloading correctly!!') !!}अतिरिक्त क्रेडिट: अपने लारवेल ऐप में कहीं भी इस वर्ग का उपयोग करें:
<?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!!');
}
...स्रोत: http://www.php-fig.org/psr/psr-4/
यह क्यों काम करता है: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php
ऑटोलॉडिंग कहां से उत्पन्न होती है: http://php.net/manual/en/language.oop5.autoload.php
aliasesसरणी में जोड़ सकते हैं app/config.php: 'Helper' => App\Helpers\Helper::class, तब आप Helper::prettyJson();ब्लेड में कॉल कर पाएंगे ।
मेरे शुरुआती विचार संगीतकार ऑटोलैड के रूप में अच्छी तरह से थे, लेकिन यह मेरे लिए बहुत Laravel 5ish नहीं लगा। L5 सेवा प्रदाताओं का भारी उपयोग करता है, वे वही हैं जो आपके एप्लिकेशन को बूटस्ट्रैप करते हैं।
शुरू करने के लिए मैंने अपनी appनिर्देशिका में एक फोल्डर बनाया जिसे कहा जाता है Helpers। फिर Helpersफ़ोल्डर के भीतर मैंने उन फ़ंक्शंस के लिए फाइलें जोड़ीं जिन्हें मैं जोड़ना चाहता था। कई फ़ाइलों के साथ एक फ़ोल्डर होने से हमें एक बड़ी फ़ाइल से बचने की अनुमति मिलती है जो बहुत लंबी और असहनीय हो जाती है।
आगे मैंने HelperServiceProvider.phpकारीगर कमांड चलाकर बनाया :
artisan make:provider HelperServiceProviderregisterविधि के भीतर मैंने इस स्निपेट को जोड़ा
public function register()
{
foreach (glob(app_path().'/Helpers/*.php') as $filename){
require_once($filename);
}
}अंत में अपने सेवा प्रदाता config/app.phpको प्रदाता सरणी में पंजीकृत करें
'providers' => [
'App\Providers\HelperServiceProvider',
]अब आपकी Helpersनिर्देशिका की कोई भी फ़ाइल लोड हो गई है, और उपयोग के लिए तैयार है।
अद्यतन 2016-02-22
यहां बहुत सारे अच्छे विकल्प हैं, लेकिन अगर मेरा जवाब आपके लिए काम करता है, तो मैंने आगे बढ़कर मदद करने वालों के लिए इस तरह से एक पैकेज बनाया। आप या तो प्रेरणा के लिए पैकेज का उपयोग कर सकते हैं या इसे संगीतकार के साथ डाउनलोड करने के लिए स्वतंत्र महसूस कर सकते हैं। इसमें कुछ ऐसे हेल्पर्स बनाए गए हैं जिनका मैं अक्सर उपयोग करता हूं (लेकिन जो डिफ़ॉल्ट रूप से सभी निष्क्रिय हैं) और आपको एक साधारण कारीगर जनरेटर के साथ अपने स्वयं के कस्टम हेल्पर्स बनाने की अनुमति देता है। यह उस सुझाव को भी संबोधित करता है जिसमें एक उत्तरदाता को मैपर का उपयोग करना था और आपको अपने हेल्पर निर्देशिका में सभी PHP फ़ाइलों को लोड करने के लिए या डिफ़ॉल्ट रूप से कस्टम सहायकों को स्पष्ट रूप से परिभाषित करने की अनुमति देता है। प्रतिक्रिया और पीआर बहुत सराहना की है!
composer require browner12/helpersstart.phpफ़ाइल में फ़ाइलों को पंजीकृत किया (जो कि बहुत अच्छा नहीं था, लेकिन समय के लिए इसका उद्देश्य था)। क्या आपके पास कई फ़ाइलों को लोड करने के लिए एक और सुझाव है?
JeffreyWayइस लैराकैस्ट्स चर्चा में यह सुझाव दिया गया है ।
app/Httpनिर्देशिका के भीतर , एक helpers.phpफ़ाइल बनाएं और अपने कार्यों को जोड़ें।composer.json, autoloadब्लॉक में, जोड़ें "files": ["app/Http/helpers.php"]।composer dump-autoload।app/helpers.phpया app/Helpers/एक बेहतर जगह लगती है।
composer dump-autoload ?
composer dump-autoloadआप इस का पालन हो सकता है: developed.be/2014/08/29/composer-dump-autoload-laravel
एसओ और गूगल पर कई तरह के जवाबों के बाद भी, मैं अभी भी एक इष्टतम दृष्टिकोण नहीं पा सका। अधिकांश उत्तर बताते हैं कि हम आवेदन छोड़ देते हैं और काम करने के लिए 3 पार्टी टूल कम्पोज़र पर भरोसा करते हैं, लेकिन मैं एक उपकरण में शामिल नहीं हूं, बस एक फाइल को शामिल करना बुद्धिमान है।
एंड्रयू ब्राउन का जवाब निकटतम था कि मुझे कैसे लगता है कि इसे संपर्क किया जाना चाहिए, लेकिन (कम से कम 5.1), सेवा प्रदाता कदम अनावश्यक है। हेइशियन का जवाब हमारे उपयोग को उजागर करता है PSR-4जो हमें एक कदम करीब लाता है। विचारों में मदद करने वालों के लिए यहां मेरा अंतिम कार्यान्वयन है:
सबसे पहले, अपने ऐप्लिकेशन निर्देशिका में कहीं भी एक सहायक फ़ाइल बनाएँ, जिसमें एक नाम स्थान हो:
namespace App\Helpers;
class BobFinder
{
static function bob()
{
return '<strong>Bob?! Is that you?!</strong>';
}
}इसके बाद, अपनी कक्षा config\app.phpको aliasesसरणी में:
'aliases' => [
// Other aliases
'BobFinder' => App\Helpers\BobFinder::class
]और आपको बस इतना करना चाहिए। PSR-4और उपनाम आपके विचार से सहायक को प्रकट करना चाहिए, इसलिए यदि आप लिखते हैं, तो आपके विचार में:
{!! BobFinder::bob() !!}यह उत्पादन करना चाहिए:
<strong>Bob?! Is that you?!</strong>{!! bob() !!}। कुछ और खोज करने के लिए जा रहा है और देखें कि क्या संभव है
bob()वास्तव में वैश्विक बनाने का प्रयास करना बुद्धिमानी नहीं होगी। नामस्थान एक कारण से हैं और हमें bob()आधार PHP कार्यों के साथ नहीं बुलाया जाना चाहिए । मैं अपने कोड में आपका उपनाम जोड़ने जाऊंगा - धन्यवाद!
extends Helper? यह मेरे लिए आवश्यक नहीं लगता है।
extends Helperवास्तव में आवश्यक नहीं है। सर उठाने के लिए धन्यवाद।
हां, ऐसा करने का एक और तरीका है!
चरण 1: एक कस्टम ब्लेड निर्देश पंजीकृत करें:
<?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>';
});
}
...चरण 2: अपने कस्टम ब्लेड निर्देश का उपयोग करें:
<!-- // code in resources/views/view.blade.php -->
@shout('this is my custom blade directive!!')
<br />
@customLinkआउटपुट:
यह मेरी कस्टम उद्देश्य है !!
विशिष्ट संबंध
स्रोत: https://laravel.com/docs/5.1/blade#extending-blade
अतिरिक्त पढ़ना: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives
यदि आप सीखना चाहते हैं कि कस्टम कक्षाएं कैसे बनायें जो आप कहीं भी उपयोग कर सकते हैं , तो लारावेल 5, ईज़ी वे में कस्टम क्लासेस देखें
यह मेरी 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;
}
}
}
}आपको फ़ोल्डर के Helpersनीचे नामक एक फ़ोल्डर बनाना चाहिए app, फिर फ़ाइल को whatever.phpअंदर बुलाया और whatever$ हेल्पर्स सरणी के अंदर स्ट्रिंग जोड़ें ।
किया हुआ!
मैं अब इस विकल्प का उपयोग नहीं कर रहा हूं, मैं वर्तमान में हेल्पर्स की तरह स्थिर फाइलों को लोड करने के लिए कंपोजर का उपयोग कर रहा हूं।
आप सहायकों को सीधे यहां जोड़ सकते हैं:
...
"autoload": {
"files": [
"app/helpers/my_helper.php",
...
]
},
...glob()एंड्रयू ब्राउन द्वारा लिखित के रूप में निर्देशिका में सभी फ़ाइलों को लोड करने के बजाय मैपर बनाने के लिए प्रदर्शन के अलावा कोई अन्य कारण हैं ? यदि आप उन फ़ाइलों को निर्दिष्ट करने में सक्षम होना चाहते हैं जिन्हें आप शामिल करना चाहते हैं, तो फाइलों composer.jsonको ऑटोलॉगड में निर्दिष्ट क्यों नहीं करें जैसा कि जोसेफ सिला ने लिखा है? आप इस समाधान को क्यों पसंद करते हैं? मैं यह नहीं कह रहा हूं कि यह एक बुरा समाधान है, मैं बस उत्सुक हूं।
composer.jsonकरना दो बिंदुओं को छोड़कर ऐसा करने से बहुत अलग नहीं है - पहला, यह एक मेटाडेटा फ़ाइल के बजाय, एप्लिकेशन के अंदर ही मानचित्र रखता है; दूसरा, आपको composer dump-autoloadहर बार लोड करने के लिए फ़ाइलों की सूची बदलने के लिए आपको फिर से चलाने की आवश्यकता नहीं होती है ।
includeया require, Laravel पहले से ही निर्मित PSR-4 autoloading गया है: php-fig.org/psr/psr-4
मेरे लारावेल प्रोजेक्ट में कस्टम हेल्पर पुस्तकालयों के लिए, मैंने Librariesअपने नाम के साथ एक फ़ोल्डर बनाया हैLaravel/App निर्देशिका और पुस्तकालयों की निर्देशिका के भीतर, मैंने विभिन्न सहायक पुस्तकालयों के लिए विभिन्न फाइलें बनाई हैं।
अपनी हेल्पर फाइलें बनाने के बाद, मैं बस उन सभी फाइलों को अपने कंपोजर.जॉन फाइल में शामिल करता हूं
...
"autoload": {
"classmap": [
"database"
],
"files": [
"app/Libraries/commonFunctions.php"
],
"psr-4": {
"App\\": "app/"
}
},
...और निष्पादित करें
composer dump-autoloadcomposer dump-autoloadऔर composer dumpautoloadकाम करता है इनफैक्ट composer duभी चलेगा ...
चूंकि ओपी ने सर्वोत्तम प्रथाओं के लिए कहा , मुझे लगता है कि हम अभी भी कुछ अच्छी सलाह याद कर रहे हैं।
एक सिंगल हेल्पर्स। एफपी फाइल एक अच्छे अभ्यास से दूर है। सबसे पहले क्योंकि आप विभिन्न प्रकार के कार्यों को मिलाते हैं, इसलिए आप अच्छे कोडिंग सिद्धांतों के खिलाफ हैं। इसके अलावा, यह न केवल कोड प्रलेखन बल्कि साइक्लोमैटिक कॉम्प्लेक्सिटी , मेंटेनेंसबिलिटी इंडेक्स और हैल्स्ट वॉल्यूम जैसे कोड मेट्रिक्स को भी नुकसान पहुंचा सकता है । आपके पास जितने अधिक कार्य हैं उतना ही यह खराब होता है।
कोड प्रलेखन phpDocumentor जैसे उपकरणों का उपयोग करके ठीक होगा , लेकिन सामी के उपयोग से यह प्रक्रियात्मक फ़ाइलों को प्रस्तुत नहीं करेगा । लारवेल एपीआई प्रलेखन एक ऐसा मामला है - कोई सहायक कार्य प्रलेखन नहीं है: https://laravel.com/api/5.4
कोड मेट्रिक्स का विश्लेषण PhpMetrics जैसे टूल से किया जा सकता है । Laravel 5.4 फ्रेमवर्क कोड का विश्लेषण करने के लिए PhpMetrics संस्करण 1.x का उपयोग करना आपको src / Illuminate / Foundation / helpers.php और src / Illuminate / सहायता / सहायता / .php दोनों के लिए बहुत खराब CC / MI / HV मेट्रिक्स देगा। फ़ाइलों ।
एकाधिक संदर्भ सहायक फ़ाइलें (जैसे। String_helpers.php , array_helpers.php , आदि) निश्चित रूप से उन बुरे मेट्रिक्स में सुधार , जिसके परिणामस्वरूप को एक आसान कोड मिलता है। कोड प्रलेखन जनरेटर के आधार पर इसका इस्तेमाल काफी अच्छा होगा।
स्थैतिक विधियों के साथ हेल्पर वर्गों का उपयोग करके इसे और बेहतर बनाया जा सकता है ताकि नामस्थानों का उपयोग करके उन्हें प्रासंगिक बनाया जा सके। ठीक वैसे ही जैसे कि लारवेल पहले से ही किस तरह करते हैं Illuminate\Support\StrऔरIlluminate\Support\Arr कक्षाओं के । इससे कोड मेट्रिक्स / संगठन और प्रलेखन दोनों में सुधार होता है। कक्षा के उपनामों का उपयोग उन्हें आसान बनाने के लिए किया जा सकता था।
कक्षाओं के साथ संरचना करना कोड संगठन और प्रलेखन को बेहतर बनाता है, लेकिन दूसरी ओर हम वैश्विक कार्यों को याद रखने के लिए उन महान लघु और आसान को खो देते हैं। हम उन स्थैतिक वर्गों के तरीकों के लिए फ़ंक्शन उपनाम बनाकर उस दृष्टिकोण को और बेहतर बना सकते हैं। यह या तो मैन्युअल रूप से या गतिशील रूप से किया जा सकता है।
लारवेल आंतरिक रूप से प्रक्रियात्मक सहायक फ़ाइलों में कार्यों की घोषणा करके पहले दृष्टिकोण का उपयोग करते हैं जो स्थैतिक कक्षाओं के तरीकों के लिए मैप करते हैं। यह आदर्श चीज नहीं हो सकती है क्योंकि आपको सभी सामान (डॉकब्लॉक / दलील) को फिर से लिखना है।
मैं व्यक्तिगत रूप से एक HelperServiceProviderवर्ग के साथ एक गतिशील दृष्टिकोण का उपयोग करता हूं जो निष्पादन समय में उन कार्यों को बनाता है:
<?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()
{
//
}
}कोई कह सकता है कि यह इंजीनियरिंग से अधिक है, लेकिन मुझे ऐसा नहीं लगता। यह बहुत अच्छी तरह से काम करता है और इसके विपरीत उम्मीद की जा सकती है कि यह PHP 7.x का उपयोग करते समय कम से कम प्रासंगिक निष्पादन समय खर्च नहीं करता है।
यहाँ एक बैश शेल स्क्रिप्ट है जिसे मैंने लारवेल को बहुत तेज़ी से 5 पहलू बनाने के लिए बनाया है।
इसे अपने Laravel 5 संस्थापन निर्देशिका में चलाएँ।
make_facade.sh -f <facade_name> -n '<namespace_prefix>'उदाहरण:
make_facade.sh -f helper -n 'App\MyApp'यदि आप उस उदाहरण को चलाते हैं, तो यह निर्देशिकाएँ बनाएगा Facadesऔर Providers'your_laravel_installation_dir / app / MyApp' के अंतर्गत आएगा।
./app/MyApp/Facades/Helper.php
./app/MyApp/Facades/HelperFacade.php
./app/MyApp/Providers/HelperServiceProvider.phpऐसा करने के बाद, यह निम्नलिखित के समान संदेश प्रदर्शित करेगा:
===========================
Finished
===========================
Add these lines to config/app.php:
----------------------------------
Providers: App\MyApp\Providers\HelperServiceProvider,
Alias: 'Helper' => 'App\MyApp\Facades\HelperFacade',इसलिए 'config / app.php' में प्रदाताओं और उपनाम सूची को अपडेट करें
Daud composer -o dumpautoload
"./App/MyApp/Facades/Helper.php" मूल रूप से इस तरह दिखेगा:
<?php
namespace App\MyApp\Facades;
class Helper
{
//
}अब बस अपने तरीके को "./app/MyApp/Facades/Helper.php" में जोड़ें।
यहाँ है "" ./app/MyApp/Facades/Helper.php "के बाद ऐसा लगता है जैसे मैंने एक हेल्पर फ़ंक्शन जोड़ा।
<?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) !!}यह फ़ंक्शन एक पैटर्न की उम्मीद करता है और एक वैकल्पिक दूसरा बूलियन तर्क स्वीकार कर सकता है।
यदि वर्तमान URL इसमें दिए गए पैटर्न से मेल खाता है, तो यह 'सक्रिय' (या 'सक्रिय वर्ग' "आउटपुट" करेगा यदि आप फ़ंक्शन कॉल के दूसरे तर्क के रूप में 'सही' जोड़ते हैं)।
मैं इसका उपयोग उस मेनू को हाइलाइट करने के लिए करता हूं जो सक्रिय है।
#!/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 ""अपने कस्टम हेल्पर वर्ग को शामिल करने के बजाय, आप वास्तव में config/app.phpउपनाम के तहत अपनी फ़ाइल में जोड़ सकते हैं ।
इस तरह दिखना चाहिए।
'aliases' => [
...
...
'Helper' => App\Http\Services\Helper::class,
]और फिर अपने नियंत्रक से, हेल्पर को 'हेल्पर का उपयोग करने की विधि' का उपयोग करके शामिल करें ताकि आप बस अपने हेल्पर वर्ग के कुछ तरीकों को कॉल कर सकें।
eg. Helper::some_function();या संसाधनों के मद्देनजर आप सीधे हेल्पर क्लास को पहले ही कॉल कर सकते हैं।
eg. {{Helper::foo()}}लेकिन इसके बाद भी डेवलपर कोडिंग स्टाइल अप्रोच है। हमारे पास समस्याओं को हल करने का अलग तरीका हो सकता है, और मैं सिर्फ वही साझा करना चाहता हूं जो शुरुआती लोगों के लिए है।
कस्टम हेल्पर्स डायरेक्टरी बनाएं : ऐप डायरेक्टरी में सबसे पहले हेल्पर्स डायरेक्टरी बनाएं। हॉल्पर क्लास की परिभाषा बनाएं: आइए अब एक साधारण सहायक फ़ंक्शन बनाएं, जो दो तारों को मिलाएगा । एक नई फ़ाइल बनाएं MyFuncs.php in /app/Helpers/MyFuncs.php निम्नलिखित कोड जोड़ें
<?php
namespace App\Helpers;
class MyFuncs {
public static function full_name($first_name,$last_name) {
return $first_name . ', '. $last_name;
}
}नामस्थान ऐप \ _ सहायकों; App नाम स्थान के तहत हेल्पर्स नेमस्पेस को परिभाषित करता है। वर्ग MyFuncs {…} सहायक वर्ग MyFuncs को परिभाषित करता है। सार्वजनिक स्थैतिक फ़ंक्शन full_name ($ first_name, $ last_name) {…} एक स्थिर फ़ंक्शन को परिभाषित करता है जो दो स्ट्रिंग मापदंडों को स्वीकार करता है और एक संक्षिप्त स्ट्रिंग देता है
सहायक सेवा वर्ग प्रदान करते हैं
सेवा प्रदाताओं का उपयोग ऑटो लोड कक्षाओं के लिए किया जाता है। हमें एक सेवा प्रदाता को परिभाषित करने की आवश्यकता होगी जो हमारे सभी सहायक वर्गों को / ऐप / हेल्पर्स निर्देशिका में लोड करेगा।
निम्नलिखित कारीगर कमांड चलाएँ:
php कारीगर बनाते हैं: प्रदाता HelperServiceProvider
फ़ाइल में बनाया जाएगा /app/Providers/HelperServiceProvider.php
Open /app/Providers/HelperServiceProvider.phpनिम्नलिखित कोड जोड़ें:
<?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);
}
}
}यहाँ,
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.अब हमें हेल्पर सर्विस सर्विस को पंजीकृत करने और अपने सहायकों के लिए एक उपनाम बनाने की आवश्यकता है।
/config/app.phpफ़ाइल खोलें
प्रदाताओं सरणी चर का पता लगाएँ
निम्नलिखित पंक्ति जोड़ें
App\Providers\HelperServiceProvider::class,उपनाम सरणी चर का पता लगाएँ
निम्नलिखित पंक्ति जोड़ें
'MyFuncs' => App\Helpers\MyFuncs::class,हमारे कस्टम सहायक का उपयोग करके परिवर्तन सहेजें
हम एक रूट बनाएंगे जो हमारे कस्टम हेल्पर फंक्शन को Open /app/routes.php कहेगा
निम्न रूट परिभाषा जोड़ें
Route::get('/func', function () {
return MyFuncs::full_name("John","Doe");
});यहाँ,
return MyFuncs::full_name("John","Doe"); calls the static function full_name in MyFuncs classसबसे पहले App \ Http निर्देशिका के अंदर helpers.php बनाएं। फिर कंपोज़र.जॉन के अंदर निम्न कोड जोड़ें
"autoload": {
"classmap": [
"database"
],
"files": [
"app/Http/helpers.php"
],
"psr-4": {
"App\\": "app/"
}
},अगला निम्नलिखित कमांड चलाएँ
composer dump-autoloadअब आप अपने कस्टम फ़ंक्शन को helpers.php फ़ाइल के अंदर परिभाषित कर सकते हैं।
दूसरा तरीका जो मैंने इस्तेमाल किया था: 1) ने app \ FolderName \ fileName.php में एक फ़ाइल बनाई थी और इस कोड को अंदर यानी जैसे
<?php
namespace App\library
{
class hrapplication{
public static function libData(){
return "Data";
}
}
}
?>2) उसके बाद हमारे ब्लेड में
$FmyFunctions = new \App\FolderName\classsName;
echo $is_ok = ($FmyFunctions->libData());बस। और यह काम करता है
कस्टम हेल्प लिखने के लिए बेस्ट प्रैक्टिस है
1) appप्रोजेक्ट रूट की डायरेक्टरी के अंदर , हेल्पर्स (बस कोड को अलग और स्ट्रक्चर करने के लिए) नाम का फोल्डर बनाएं।
2) फ़ोल्डर के अंदर psr-4 फाइलें या सामान्य php फाइलें लिखें
अगर PHP फाइलें psr-4 के प्रारूप में हैं, तो यह ऑटो लोड हो जाएगा, अन्यथा कंपोज़र में निम्नलिखित पंक्ति जोड़ें। जो कि प्रोजेक्ट रूट डायरेक्टरी के अंदर है
autoloadकुंजी के अंदर , filesऑटो लोड के समय फ़ाइलों को लोड करने के लिए नाम की एक नई कुंजी बनाएं , filesऑब्जेक्ट के अंदर ऐप डायरेक्टरी से शुरू होने वाले पथ को जोड़ें। यहां, एक उदाहरण है।
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\\": "app/"
},
"files": [
"app/Helpers/customHelpers.php"
]
},
"autoload-dev": {
"classmap": [
"tests/TestCase.php"
]
},PS: composer dump-autoloadयदि फ़ाइल लोड न हो तो चलाने का प्रयास करें ।
App / Helper / Helpers.php में Helpers.php बनाएं
namespace App\Helper
class Helpers
{
}संगीतकार और संगीतकार अपडेट में जोड़ें
"autoload": {
"classmap": [
"database/seeds",
"database/factories",
"database","app/Helper/Helpers.php"
],
"psr-4": {
"App\\": "app/"
},
"files": ["app/Helper/Helpers.php"]
},नियंत्रक में उपयोग करें
App \ Helper \ Helpers का उपयोग करें
config-> app.php फ़ाइल में दृश्य परिवर्तन का उपयोग करें
'aliases' => [
...
'Helpers' => 'App\Helper\Helpers'
],देखने में
<?php echo Helpers::function_name(); ?>composer.jsonबेकार है, क्योंकि ps-4 ऑटोलैड काम करेगा।
in dir बूटस्ट्रैप \ autoload.php
require __DIR__.'/../vendor/autoload.php';
require __DIR__.'/../app/Helpers/function.php'; //addइस फ़ाइल को जोड़ें
app\Helpers\function.php**
** नया सहायक बनाएँ
<?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;
}
}नियंत्रक और किसी भी दृश्य फ़ाइल के लिए उपयोग करें
use App\Helpers\StatusHelper;
class ExampleController extends Controller
{
public function index()
{
$statusList = StatusHelper::getStatusesList();
return view('example.index', compact('statusList'));
}
}5.3 और ऊपर के लार्वा में, लार्वा टीम ने सभी प्रक्रियात्मक फाइलों ( routes.php) को app/निर्देशिका से बाहर कर दिया , और संपूर्ण app/फ़ोल्डर को psr-4स्वारोलबेड किया गया। स्वीकृत उत्तर इस मामले में काम करेगा लेकिन यह मुझे सही नहीं लगता।
इसलिए मैंने जो किया वह मैंने helpers/अपनी परियोजना के मूल में एक निर्देशिका बनाई और सहायक फाइल को उसके अंदर डाल दिया, और अपनी composer.jsonफ़ाइल में मैंने ऐसा नहीं किया:
...
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\\": "app/"
},
"files": [
"helpers/ui_helpers.php"
]
},
...इस तरह मेरी app/ निर्देशिका अभी भी एक psr-4 ऑटोलॉइड एक है, और सहायकों को थोड़ा बेहतर व्यवस्थित किया गया है।
आशा है कि यह किसी की मदद करता है।
यहाँ कुछ महान जवाब हैं, लेकिन मुझे लगता है कि यह सबसे सरल है। Laravel 5.4 (और प्रोब वर्जन भी) में आप अपने लिए सुविधाजनक कहीं एक क्लास बना सकते हैं, जैसे ऐप / लाइब्रेरी / हेलिकॉप्टर।
class Helper() {
public function uppercasePara($str) {
return '<p>' .strtoupper($str). '<p>;
}
}तो आप बस इसे इस तरह से अपने ब्लेड टेम्पलेट में कॉल कर सकते हैं:
@inject('helper', \App\Libraries\Helper)
{{ $helper->drawTimeSelector() }}यदि आप @inject का उपयोग नहीं करना चाहते हैं, तो बस 'अपरकेसपारा' फ़ंक्शन को स्थिर बनाएं और कॉल को इस तरह से अपने ब्लेड टेम्पलेट में एम्बेड करें:
{{ \App\Libraries\Helper::drawTimeSelector() }}उपनामों की कोई जरूरत नहीं। लारवेल अपने आप कंक्रीट क्लास को हल करता है।