Good Peoples.
I have an issue with my project.
In the layout blade, I need to fetch some data from the database. But I cannot pass variables as there has no route for the layout blade. It's just a master blade.
Is there any way to make a global variable and use it all blade?
Thanks for the valuable replies.
to have global functions or variables there are different ways
in my opinion, the easiest way is:
make a helper php file to restore global functions and vars, in this way you
load this file in composer.json and you can call that everywhere you want.
I created Functions.php in App/Helpers directory to restore my global vars and functions.
after that declare the file in composer.json:
"autoload", inside it if there is not "files(array)" add it and set the path to
your file. in my example, it is "app/Helpers/Functions.php".
"autoload": {
"psr-4": {
"App\\": "app/",
"Database\\Factories\\": "database/factories/",
"Database\\Seeders\\": "database/seeders/"
},
"files": [
"app/Helpers/Functions.php"
]
},
finally, rerun the
php artisan serve
for accessing a variable in your blade, I'm not sure you can do it or not (I tried but it returns undefined variable).
you can do:
// in your helper file
myFunc() {
$myVar = 'value';
return $myVar;
}
// in your blade
{{ myFunc() }}
or using classes:
// in your helper file
class myClass {
protected $myVar = 'value';
protected static $staticVar = 'value';
public myFunc() {
return $this->myVar;
}
public static staticFunc() {
return myClass::$staticVar;
}
}
// in your blade
{{ (new myClass())->myFunc() }}
// of static function
{{ myClass::staticFunc() }}
hope, it helps...
you can use laravel helpers to declare a global variable, you can create your own customize helper function.
you can follow laravel custom helpers and this one to custom create helpers
Create a new Service Provider as suggested in here
Add your new Service Provider to the configuration file (config/app.php).
In the boot method of your new Service Provider use:
View::share( 'something_cool', 'this is a cool shared variable' );
Now you are ready to use $something_cool in all of your views.
Related
I have two controller file homecontroller and backendcontroller. What is the best way to create global function and access it from both files?
I found here Arian Acosta's answer helpful but I wonder if there is an easiest way. I would appreciate any suggestions.
Solution
One way to do this is to create a class and use its instance, this way you can not only access the object of the class within a controller, blade, or any other class as well.
AppHelper file
In you app folder create a folder named Helpers and within it create a file name AppHelper or any of your choice
<?php
namespace App\Helpers;
class AppHelper
{
public function bladeHelper($someValue)
{
return "increment $someValue";
}
public function startQueryLog()
{
\DB::enableQueryLog();
}
public function showQueries()
{
dd(\DB::getQueryLog());
}
public static function instance()
{
return new AppHelper();
}
}
Usage
In a controller
When in a controller you can call the various functions
public function index()
{
//some code
//need to debug query
\App\Helpers\AppHelper::instance()->startQueryLog();
//some code that executes queries
\App\Helpers\AppHelper::instance()->showQueries();
}
In a blade file
Say you were in a blade file, here is how you can call the app blade helper function
some html code
{{ \App\Helpers\AppHelper::instance()->bladeHelper($value) }}
and then some html code
Reduce the overhead of namespace (Optional)
You can also reduce the overhead of call the complete function namespace \App\Helpers by creating alias for the AppHelper class in config\app.php
'aliases' => [
....
'AppHelper' => App\Helpers\AppHelper::class
]
and in your controller or your blade file, you can directly call
\AppHelper::instance()->functioName();
Easy Solution:
Create a new Helpers folder in your app directory.
Create a php file named your_helper_function.php in that Helpers directory.
Add your function(s) inside your_helper_function.php
function your_function($parameters){
//function logic
}
function your_another_function($parameters){
//function logic
}
Add this file to the Files key of your composer.json like
"autoload": {
...
"files": [
"app/Helpers/your_helper_function.php"
]
...
}
Finally, regenerate composer autoload files. (Run this in your project directory)
composer dump-autoload
That's it! and now you can access your_function() or your_another_function() in any part of your Laravel project.
If you still have any confusion, check my blog post on how to do this:
How to Add a Global Function in Laravel Using Composer?
Updated:
Step 1
Add folder inside app folder
app->Helper
Step 2
add php Class inside Helper folder
Eg. Helper.php
Add namespace and class to the Helper.php
namespace App\Helper;
class Helper
{
}
Register this Helper.php into config/app.php file
'aliases' => [
....
'Helper' => App\Helper\Helper::class
]
Now, write all the functions inside Helper.php and it will be accessible everywhere.
How to access from Controller?
Step 1 - Add a namespace at top of the controller.
use App\Helper\Helper;
Step 2 - Call function - Assume there a getInformation() inside the Helper Class.
$information = Helper::getInformation()
In your Controller.php which extends BaseController, you can create a function like;
public function data($arr = false)
{
$data['foo'] = 'bar';
return array_merge($data,$arr);
}
And from any controller when you send a data to a view;
public function example()
{
$data['smthg'] = 'smthgelse';
return view('myView',$this->data($data));
}
The data in the the main controller can be accessed from all controllers and blades.
The Laravel Service Provider way
I've been using global function within Laravel for a while and I want to share how I do it. It's kind of a mix between 2 answers in this post : https://stackoverflow.com/a/44021966/5543999 and https://stackoverflow.com/a/44024328/5543999
This way will load a file within a ServiceProvider and register it within your Laravel app.
Where is the difference, the scope, it's always about the scope.
Composer //Autload whitin composer.json method
|
|--->Laravel App //My method
|
|--->Controller //Trait method
|--->Blade //Trait method
|--->Listener //Trait method
|--->...
This is a really simplist way to explain my point, all three methods will achieve the purpose of the "Global function". The Traits method will need you to declare use App\Helpers\Trait; or App\Helpers\Trait::function().
The composer and service provider are almost about the same. For me, they answer better to the question of what is a global function, because they don't require to declare them on each place you want to use them. You just use them function(). The main difference is how you prefer things.
How to
Create the functions file : App\Functions\GlobalFunctions.php
//App\Functions\GlobalFunctions.php
<?php
function first_function()
{
//function logic
}
function second_function()
{
//function logic
}
Create a ServiceProvider:
//Into the console
php artisan make:provider GlobalFunctionsServiceProvider
Open the new file App\Providers\GlobalFunctionsServiceProvider.php and edit the register method
//App\Providers\GlobalFunctionsServiceProvider.php
public function register()
{
require_once base_path().'/app/Functions/GlobalFunctions.php';
}
Register your provider into App\Config\App.php wihtin the providers
//App\Config\App.php
'providers' => [
/*
* Laravel Framework Service Providers...
*/
Illuminate\Auth\AuthServiceProvider::class,
...
Illuminate\Validation\ValidationServiceProvider::class,
Illuminate\View\ViewServiceProvider::class,
App\Providers\GlobalFunctionsServiceProvider::class, //Add your service provider
Run some artisan's commands
//Into the console
php artisan clear-compiled
php artisan config:cache
Use your new global functions
//Use your function anywhere within your Laravel app
first_function();
second_function();
Laravel uses namespaces by default. So you need to follow the method described in that answer to setup a helper file.
Though in your case you want to access a method in different controllers. For this there's a simpler way. Add a method to you base controller app/Http/Controllers/Controller.php and you can access them in every other controller since they extend it.
// in app/Http/Controllers/Controller.php
protected function dummy()
{
return 'dummy';
}
// in homecontroller
$this->dummy();
There are a few ways, depending on the exact functionality you're trying to add.
1) Create a function inside Controller.php, and make all other controller extend that controller. You could somewhat compair this to the master.blade.php
2) Create a trait, a trait can do a lot for you, and keeping ur controllers clean. I personally love to use traits as it will look clean, keep my Controller.php from being a mess with tons of different lines of code.
Creating a global function
create a Helpers.php file under a folder, let's name it 'core'.
core
|
-- Helpers.php
namespace Helpers; // define Helper scope
if(!function_exists('html')) {
function html($string) {
// run some code
return $str;
}
}
In your composer.json
"autoload": {
"psr-4": {
},
"files": [
"core/Helpers.php"
]
}
in the file that you want to use it
// the " use " statement is not needed, core/Helpers is loaded on every page
if(condition_is_true) {
echo Helpers\html($string);die();
}
Remove the namespace in Helpers.php if you want to call your function without the need to prefix namespace. However I advise to leave it there.
Credit: https://dev.to/kingsconsult/how-to-create-laravel-8-helpers-function-global-function-d8n
By using composer.json and put the function containing file(globalhelper.php) to the autoload > files section, then run
composer dump-autoload
You can access the function inside the file(globalhelper.php) without having to calling the class name, just like using default php function.
This question already has answers here:
How to create custom helper functions in Laravel
(23 answers)
Closed 7 months ago.
I have some helper classes in app/Helpers. How do I load these classes using a service provider to use them in blade templates?
e.g. If I have a class CustomHelper that contains a method fooBar() :
<?php
nampespace App\Helpers;
class CustomHelper
{
static function fooBar()
{
return 'it works!';
}
}
I want to be able to do something like this in my blade templates:
{{ fooBar() }}
instead of doing this:
{{ \App\Helpers\CustomHelper::fooBar() }}
P.S: #andrew-brown's answer in Best practices for custom helpers on Laravel 5 deals with non-class files. It would be nice to have a class based solution so that the helper functions can be organized among classes.
I don't think it's possible to use only function when you have code in your classes. Well, you could try with extending Blade but it's too much.
What you should do is creating one extra file, for example app\Helpers\helpers.php and in your composer.json file put:
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\\": "app/"
},
"files": ["app/Helpers/helpers.php"] // <- this line was added
},
create app/Helpers/helpers.php file and run
composer dump-autoload
Now in your app/Helpers/helpers.php file you could add those custom functions for example like this:
if (! function_exists('fooBar')) {
function fooBar()
{
return \App\Helpers\CustomHelper::fooBar();
}
}
so you define global functions but in fact all of them might use specific public methods from some classes.
By the way this is exactly what Laravel does for its own helpers for example:
if (! function_exists('array_add')) {
function array_add($array, $key, $value)
{
return Arr::add($array, $key, $value);
}
}
as you see array_add is only shorter (or maybe less verbose) way of writing Arr::add
In laravel 4 i just used a function
$varbl = App::make("ControllerName")->FunctionName($params);
to call a controller function from a my balde template(view page).
Now i'm using Laravel 5 to do a new project and i tried this method to call a controller function from my blade template .But its not working and showing some errors.
Is there any method to call a controller function from a view page in Laravel 5?
Just try this in your view :
{{ ControllerName::Functionname($params); }}
OR
<?php echo ControllerName::Functionname($params);?>
Refer this : http://laravel.io/forum/03-06-2014-what-is-the-proper-way-to-call-controllers-from-the-view?page=1
If you have a function which is being used at multiple places you should define it in helpers file, to do so create one (may be) in app/Http/Helpers folder and name it helpers.php, mention this file in the autoload block of your composer.json in following way :
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\\": "app/"
},
"files": [
"app/Http/Helpers/helpers.php"
]
},
run composer dump-autoload, and then you may call this function from anywhere, let it be controller view or model.
or if you don't need to put in the helpers. You can just simply call it from it's controller. Just make it a static function.
Create.
public static function funtion_name($args) {}
Call.
\App\Http\Controllers\ControllerName::function_name($args)
If you don't like the very long code, you can just make it
ControllerName::function_name($args)
but don't forget to call it from the top of the view page.
use \App\Http\Controllers\ControllerName;
In laravel 5, you can do it like so
In your view:
<?php use App\Http\Controllers\ControllerName;
echo ControllerName::functionName(); ?>
The functionName should have the 'static' keyword e.g
Controller function:
public static function functionName() {
return "Hello World!";
}
You can actually call a class, helper class or any declared class in your blade template but putting it in the aliases array of your app.php in the config folder
'Helper' => App\Http\Helpers\Helper::class,
Using the Helper as an alias, you can reference it in your blade template, example below:
{{Helper::formatDateToAgo ($notification->created_at)}}
For accessing a method of a Controller from a view page you need to give the full path of that controller in your blade page.
use App\Http\Controllers\AdminAfterAuth;
$admin_dtls = AdminAfterAuth::globAdmin();
Here AdminAfterAuth is the controller class name and globAdmin is the method name.
Now in your controller declare the method statically.
public static function globAdmin(){
$admin_val = AdminLogin::where('id',session('admin_id'))->get();
return $admin_val;
}
In view call the function like this:
#php
use App\Http\Controllers\ControllerName;
$var = ControllerName::FunctionName();
#endphp
But if the function name in the controller is as:
public function FunctionName(){
return something;
}
Then an error will be shown:
Non-static method App\Http\Controllers\ControllerName::FunctionName() should not be called statically(...)
So to solve this problem "non-static" you have to change your function like this:
public static function FunctionName(){
return something;
}
Then you are all done.
I like and favor Khan Shahrukh way, it is better to create a helpers files with all your functions, then add it to your composer.json file:
"autoload": {
"files": [
"app/Http/Helpers/helpers.php"
]
},
You can select the path that suits you, then dump-autoload composer to make it includes the new file.
For usability and clean work, after that you will be able to invoke your function on any view file OR project parts : Controller, Model.
If you decided to go with the public static method Don't forget to add this line at the very top of your view:
use \App\Http\Controllers\ControllerName;
In my blade view (Laravel), I used below blade syntax (specify full path) to call my controller action.
{{ App\Http\Controllers\mynestedpageController::index() }}
Controllers methods are not supposed to be called from the view. Best options are to call the method from the method which is returning the view object, which contains the output which you then can echo in the view;
public function bar() {
$foo = $this->foo();
return view( 'my.view', compact( 'foo' ) );
}
protected method foo()
{
return 'foobar';
}
second option to add a helpers file to the compose.json file
"autoload": {
"files": [
"app/helpers.php"
]
},
dump your autoload and you can call these functions from anywhere inside your application
Actually below should work as per Laravel 5:
Usage: App::make(ControllerName)->functionName($parameters);
Example: App:make("TestController")->getUserInfo('user_id' => 9);
Please post the actual error you are getting!
This question already has answers here:
How to create custom helper functions in Laravel
(23 answers)
Closed 7 months ago.
If I wanted to make a currentUser() function for some oauth stuff I am doing where I can use it in a view or in a controller (think rails, where you do helper_method: current_user in the application controller).
Everything I read states to create a helpers folder and add the function there and then that way you can do Helpers::functionName Is this the right way to do this?
Whats the "laravel way" of creating helper functions that can be used in blade templates and controllers?
Create a new file in your app/Helpers directory name it AnythingHelper.php
An example of my helper is :
<?php
function getDomesticCities()
{
$result = \App\Package::where('type', '=', 'domestic')
->groupBy('from_city')
->get(['from_city']);
return $result;
}
generate a service provider for your helper by following command
php artisan make:provider HelperServiceProvider
in the register function of your newly generated HelperServiceProvider.php add following code
require_once app_path('Helpers/AnythingHelper.php');
now in your config/app.php load this service provider and you are done
'App\Providers\HelperServiceProvider',
An easy and efficient way of creating a global functions file is to autoload it directly from Composer. The autoload section of composer accepts a files array that is automatically loaded.
Create a functions.php file wherever you like. In this example, we are going to create in inside app/Helpers.
Add your functions, but do not add a class or namespace.
<?php
function global_function_example($str)
{
return 'A Global Function with '. $str;
}
In composer.json inside the autoload section add the following line:
"files": ["app/Helpers/functions.php"]
Example for Laravel 5:
"autoload": {
"classmap": [
"database"
],
"psr-4": {
"App\\": "app/"
},
"files": ["app/Helpers/functions.php"] // <-- Add this line
},
Run composer dump-autoload
Done! You may now access global_function_example('hello world') form any part of your application including Blade views.
Laravel global helpers
Often you will find your self in need of a utility function that is access globally throughout you entire application. Borrowing from how laravel writes their default helpers you're able to extend the ability with your custom functions.
Create the helper file, not class
I prefer to you a file and not a class since I dont want to bother with namespaces and I want its functions to be accessible without the class prefixes like: greeting('Brian'); instead of Helper::greeting('Brian'); just like Laravel does with their helpers.
File: app/Support/helper.php
Register helper file with Composer: composer.json
{
...
"autoload": {
"classmap": [
"database"
],
"files": [
"app/Support/helpers.php"
],
"psr-4": {
"App\\": "app/"
}
},
...
}
Create your first helper function
<?php
if (!function_exists('greet')) {
/**
* Greeting a person
*
* #param string $person Name
* #return string
*/
function greet($person)
{
return 'Hello ' . $person;
}
}
Usage:
Remember to autoload the file before trying to access its functions:
composer dump-autoload
Let's test with Tinker
$ php artisan tinker
Psy Shell v0.8.17 (PHP 7.0.6 ΓÇö cli) by Justin Hileman
>>> greet('Brian');
=> "Hello Brian"
>>> exit
Exit: Goodbye.
With Blade
<p>{{ greet('Brian') }}</p>
Advanced usage as Blade directive:
A times you will find yourself wanting to use a blade directive instead of a plain function.
Register you Blade directive in the boot method of AppServiceProvider: app/Providers/AppServiceProvider.php
public function boot()
{
// ...
Blade::directive('greet', function ($expression) {
return "<?php echo greet({$expression}); ?>";
});
}
Usage:
<p>#greet('Brian')</p>
Note: you might need to clear cache views
php artisan view:clear
The above answers are great with a slight complication, therefore this answer exists.
utils.php
if (!function_exists('printHello')) {
function printHello()
{
return "Hello world!";
}
}
in app/Providers/AppServiceProvider.php add the following in register method
public function register()
{
require_once __DIR__ . "/path/to/utils.php"
}
now printHello function is accessible anywhere in code-base just as any other laravel global functions.
Another option, if you don't want to register all your helper functions one by one and wondering how to register them each time you create a new helper function:
Again in the app/Providers/AppServiceProvider.php add the following in register method
public function register()
{
foreach (glob(app_path().'/Helpers/*.php') as $filename) {
require_once($filename);
}
}
i have some custom function and i'm trying to use that into project, for example:
function makeText($str1, $str2){
return $str1 . ' '. $str2;
}
and i want to use this function in view such as :
<div style='float:left;'>MakeText : {{makeText("Hello","World");}}</div>
makeText is only sample function, witch folder must be put functions method such as UF.php containes all functions and how to define this file to laravel and use it?
You could follow Laravel’s conventions and create a helpers.php file in your app directory. Be sure to auto-load it with Composer though:
"autoload": {
"classmap": [
//
],
"files": [
"app/helpers.php"
]
},
You can then use the function any where in your application, including views.
Laravel gives you a few options. You can include your function definition inside of any of the files that get automatically included and achieve the result you want, such as /app/start/global.php, /bootstrap/start.php, /app/routes.php or many others. The problem with this approach is that, depending on the name of your function, there is a non-negligible likelihood that the name might conflict with one that is already taken (or may get taken later). Also, if you ever need to debug this function you will need to be able to find it later.
You can get around this issue by placing your function inside of a class, and then call that class a service. You can then inject that class into your controller via dependency injection and then pass that data to your view:
class MyService
{
public function makeText($param1, $param2)
{
return $param1 . ' ' . $param2;
}
}
class AController extends BaseController
{
public function __construct(MyService $serv)
{
$this->serv = $serv;
}
public function aRoute()
{
return View::make('some.view')
->with('serv', $this->serv);
}
}
And then in your view:
<div style='float:left;'>MakeText : {{ $serv->makeText("Hello","World"); }}</div>
This will help you prevent naming collisions because you can easily place MyService into any namespace that makes sense. It will also help you keep your code organized better.
Something this simple will probably not require a service provider, but as you add complexity to your project it would be an easy step to do once you need to.