Práticas recomendadas para assistentes personalizados no Laravel 5 [fechado]

472

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?

Calebe Oliveira
fonte

Respostas:

595

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"
]
Joseph Silber
fonte
86
Dica para noobs: use este comando após alterar o compositer.json. compositor dump-autoload
Allfarid Morales García
11
@ AllfaridMoralesGarcía Ou talvez apenas 'Uma dica útil, pois a resposta não deixa claro que você precisa fazer isso depois'.
Matt McDonald
8
Eu aprovo as funções auxiliares para facilitar a visualização da escrita, mas odeio o quanto essa resposta é mencionada em outras respostas. Não me interpretem mal, é uma boa resposta e correta. Só temo que as pessoas abusem dela e comecem a escrever toneladas de PHP funcional mal escrito e mal organizado novamente.
andrewtweber
40
Eu não entendo essa abordagem. O Composer deve ser uma ferramenta para incluir bibliotecas: o Laravel funcionaria perfeitamente bem sem ele e o Composer sem o Laravel. Esta sugestão nos diz para criar um arquivo em nosso aplicativo, deixá-lo, vá para o Composer, diga ao compositor para voltar ao aplicativo e incluir um arquivo. O Laravel lida claramente com a inclusão de arquivos, certo? Por que renunciaríamos à implementação nativa do Laravel e usaríamos essa ferramenta externa para incluir um arquivo para nós, acoplando mais nosso aplicativo ao Composer? É preguiça, ou estou faltando alguma coisa?
dKen
6
O Laravel usa o carregador automático do compositor para saber onde incluir todas as bibliotecas e arquivos em que se baseia. Referenciado em bootstrap / autoload.php. Leia o comentário nesse arquivo. A abordagem é adicionar a referência ao arquivo no composer.json e depois "despejar o carregamento automático", que regenera o carregamento automático do compositor para que o Laravel possa encontrá-lo. O uso da coleção "arquivos" do Composer é uma boa maneira de adicionar bibliotecas ou arquivos de função únicos que não estão organizados em pacotes do compositor. É bom ter um lugar para todas as situações "a propósito, eu tenho que incluir esse arquivo estranho".
Phillip Harrington
370

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

heisian
fonte
35
Para ser claro, essa resposta não lida com auxiliares, que são funções com espaço global de nomes. Em vez disso, incentiva a conversão de ajudantes em métodos de classe. Geralmente, essa é a melhor abordagem, mas, na verdade, não responde à pergunta feita aqui, e é por isso que outras respostas são tão complexas em comparação.
Dan Hunsaker
1
O auxiliar de função significa que também está disponível no Blade. Como você disponibiliza esta função no blade? Você não pode chamar Helper :: prettyJason (parâmetros) no blade.
MaXi32 21/01
@ MaXi32, você poderia adicionar a classe sob a aliasesmatriz em app/config.php: 'Helper' => App\Helpers\Helper::class, Então você seria capaz de chamar o Helper::prettyJson();blade muito bem.
heisian
O @ DanHunsaker editado para responder diretamente à pergunta, e ainda é a mesma abordagem simples. Você também pode escrever suas próprias diretivas de blade personalizadas: stackoverflow.com/questions/28290332/…
heisian 29/04/16
1
Sim, examinei a estrutura uma vez e descobri onde eles ajudaram os auxiliares. E, novamente, concordo completamente que os métodos das classes estáticas no espaço de nomes são muito mais adequados do que o que está sendo solicitado - ou recomendado - na maioria das vezes. O fato é que os ajudantes não são realmente o The Laravel Way em primeiro lugar, mas sim uma recuperação do CodeIgniter 2.x que ainda não foi eliminado. Portanto, meu pedantismo sobre essa abordagem, que não responde ao OP exatamente como solicitado, é mais uma tentativa de destacar o fato de que você não recebe ajudantes, mas de algo melhor.
Dan Hunsaker
315

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

Andrew Brown
fonte
29
para pessoas que têm apenas algumas funções que precisam adicionar, o carregamento automático do compositor é perfeitamente adequado, mas para aqueles de nós que podem ter muitas funções auxiliares, é essencial uma organização de vários arquivos. Essa solução é essencialmente o que eu fiz no L4, exceto que registrei os arquivos no meu start.phparquivo (o que não foi ótimo, mas serviu ao seu propósito na época). você tem outra sugestão para carregar vários arquivos?
Andrew Brown
7
Se você tiver vários arquivos, adicione-os todos ao seu arquivo composer.json. Adicionar até 5 a 10 linhas faz muito mais sentido do que você tem aqui.
Joseph Silber
22
Eu acho que essa técnica tem muito mérito. É elegante e eficiente porque você não precisa se lembrar de mexer com o arquivo composer.json toda vez que cria um arquivo auxiliar.
impeto 22/03/2015
8
Solução realmente boa. A única coisa que discordo é a maneira como você adiciona os arquivos, acho que deveria ser um mapeador, onde adicionamos o nome do arquivo que queremos carregar. Pense em erros! se houver apenas um auxiliar em um dos arquivos que está falhando, remova todos eles ou o site será quebrado até que você o resolva.
Pablo Ezequiel Leone
3
Você usa o namespace App \ Providers? Como eu chamo esse ajudante do controlador e da visualização. Desculpe, noob pergunta.
Cengkaruk
79

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.
itsazzad
fonte
15
Os auxiliares podem não ser apenas HTTP. app/helpers.phpou app/Helpers/parece ser um lugar melhor.
sepehr 6/12/15
1
E se estivermos em um servidor compartilhado e não tivermos a opção de usar composer dump-autoload ?
user3201500
@ user3201500 é outra pergunta e talvez você precise fazer manualmente se quiser seguir a resposta acima. Ou você pode escolher entre outras respostas. E para refletir manualmente, composer dump-autoloadvocê pode seguir o seguinte: desenvolveu.be/2014/08/29/composer-dump-autoload-laravel
itsazzad
55

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>
dKen
fonte
obrigado por postar isso. como @ Dan-Hunsaker apontou em minha solução, ainda não terminamos com uma função com espaço de nome global, ou seja, ser capaz de escrever de maneira simples {!! bob() !!}. vamos fazer mais algumas pesquisas e ver se isso é possível
heisian
1
Eu pensei mais sobre isso e tentar tornar-se bob()verdadeiramente global não seria uma coisa sábia a se fazer. Os namespaces existem por um motivo e não devemos chamar bob()juntamente com as funções básicas do PHP. Vou adicionar seu bit de alias ao meu código - obrigado!
heisian
1
Acho que este é o melhor de todos
Jimmy Obonyo Abor
Por que existe extends Helper? Não parece necessário para mim.
Bernie
@bernie @ user3201500 Desculpe equipe, eu tinha minha própria classe auxiliar de base da qual todos os meus ajudantes herdam; o extends Helperfato não é necessário. Obrigado pela atenção.
dKen 5/02/16
31

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

heisian
fonte
Essa deve ser a melhor resposta, porque a pergunta era "para evitar a repetição de código entre algumas visualizações". A palavra-chave é VIEWS. :)
Aleksandrs
23

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",
        ...
    ]
},
...
Pablo Ezequiel Leone
fonte
Existem outros motivos além do desempenho para criar um mapeador em vez de carregar todos os arquivos no diretório glob()como Andrew Brown escreveu? Se você deseja especificar os arquivos que deseja incluir, por que não especificar os arquivos composer.jsonpara carregá-los automaticamente, como Joseph Silber escreveu? Por que você prefere esta solução? Não estou dizendo que essa é uma solução ruim, só estou curiosa.
Pelmered
3
É mais fácil, com uma abordagem mapeada, ativar / desativar seletivamente ajudantes se, por exemplo, um dos arquivos auxiliares contiver um erro de quebra. Dito isso, o mapeamento de arquivos em um provedor de serviços não é muito diferente de fazê-lo, composer.jsonexceto por dois pontos - primeiro, ele mantém o mapa dentro do próprio aplicativo, em vez de um arquivo de metadados; segundo, não é necessário executar novamente composer dump-autoloadtoda vez que você altera a lista de arquivos para carregar.
Dan Hunsaker
Não há necessidade de includeou require, Laravel já foi construído com PSR-4 autoloading: php-fig.org/psr/psr-4
heisian
1
o uso do PSR-4 e do compositor não permitirá que você ative / desative os auxiliares.
Pablo Ezequiel Leone
@PabloEzequielLeone e como eu o usaria dentro de um controlador ou arquivo blade? Essa é a melhor opção se você estiver preocupado em não carregar todos os auxiliares para todos os controladores todas as vezes, mas não é bom para iniciantes no Laravel (como eu).
VinGarcia
12

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
Akshay Khale
fonte
composer dump-autoloade composer dumpautoloadtambém funciona de facto composer dutambém funcionará ...
Akshay Khale
10

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.

Paulo Freitas
fonte
8

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 ""
Traço
fonte
8

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.

Kenneth Sunday
fonte
4

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
Mizanur Rahman
fonte
4

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.

ujjal
fonte
3

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

Dee
fonte
3

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.

Reiah Paul Sam
fonte
3

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();  ?>
abhishek kumar
fonte
Obrigado, você se importaria em expandir um pouco sua explicação?
Felipe Valdes
2
Se a classe estiver com namespace, a adição do arquivo composer.jsonserá inútil, pois o psr-4 autoload fará o trabalho.
Arceilas #
2

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
panqingqiang
fonte
2

**

  • 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'));
        }
}
Sunil
fonte
0

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.

Mubashar Abbas
fonte
0

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.

omarjebari
fonte