Gostaria de criar funções auxiliares para evitar a repetição de código entre visualizações no Laravel 5:

view.blade.php

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

Eles são basicamente funções de formatação de texto. Onde e como posso criar um arquivo com essas funções?

Crie um helpers.phparquivo na pasta do aplicativo e carregue-o com o compositor:

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

Depois de adicionar isso ao seu composer.jsonarquivo, execute o seguinte comando:

composer dump-autoload

Se você não gosta de manter o helpers.phparquivo no appdiretório (porque não é um arquivo de classe com espaço para nome PSR-4), faça o que o laravel.comsite faz: armazene-o helpers.php no diretório de inicialização . Lembre-se de configurá-lo em seu composer.jsonarquivo:

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

Aulas personalizadas no Laravel 5, o caminho mais fácil

Esta resposta é aplicável a classes personalizadas gerais no Laravel. Para obter uma resposta mais específica do Blade, consulte Diretivas personalizadas do Blade no Laravel 5 .

Etapa 1: Crie seu arquivo Helpers (ou outra classe personalizada) e forneça um espaço para nome correspondente. Escreva sua classe e método:

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

namespace App\Helpers;

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

Etapa 2: Crie um alias:

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

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

Etapa 3: executar composer dump-autoloadna raiz do projeto

Etapa 4: use-o no seu modelo Blade:

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

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

Crédito extra: use essa classe em qualquer lugar do seu aplicativo 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!!');
    }
    ...

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

Por que funciona: https://github.com/laravel/framework/blob/master/src/Illuminate/Support/ClassLoader.php

De onde se origina o carregamento automático: http://php.net/manual/en/language.oop5.autoload.php

meu pensamento inicial também era o carregamento automático do compositor, mas não parecia muito o Laravel para mim. O L5 faz uso pesado de provedores de serviços, eles são o que inicializa seu aplicativo.

Para começar, criei uma pasta no meu appdiretório chamada Helpers. Depois, na Helperspasta, adicionei arquivos para as funções que desejava adicionar. Ter uma pasta com vários arquivos nos permite evitar um arquivo grande que fica muito longo e incontrolável.

Em seguida, criei um HelperServiceProvider.phpexecutando o comando artisan:

artisan make:provider HelperServiceProvider

Dentro do registermétodo, adicionei esse trecho

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

Por fim, registre o provedor de serviços no seu config/app.phparray de provedores

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

agora qualquer arquivo em seu Helpersdiretório está carregado e pronto para uso.

ATUALIZAÇÃO 22-02-2016

Existem muitas opções boas aqui, mas se minha resposta funcionar para você, fui em frente e fiz um pacote para incluir ajudantes dessa maneira. Você pode usar o pacote como inspiração ou sinta-se à vontade para fazer o download com o Composer. Ele tem alguns auxiliares internos que eu uso frequentemente (mas que estão todos inativos por padrão) e permite que você crie seus próprios auxiliares personalizados com um simples gerador Artisan. Ele também aborda a sugestão que um respondente teve de usar um mapeador e permite definir explicitamente os auxiliares personalizados para carregar ou, por padrão, carregar automaticamente todos os arquivos PHP no diretório auxiliar. Feedback e PRs são muito apreciados!

composer require browner12/helpers

Github: browner12 / ajudantes

Isto é o que é sugerido JeffreyWaynesta discussão em Laracasts .

1. Dentro do seu app/Httpdiretório, crie um helpers.phparquivo e adicione suas funções.
2. Dentro composer.json, noautoload bloco, adicione "files": ["app/Http/helpers.php"].
3. Corra composer dump-autoload.

Tendo vasculhado uma variedade de respostas no SO e no Google, ainda não consegui encontrar uma abordagem ideal. A maioria das respostas sugere que deixemos o aplicativo e confiamos no Composer de ferramentas de terceiros para fazer o trabalho, mas não estou convencido de que o acoplamento a uma ferramenta apenas para incluir um arquivo seja sensato.

A resposta de Andrew Brown chegou mais perto de como eu acho que deveria ser abordada, mas (pelo menos na versão 5.1), a etapa do provedor de serviços é desnecessária. A resposta de Heisian destaca o uso PSR-4que nos aproxima um passo. Aqui está minha implementação final para os auxiliares nas visualizações:

Primeiro, crie um arquivo auxiliar em qualquer lugar do diretório de aplicativos, com um espaço para nome:

namespace App\Helpers;

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

Em seguida, alias sua classe em config\app.php, na aliasesmatriz:

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

E isso deve ser tudo o que você precisa fazer. PSR-4e o alias deve expor o auxiliar às suas visualizações, portanto, na sua visualização, se você digitar:

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

Deve produzir:

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

Diretivas personalizadas de lâminas no Laravel 5

Sim, há outra maneira de fazer isso!

Etapa 1: registrar uma diretiva 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>';
         });
     }
    ...

Etapa 2: use sua diretiva Blade personalizada:

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

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

Saídas:

ESTA É MINHA DIRETIVA DE LÂMINA PERSONALIZADA !!
Link personalizado

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

Leitura adicional: https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives

Se você quiser aprender a melhor forma de criar classes personalizadas que você pode usar em qualquer lugar , consulte Classes personalizadas no Laravel 5, a maneira fácil

Este é o meu arquivo 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;
            }
        }
    }
}

Você deve criar uma pasta chamada Helperssob a apppasta e, em seguida, criar um arquivo chamadowhatever.php inside e adicionar a string whateverdentro da matriz $ helpers.

Feito!

Editar

Não estou mais usando esta opção, atualmente estou usando o compositor para carregar arquivos estáticos como auxiliares.

Você pode adicionar os auxiliares diretamente em:

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

Para bibliotecas auxiliares personalizadas no meu projeto Laravel, criei uma pasta com o nome Librariesno meuLaravel/App diretório e, no diretório Bibliotecas, criei vários arquivos para diferentes bibliotecas auxiliares.

Depois de criar meus arquivos auxiliares, simplesmente incluo todos esses arquivos no meu arquivo composer.json como este

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

e executar

composer dump-autoload

Como o OP pediu melhores práticas , acho que ainda estamos perdendo alguns bons conselhos aqui.

Um único arquivo helpers.php está longe de ser uma boa prática. Em primeiro lugar, porque você combina muitos tipos diferentes de funções, por isso é contra os bons princípios de codificação. Além disso, isso pode prejudicar não apenas a documentação do código, mas também as métricas de código, como Complexidade Ciclomática , Índice de Manutenção e Volume Halstead . Quanto mais funções você tiver, mais fica pior.

A documentação do código seria OK usando ferramentas como o phpDocumentor , mas usando o Sami, ele não renderiza arquivos procedurais . A documentação da API do Laravel é esse o caso - não há documentação das funções auxiliares: https://laravel.com/api/5.4

As métricas de código podem ser analisadas com ferramentas como PhpMetrics . O uso do PhpMetrics versão 1.x para analisar o código da estrutura do Laravel 5.4 fornecerá métricas CC / MI / HV muito ruins para os arquivos src / Illuminate / Foundation / helpers.php e src / Illuminate / Support / helpers.php .

Vários arquivos auxiliares contextuais (por exemplo , string_helpers.php , array_helpers.php , etc.) certamente melhorariam essas métricas ruins, resultando em um código mais fácil de manter. Dependendo do gerador de documentação de código usado, isso seria bom o suficiente.

Ele pode ser aprimorado ainda mais usando classes auxiliares com métodos estáticos, para que possam ser contextualizadas usando espaços para nome. Assim como o Laravel já faz com Illuminate\Support\StreIlluminate\Support\Arr classes. Isso melhora as métricas / organização do código e a documentação. Aliases de classe podem ser usados ​​para torná-los mais fáceis de usar.

Estruturar com classes melhora a organização e a documentação do código, mas, por outro lado, acabamos perdendo aquelas excelentes funções globais curtas e fáceis de lembrar. Podemos melhorar ainda mais essa abordagem criando aliases de função para esses métodos de classes estáticas. Isso pode ser feito manualmente ou dinamicamente.

O Laravel usa internamente a primeira abordagem declarando funções nos arquivos auxiliares de procedimentos que são mapeados para os métodos de classes estáticas. Isso pode não ser o ideal, pois você precisa redeclarar tudo (docblocks / argumentos).
Eu pessoalmente uso uma abordagem dinâmica com uma HelperServiceProviderclasse que cria essas funções no tempo de execução:

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

Pode-se dizer que isso acabou com a engenharia, mas acho que não. Funciona muito bem e, ao contrário do que se poderia esperar, não custa tempo de execução relevante, pelo menos ao usar o PHP 7.x.

Aqui está um script bash shell que criei para fazer as fachadas do Laravel 5 muito rapidamente.

Execute isso no diretório de instalação do Laravel 5.

Chame assim:

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

Exemplo:

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

Se você executar esse exemplo, ele criará os diretórios Facadese Providersem 'your_laravel_installation_dir / app / MyApp'.

Ele criará os três arquivos a seguir e também os exibirá na tela:

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

Depois de pronto, ele exibirá uma mensagem semelhante à seguinte:

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

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

Portanto, atualize a lista Provedores e alias em 'config / app.php'

Corre composer -o dumpautoload

O "./app/MyApp/Facades/Helper.php" terá a seguinte aparência:

<?php

namespace App\MyApp\Facades;


class Helper
{
    //
}

Agora basta adicionar seus métodos em "./app/MyApp/Facades/Helper.php".

Aqui está o que "./app/MyApp/Facades/Helper.php" se parece depois de adicionar uma função Helper.

<?php

namespace App\MyApp\Facades;

use Request;

class Helper
{
    public function isActive($pattern = null, $include_class = false)
    {
        return ((Request::is($pattern)) ? (($include_class) ? 'class="active"' : 'active' ) : '');
    }
}

This is how it would be called:
===============================

{!!  Helper::isActive('help', true) !!}

Esta função espera um padrão e pode aceitar um segundo argumento booleano opcional.

Se o URL atual corresponder ao padrão passado, ele produzirá 'active' (ou 'class = "active"' se você adicionar 'true' como um segundo argumento à chamada de função).

Eu o uso para destacar o menu que está ativo.

Abaixo está o código fonte do meu script. Espero que você ache útil e informe-me se tiver algum 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 ""

em vez de incluir sua classe auxiliar personalizada, você pode realmente adicionar ao seu config/app.phparquivo com aliases.

deve ser assim.

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

e depois ao seu Controller, inclua o Helper usando o método 'use Helper' para que você possa simplesmente chamar parte do método na sua classe Helper.

eg. Helper::some_function();

ou na exibição de recursos, você já pode chamar diretamente a classe Helper.

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

Mas essa ainda é a abordagem do estilo de codificação do desenvolvedor a ser seguida. Podemos ter uma maneira diferente de resolver problemas, e eu só quero compartilhar o que tenho também para iniciantes.

Criar diretório de auxiliares personalizados: primeiro crie o diretório de auxiliares no diretório de aplicativos. Criar definição de classe hlper: Agora vamos criar uma função auxiliar simples que concatenará duas strings. Crie um novo arquivo MyFuncs.php em /app/Helpers/MyFuncs.php Adicione o seguinte código

<?php

namespace App\Helpers;

class MyFuncs {

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

espaço para nome App \ Helpers; define o espaço para nome dos auxiliares em espaço para nome do aplicativo. classe MyFuncs {…} define a classe auxiliar MyFuncs. função estática pública full_name ($ first_name, $ last_name) {…} define uma função estática que aceita dois parâmetros de string e retorna uma string concatenada

O serviço de ajudantes fornece classe

Os provedores de serviços são usados ​​para carregar classes automaticamente. Precisamos definir um provedor de serviços que carregará todas as nossas classes auxiliares no diretório / app / Helpers.

Execute o seguinte comando do artesão:

php artisan make: provider HelperServiceProvider

O arquivo será criado em /app/Providers/HelperServiceProvider.php

Open /app/Providers/HelperServiceProvider.php

Adicione o seguinte 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);
        }
   }
}

AQUI,

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.

Agora precisamos registrar o HelperServiceProvider e criar um alias para nossos auxiliares.

Abrir /config/app.phparquivo

Localize a variável de matriz de provedores

Adicione a seguinte linha

App\Providers\HelperServiceProvider::class,

Localize a variável de matriz de aliases

Adicione a seguinte linha

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

Salve as alterações Usando nosso assistente personalizado

Criaremos uma rota que chamará nossa função auxiliar personalizada. Abra /app/routes.php

Adicione a seguinte definição de rota

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

AQUI,

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

Primeiro crie helpers.php dentro do diretório App \ Http. Em seguida, adicione o seguinte código dentro do compositer.json

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

Em seguida, execute o seguinte comando

composer dump-autoload

Agora você pode definir sua função personalizada dentro do arquivo helpers.php.

Outra maneira que eu usei foi: 1) criou um arquivo em app \ FolderName \ fileName.php e tinha esse código dentro dele, ou seja

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

2) Depois disso em nossa lâmina

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

é isso aí. e funciona

A melhor prática para escrever auxiliares personalizados é

1) Dentro do app diretório da raiz do projeto, crie uma pasta chamada Helpers (Apenas para separar e estruturar o código).

2) Dentro da pasta, escreva arquivos psr-4 ou arquivos php normais

Se os arquivos PHP estiverem no formato psr-4, eles serão carregados automaticamente, caso contrário, adicione a seguinte linha no composer.json, que está dentro do diretório raiz do projeto

Dentro da autoloadchave, crie uma nova chave denominada filespara carregar arquivos no momento do carregamento automático, dentro do filesobjeto adicione o caminho a partir do diretório do aplicativo. Aqui está um exemplo.

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

PS: tente executar composer dump-autoloadse o arquivo não estiver carregado.

Crie Helpers.php em app / Helper / Helpers.php

namespace App\Helper
class Helpers
{


}

Adicionar na atualização do compositor e compositor

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

usar no controlador

use App \ Helper \ Helpers

usar na alteração de exibição no arquivo config-> app.php

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

ligar em vista

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

no diretório bootstrap \ autoload.php

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

adicione este arquivo

app\Helpers\function.php

**

• Auxiliar de status

** criar novo ajudante

<?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 para o controlador e qualquer arquivo de visualização

use App\Helpers\StatusHelper;

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

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

No laravel 5.3 e acima, a equipe do laravel moveu todos os arquivos procedurais ( routes.php) para fora do app/diretório e a app/pasta inteira é psr-4carregada automaticamente. A resposta aceita funcionará neste caso, mas não parece certo para mim.

Então, o que eu fiz foi criar um helpers/diretório na raiz do meu projeto e colocar os arquivos auxiliares dentro dele, e no meu composer.jsonarquivo eu fiz o seguinte:

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

Desta forma, o meu app/ diretório ainda é um psr-4, carregado automaticamente, e os ajudantes são um pouco melhor organizados.

Espero que isso ajude alguém.

Existem algumas ótimas respostas aqui, mas acho que essa é a mais simples. No Laravel 5.4 (e provavelmente nas versões anteriores), você pode criar uma classe em algum lugar conveniente para você, por exemplo, App / Libraries / Helper.php

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

Em seguida, você pode simplesmente chamá-lo no seu modelo Blade assim:

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

Se você não quiser usar o @inject, faça a função 'uppercasePara' como estática e incorpore a chamada no seu modelo Blade da seguinte maneira:

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

Não há necessidade de aliases. O Laravel resolve a classe concreta automaticamente.