Mi pensamiento inicial fue el compositor autoload también, pero no me pareció muy Laravel 5ish. L5 hace un uso intensivo de los proveedores de servicios, son los que bootstraps su aplicación.

Para empezar he creado una carpeta en mi directorio app llamada Helpers. Luego, dentro de la carpeta Helpers agregué archivos para las funciones que quería agregar. Tener una carpeta con varios archivos nos permite evitar un archivo grande que se vuelve demasiado largo e inmanejable.

Luego creé un HelperServiceProvider.php ejecutando el comando artesano:

artisan make:provider HelperServiceProvider

Dentro del método register agregué este fragmento

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

Por último, registre el proveedor de servicios en su config/app.php en la matriz de proveedores

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

Ahora cualquier archivo en su directorio Helpers está cargado y listo para usar.

ACTUALIZACIÓN 2016-02-22

Hay muchas buenas opciones aquí, pero si mi respuesta funciona para ti, seguí adelante e hice un paquete para incluir ayudantes de esta manera. Puede utilizar el paquete para inspiración o siéntase libre de descargarlo con Composer también. Tiene algunos ayudantes incorporados que uso a menudo (pero que están inactivos por defecto) y le permite hacer sus propios ayudantes personalizados con un simple generador Artesanal. También aborda la sugerencia que un respondedor tenía de usar un mapeador y le permite definir explícitamente los ayudantes personalizados para cargar, o por defecto, cargar automáticamente todos los archivos PHP en su directorio de ayudantes. Retroalimentación y PRs son mucho apreciada!

composer require browner12/helpers

Github: browner12 / helpers

Clases personalizadas en Laravel 5, la Manera Fácil

Esta respuesta es aplicable a general clases personalizadas dentro de Laravel. Para obtener una respuesta más específica de la hoja, consulte Directivas de Cuchillas Personalizadas en Laravel 5.

Paso 1: Crea tu archivo Helpers (u otra clase personalizada) y dale un espacio de nombres que coincida. Escribe tu clase y método:

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

namespace App\Helpers;

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

Paso 2: Crea un alias:

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

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

Paso 3: Úsalo en tu Hoja plantilla:

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

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

Crédito extra: Utilice esta clase en cualquier lugar de su aplicación 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!!');
    }
    ...

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

¿por Qué funciona: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

Donde se origina la carga automática: http://php.net/manual/en/language.oop5.autoload.php

Esto es lo que sugiere JeffreyWay en esta Discusión de Laracasts.

1. Dentro de su directorio app/Http, cree un archivo helpers.php y agregue sus funciones.
2. Dentro de composer.json, en el bloque autoload, añádase "files": ["app/Http/helpers.php"].
3. Ejecutar composer dump-autoload.

Después de haber tamizado a través de una variedad de respuestas en SO y Google, todavía no pude encontrar un enfoque óptimo. La mayoría de las respuestas sugieren que dejemos la aplicación y dependamos de 3rd party tool Composer para hacer el trabajo, pero no estoy convencido de que el acoplamiento a una herramienta solo para incluir un archivo sea prudente.

La respuesta de Andrew Brown fue la más cercana a cómo creo que se debe abordar, pero (al menos en 5.1), el paso del proveedor de servicios es innecesario. La respuesta de Heisian destaca el uso de PSR-4 lo que nos acerca un paso más. Aquí está mi implementación final para ayudantes en vistas:

Primero, cree un archivo de ayuda en cualquier lugar del directorio de aplicaciones, con un espacio de nombres:

namespace App\Helpers;

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

Después, alias tu clase en config\app.php, en el array aliases:

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

Y eso debería ser todo lo que necesitas hacer. PSR-4 y el alias debería exponer el helper a tus vistas, así que en tu vista, si escribes:

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

Debería generar:

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

Directivas de Hoja personalizada en Laravel 5

Sí, hay otra manera de hacer esto!

Paso 1: Registrar una directiva de hoja personalizada:

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

Paso 2: Utilice su directiva de hoja personalizada:

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

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

Salidas:

ESTA ES MI DIRECTIVA DE HOJA PERSONALIZADA!!
Enlace Personalizado

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

Lectura Adicional: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives

Si desea aprender cómo hacer mejores clases personalizadas que pueda usar en cualquier lugar, consulte Clases personalizadas en Laravel 5, de la Manera fácil

Este es mi HelpersProvider.archivo 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;
            }
        }
    }
}

Debe crear una carpeta llamada Helpers bajo la carpeta app, luego cree un archivo llamado whatever.php dentro y agregue la cadena whatever dentro de la matriz help helpers.

Hecho!

Editar

Ya no estoy usando esta opción, actualmente estoy usando composer para cargar archivos estáticos como helpers.

Puede agregar los ayudantes directamente en:

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

Para las Bibliotecas de Ayuda Personalizadas en mi proyecto Laravel, he creado una carpeta con el nombre Libraries en mi Directorio Laravel/App y dentro del directorio de Bibliotecas, he creado varios archivos para diferentes bibliotecas de ayuda.

Después de crear mis archivos de ayuda, simplemente incluyo todos esos archivos en mi composer.json archivo como este

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

Y ejecutar

composer dumpautoload

En lugar de incluir su clase helper personalizada, puede agregar a su archivo config/app.php bajo alias.

Debería verse así.

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

Y luego a su Controlador, incluya el Helper usando el método 'use Helper' para que simplemente pueda llamar a algunos de los métodos de su clase Helper.

eg. Helper::some_function();

O en la vista recursos ya puede llamar directamente a la clase Helper.

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

Pero este sigue siendo el enfoque de estilo de codificación para desarrolladores a seguir. Podemos tener diferente manera de resolver problemas, y solo quiero compartir lo que tengo también para principiantes.

Desde que OP pidió las mejores prácticas, creo que todavía nos faltan algunos buenos consejos aquí.

Un único ayudantes.el archivo php está lejos de ser una buena práctica. En primer lugar porque usted mezcla un montón de diferentes tipos de funciones, por lo que está en contra de los principios de codificación buena. Además, esto podría dañar no solo la documentación del código, sino también las métricas de código como Complejidad ciclomática, Índice de Mantenibilidad y Volumen de Halstead. El más funciones que tiene más se pone peor.

La documentación de código estaría bien usando herramientas como phpDocumentor, pero usando Sami it no renderizará archivos de procedimiento. La documentación de la API de Laravel es tal caso - no hay documentación de funciones auxiliares: https://laravel.com/api/5.4

Las métricas de código se pueden analizar con herramientas como PhpMetrics. Usando PhpMetrics versión 1.x para analizar el código de marco Laravel 5.4 le dará muy mal Métricas CC/MI/HV para ambos src / Illuminate / Foundation / helpers.php y src / Illuminate / Support / helpers.php archivos.

Múltiples archivos de ayuda contextuales (por ejemplo. string_helpers.php, array_helpers.php , etc.) sin duda mejoraría esas malas métricas que resultan en un código más fácil de mantener. Dependiendo del generador de documentación de código utilizado, esto sería lo suficientemente bueno.

Se puede mejorar aún más mediante el uso de clases auxiliares con métodos estáticos para que puedan contextualizarse mediante espacios de nombres. Justo como Laravel ya lo hace con Illuminate\Support\Str y Illuminate\Support\Arr clases. Esto mejora tanto las métricas/organización del código como la documentación. Se podrían usar alias de clase para hacerlos más fáciles de usar.

Estructurar con clases hace que la organización del código y la documentación sean mejores, pero por otro lado terminamos perdiendo esas excelentes funciones globales cortas y fáciles de recordar. Podemos mejorar aún más ese enfoque: crear alias de función para esos métodos de clases estáticas. Esto se puede hacer de forma manual o dinámica.

Laravel utiliza internamente el primer enfoque declarando funciones en los archivos auxiliares de procedimiento que se asignan a los métodos de clases estáticas. Esto podría no ser lo ideal, ya que necesita volver a declarar todas las cosas (docblocks/argumentos).
Yo personalmente uso un enfoque dinámico con una clase HelperServiceProvider que crea esas funciones en el tiempo de ejecución:

<?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()
    {
        //
    }
}

Uno puede decir esto es sobre ingeniería, pero no lo creo. Funciona bastante bien y contrariamente a lo que podría esperarse, no cuesta un tiempo de ejecución relevante al menos cuando se usa PHP 7.x.

Aquí hay un script de shell bash que creé para hacer Laravel 5 fachadas muy rápidamente.

Ejecute esto en su directorio de instalación Laravel 5.

Llámalo así: {[15]]}

make_facade.sh -f <facade_name> -n '<namespace_prefix>'

Ejemplo:

make_facade.sh -f helper -n 'App\MyApp'

Si ejecuta ese ejemplo, creará los directorios Facades y Providers bajo 'your_laravel_installation_dir/app/MyApp'.

Creará los siguientes 3 archivos y también los enviará a la pantalla:

./app/MyApp/Facades/Helper.php
./app/MyApp/Facades/HelperFacade.php
./app/MyApp/Providers/HelperServiceProvider.php

Después de que se hace, se mostrará un mensaje similar al siguiente:

===========================
    Finished
===========================

Add these lines to config/app.php:
----------------------------------
Providers: App\MyApp\Providers\HelperServiceProvider,
Alias: 'Helper' => 'App\MyApp\Facades\HelperFacade',

Así que actualice la lista de proveedores y alias en 'config/app.php "

Corre composer -o dumpautoload

El "./app/MyApp/Facades / Helper.php " se verá originalmente así:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Ahora simplemente agregue sus métodos en "./app/MyApp/Facades / Helper.php".

Aquí está lo que "./app/MyApp/Facades / Helper.php " parece después de que agregué una función Auxiliar.

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

Esta función espera un patrón y puede aceptar un segundo booleano opcional argumento.

Si la URL actual coincide con el patrón que se le ha pasado, mostrará 'active' (o 'class="active"' si agrega 'true' como segundo argumento a la llamada a la función).

Lo uso para resaltar el menú que está activo.

A continuación se muestra el código fuente de mi script. Espero que lo encuentre útil y por favor hágamelo saber si tiene algún problema con él.

#!/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 ""

Crear directorio de ayudantes personalizados: Primero crea el directorio Helpers en app directory. Crear definición de clase hlper: Ahora vamos a crear una función auxiliar simple que concatenar dos cadenas. Crear un nuevo archivo MyFuncs.php en / app/Helpers / MyFuncs.php Agrega el siguiente código

<?php

namespace App\Helpers;

class MyFuncs {

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

Namespace App\Helpers; define el espacio de nombres Helpers bajo App namespace. la clase MyFuncs {}} define la clase auxiliar MyFuncs. función estática pública full_name($nombre,$apellido) {...} define una función estática que acepta dos parámetros de cadena y devuelve una cadena concatenada

Helpers service provide class

Los proveedores de servicios se utilizan para las clases de carga automática. Necesitaremos definir un proveedor de servicios que cargará todas nuestras clases de ayuda en el directorio/app / Helpers.

Ejecute el siguiente comando artisan:

Php artisan make: provider HelperServiceProvider{[15]]}

El archivo se creará en /app/Providers/HelperServiceProvider.php

Open /app/Providers/HelperServiceProvider.php

Añádase el siguiente código:

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

AQUÍ,

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.

Ahora necesitamos registrar el HelperServiceProvider y crear un alias para nuestros helpers.

Abrir /config/app.php archivo

Localice la variable matriz de proveedores

Añádase la siguiente línea

App\Providers\HelperServiceProvider::class,

Localice la variable array de alias

Añádase la siguiente línea

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

Guarde los cambios Usando nuestro ayudante personalizado

Vamos a crear una ruta que llame a nuestra función auxiliar personalizada Open / app / routes.php

Añadir la siguiente definición de ruta

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

AQUÍ,

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

Otra forma que usé fue: 1) creó un archivo en app \ FolderName\fileName.php y tenía este código dentro es decir,

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

2) Después de eso en nuestra espada

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

Eso es todo. y funciona

La mejor práctica para escribir ayudantes personalizados es

1) Dentro del directorio app de la raíz del proyecto, cree una carpeta llamada Helpers (Solo para separar y estructurar el código).

2) Dentro de la carpeta escriba archivos psr-4 o archivos php normales

Si los archivos PHP están en el formato psr-4, entonces se cargará automáticamente, de lo contrario agregue la siguiente línea en el editor.json que está dentro del directorio raíz del proyecto

Dentro de la clave autoload, cree una nueva clave llamada files para cargar archivos en el momento de la carga automática, dentro del objeto files agregue la ruta que comienza desde el directorio de la aplicación. he aquí un ejemplo.

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

PD : intente ejecutar composer dump-autoload si el archivo no se carga.

En dir bootstrap\autoload.php

require __DIR__.'/../vendor/autoload.php';
require __DIR__.'/../app/Helpers/function.php'; //add

Añadir este archivo

app\Helpers\function.php

Primero crea ayudantes.php dentro del directorio App \ Http. Luego agregue el siguiente código dentro del compositor.json

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

A continuación ejecute el siguiente comando

composer dump-autoload

Ahora puede definir su función personalizada dentro de los helpers.archivo php. Aquí puede obtener la guía completa

¡No estoy de acuerdo con ninguna otra respuesta a esta pregunta!

En primer lugar, no hay nada de malo en tener algunas funciones auxiliares globales. A modo de ejemplo, la aplicación en la que estoy trabajando actualmente tiene cinco años (¡comenzó en Laravel 3!) y tiene un total de solo seis funciones globales que se usan con frecuencia para formatear fechas y depurar propósitos. No hay choques con ninguna otra función en el espacio de nombres global y, en su núcleo, son no orientado a objetos, entonces, ¿por qué convertirlos en métodos estáticos en una clase contenedor? Una cosa que creo que es peor que confiar demasiado en funciones antiguas es empaquetarlas como clases y engañarte a ti mismo pensando que ahora estás haciendo las cosas De la Manera Correcta. Además, tener que prefijar estas funciones auxiliares con un nombre de clase o alias de clase es terriblemente doloroso, de ahí mi preferencia por mantenerlas como simples funciones globales.

En segundo lugar, si queremos hablar de código pureza, no debemos considerar una solución que deje caer un archivo helpers.php en cualquier lugar del área app/, ya que la carpeta app/ está destinada a ser solo para clases PSR-4.

Además, creo que muchas de las respuestas son demasiado complicadas. Crear nuevas clases de proveedor solo para cargar automáticamente un montón de otro código cuando ya hay un lugar perfecto para cargar automáticamente el código es una tontería.

Solo noté una respuesta que consideraba modificar bootstrap/autoload.php, que, en mi opinión, es absolutamente la más lugar apropiado para enganchar. No hay ninguna regla, escrita o no, que diga que no debemos cambiar este archivo. Claro, necesita verificar si cambia de una versión de Laravel a la siguiente, pero lo mismo ocurre con los archivos de configuración, las clases de proveedores, las cosas de cola, etc.

Por lo tanto, creo que la solución más simple y apropiada es crear un archivo en la carpeta bootstrap llamada helpers.php y agregar la siguiente línea al final de boostrap/autoload.php:

require __DIR__.'/helpers.php';

Esa otra respuesta que sugería cambiar autoload.phpfue casi la respuesta perfecta (IMO), excepto que sugirieron poner function.php en la carpeta app/Helpers. Como se mencionó anteriormente, la carpeta app/ está destinada a ser para clases PSR-4, por lo que no es el mejor lugar para lanzar un archivo con un montón de funciones auxiliares.

Crear Ayudantes.php en app / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Añadir en composer y composer update

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

uso en el controlador

use App\Helper\Helpers

uso a la vista cambiar en config- > app.archivo php

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

Llamada a la vista

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

En laravel 5.3 y superior, el equipo de laravel movió todos los archivos de procedimiento (routes.php) fuera del directorio app/, y toda la carpeta app/ se carga automáticamente psr-4. La respuesta aceptada funcionará en este caso, pero no se siente bien para mí.

Así que lo que hice fue crear un directorio helpers/ en la raíz de mi proyecto y poner los archivos de ayuda dentro de eso, y en mi archivo composer.json hice esto:

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

De esta manera mi app/ directorio sigue siendo un psr-4 autoloaded uno, y los ayudantes son un un poco mejor organizado.

Espero que esto ayude a alguien.

Hay algunas grandes respuestas aquí, pero creo que esta es la más simple. En Laravel 5.4 (y prob versiones anteriores también) puede crear una clase en algún lugar conveniente para usted, por ejemplo, App/Libraries/Helper.php

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

Entonces simplemente puede llamarlo en su plantilla de Hoja de esta manera:

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

Si no desea utilizar @inject, simplemente haga que el' uppercasePara ' funcione como estático e incruste la llamada en su plantilla de Blade de la siguiente manera:

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

No hay necesidad de alias. Laravel resuelve la clase concreta automáticamente.