Me gustaría crear funciones auxiliares para evitar repetir el código entre vistas en Laravel 5:

view.blade.php

<p>Foo Formated text: {{ fooFormatText($text) }}</p>

Básicamente son funciones de formato de texto. ¿Dónde y cómo puedo crear un archivo con estas funciones?

Cree un helpers.phparchivo en la carpeta de su aplicación y cárguelo con el compositor:

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

Después de agregar eso a su composer.jsonarchivo, ejecute el siguiente comando:

composer dump-autoload

Si no le gusta mantener su helpers.phparchivo en su appdirectorio (porque no es un archivo de clase con espacio de nombres PSR-4), puede hacer lo que hace el laravel.comsitio web: almacenarlo helpers.php en el directorio de arranque . Recuerde configurarlo en su composer.jsonarchivo:

"files": [
    "bootstrap/helpers.php"
]

Clases personalizadas en Laravel 5, la manera fácil

Esta respuesta es aplicable a las clases personalizadas generales dentro de Laravel. Para obtener una respuesta más específica de Blade, consulte Directivas de Blade personalizadas en Laravel 5 .

Paso 1: cree su archivo Helpers (u otra clase personalizada) y asígnele un espacio de nombres coincidente. 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: ejecutar composer dump-autoloaden la raíz del proyecto

Paso 4: Úselo en su plantilla Blade:

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

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

Crédito adicional: use 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

De dónde se origina la carga automática: http://php.net/manual/en/language.oop5.autoload.php

mi pensamiento inicial fue la carga automática del compositor también, pero no me pareció muy Laravel 5ish. L5 hace un uso intensivo de los proveedores de servicios, que son los que inician su aplicación.

Para comenzar, creé una carpeta en mi appdirectorio llamada Helpers. Luego, dentro de la Helperscarpeta, 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.phpejecutando el comando artesanal:

artisan make:provider HelperServiceProvider

Dentro del registermétodo 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.phpen la matriz de proveedores

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

ahora cualquier archivo en su Helpersdirectorio está cargado y listo para usar.

ACTUALIZACIÓN 2016-02-22

Aquí hay muchas buenas opciones, pero si mi respuesta funciona para usted, seguí adelante e hice un paquete para incluir ayudantes de esta manera. Puede utilizar el paquete como inspiración o descargarlo también con Composer. Tiene algunos ayudantes integrados que uso a menudo (pero que están inactivos por defecto) y le permite crear sus propios ayudantes personalizados con un simple generador Artisan. También aborda la sugerencia que tenía un respondedor 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 auxiliar. Comentarios y relaciones públicas son muy apreciados!

composer require browner12/helpers

Github: browner12 / helpers

Esto es lo que sugiere JeffreyWayesta Discusión de Laracasts .

1. Dentro de su app/Httpdirectorio, cree un helpers.phparchivo y agregue sus funciones.
2. Dentro composer.json, en el autoloadbloque, agregue "files": ["app/Http/helpers.php"].
3. Ejecutar composer dump-autoload.

Habiendo examinado una variedad de respuestas en SO y Google, todavía no pude encontrar un enfoque óptimo. La mayoría de las respuestas sugieren que abandonemos la aplicación y confiemos en la herramienta de terceros Composer para hacer el trabajo, pero no estoy convencido de que sea conveniente acoplar una herramienta solo para incluir un archivo.

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

Primero, cree un archivo auxiliar en cualquier lugar de su directorio de aplicaciones, con un espacio de nombres:

namespace App\Helpers;

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

A continuación, alias su clase en config\app.php, en la aliasesmatriz:

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

Y eso debería ser todo lo que necesitas hacer. PSR-4y el alias debe exponer el ayudante a sus vistas, por lo que en su vista, si escribe:

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

Debería generar:

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

Directivas de cuchillas personalizadas en Laravel 5

¡Sí, hay otra forma de hacer esto!

Paso 1: Registre una directiva Blade 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: usa tu directiva Blade personalizada:

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

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

Salidas:

¡ESTA ES MI DIRECTIVA DE CUCHILLA 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 crear clases personalizadas que pueda usar en cualquier lugar , consulte Clases personalizadas en Laravel 5, la manera fácil

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

Debe crear una carpeta llamada Helpersdebajo de la appcarpeta, luego crear un archivo llamado whatever.phpdentro y agregar la cadena whateverdentro de la matriz $ helpers.

¡Hecho!

Editar

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

Puede agregar los ayudantes directamente en:

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

Para las bibliotecas auxiliares personalizadas en mi proyecto Laravel, he creado una carpeta con nombre Librariesen mi Laravel/Appdirectorio y dentro del directorio de bibliotecas, he creado varios archivos para diferentes bibliotecas auxiliares.

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

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

y ejecutar

composer dump-autoload

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

Un solo archivo helpers.php está lejos de ser una buena práctica. En primer lugar, porque mezclas muchos tipos diferentes de funciones, por lo que estás en contra de los buenos principios de codificación. Además, esto podría dañar no solo la documentación del código, sino también las métricas del código como la Complejidad Ciclomática , el Índice de Mantenibilidad y el Volumen de Halstead . Cuantas más funciones tenga, más empeorará.

Documentación de código no estaría mal uso de herramientas como phpDocumentor , pero utilizando Sami que no va a hacer que los ficheros de procedimiento . La documentación de Laravel API es un caso así: 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 . El uso de PhpMetrics versión 1.x para analizar el código marco de Laravel 5.4 le dará muy malas métricas CC / MI / HV para src / Illuminate / Foundation / helpers.php y src / Illuminate / Support / helpers.php archivos .

Múltiples archivos auxiliares contextuales (por ejemplo , string_helpers.php , array_helpers.php , etc.) ciertamente mejorarían esas métricas malas, lo que resultaría 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 utilizando espacios de nombres. Al igual que Laravel ya lo hace con Illuminate\Support\Stry las Illuminate\Support\Arrclases. Esto mejora tanto la métrica / organización del código como la documentación. Los alias de clase podrían usarse para hacerlos más fáciles de usar.

La estructuración con clases mejora la organización y la documentación del código, pero, por otro lado, terminamos perdiendo esas funciones globales breves y fáciles de recordar. Podemos mejorar aún más ese enfoque creando alias de función para esos métodos de clases estáticas. Esto se puede hacer de forma manual o dinámica.

Laravel usa 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 (bloques de documentos / argumentos).
Personalmente uso un enfoque dinámico con una HelperServiceProviderclase 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()
    {
        //
    }
}

Se puede decir que esto se debe a la ingeniería, pero no lo creo. Funciona bastante bien y, al contrario de lo que cabría esperar, 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 las fachadas de Laravel 5 muy rápidamente.

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

Llámalo así:

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 Facadesy Providersdebajo de '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

Una vez hecho esto, 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',

Actualice la lista de proveedores y alias en 'config / app.php'

correr composer -o dumpautoload

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

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

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

Así es como se ve "./app/MyApp/Facades/Helper.php" después de agregar una función de ayuda.

<?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 argumento booleano opcional.

Si la URL actual coincide con el patrón que se le pasó, generará '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 avíseme si tiene algún problema.

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

en lugar de incluir su clase auxiliar personalizada, en realidad puede agregar a su config/app.phparchivo con 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 en su clase Helper.

eg. Helper::some_function();

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

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

Pero este sigue siendo el enfoque de estilo de codificación de desarrollador a seguir. Es posible que tengamos una forma diferente de resolver problemas, y solo quiero compartir lo que tengo también para principiantes.

Crear directorio de ayudantes personalizado: Primero cree el directorio de ayudantes en el directorio de la aplicación. Crear definición de clase hlper: ahora creemos una función auxiliar simple que concatene dos cadenas. Cree un nuevo archivo MyFuncs.php en /app/Helpers/MyFuncs.php Agregue el siguiente código

<?php

namespace App\Helpers;

class MyFuncs {

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

App de espacio de nombres \ Helpers; define el espacio de nombres Helpers en el espacio de nombres de la aplicación. La clase MyFuncs {…} define la clase auxiliar MyFuncs. public static function full_name ($ first_name, $ last_name) {…} define una función estática que acepta dos parámetros de cadena y devuelve una cadena concatenada

El servicio de ayuda proporciona clase

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

Ejecute el siguiente comando artesanal:

php artisan make: proveedor HelperServiceProvider

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

Open /app/Providers/HelperServiceProvider.php

Agregue 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 ayudantes.

Abrir /config/app.phparchivo

Localice la variable de matriz de proveedores

Agregue la siguiente línea

App\Providers\HelperServiceProvider::class,

Localice la variable de matriz de alias

Agregue la siguiente línea

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

Guarde los cambios con nuestro ayudante personalizado

Crearemos una ruta que llamará a nuestra función auxiliar personalizada Abrir /app/routes.php

Agregue 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

Primero cree helpers.php dentro del directorio App \ Http. Luego agregue el siguiente código dentro del composer.json

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

Luego ejecute el siguiente comando

composer dump-autoload

Ahora puede definir su función personalizada dentro del archivo helpers.php.

Otra forma que utilicé 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 cuchilla

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

Eso es. y funciona

La mejor práctica para escribir ayudantes personalizados es

1) Dentro del appdirectorio 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 tienen el formato psr-4, se cargarán automáticamente; de ​​lo contrario, agregue la siguiente línea en composer.json, que se encuentra dentro del directorio raíz del proyecto.

Dentro de la autoloadclave, cree una nueva clave llamada filespara cargar archivos en el momento de la carga automática, dentro del filesobjeto agregue la ruta a partir del directorio de la aplicación. Aquí hay 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-autoloadsi el archivo no se carga.

Cree Helpers.php en la aplicación / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Agregar compositor y actualización de compositor

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

utilizar en controlador

use App \ Helper \ Helpers

usar en vista cambiar en el archivo config-> app.php

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

llamar a la vista

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

en dir bootstrap \ autoload.php

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

agrega este archivo

app\Helpers\function.php

** **

• Ayudante de estado

** crear nuevo ayudante

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

Úselo para el controlador y cualquier archivo de vista

use App\Helpers\StatusHelper;

class ExampleController extends Controller
{
        public function index()
        {
            $statusList = StatusHelper::getStatusesList();

            return view('example.index', compact('statusList'));
        }
}

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

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

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

De esta manera, mi app/directorio sigue siendo uno con carga automática de psr-4, y los ayudantes están un poco mejor organizados.

Espero que esto ayude a alguien.

Aquí hay algunas respuestas geniales, pero creo que esta es la más simple. En Laravel 5.4 (y probablemente también en versiones anteriores) 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>;
    }
}

Luego, simplemente puede llamarlo en su plantilla Blade de esta manera:

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

Si no desea utilizar @inject, simplemente haga que la función 'uppercasePara' sea estática e inserte la llamada en su plantilla Blade de esta manera:

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

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