Como criar um auxiliar de Laravel

Para começar, prefiro deixar o site oficial do Laravel falar sobre helpers.

O Laravel inclui uma variedade de funções PHP “auxiliares” globais. Muitas dessas funções são usadas pelo próprio framework; no entanto, você é livre para usá-los em seus próprios aplicativos, se achar conveniente.

Então, basicamente, helpers no Laravel são funções utilitárias embutidas que você pode chamar de qualquer lugar dentro de sua aplicação. Se eles não tivessem sido fornecidos pelo framework principal, você poderia ter desenvolvido suas próprias classes auxiliares.

Embora o núcleo já forneça uma variedade de auxiliares, sempre há uma chance de você precisar do seu próprio e gostaria de desenvolver um para não precisar repetir o mesmo código aqui e ali, reforçando assim uma melhor capacidade de manutenção. Você aprenderá como criar um ajudante personalizado do Laravel neste tutorial.

Auxiliares em Laravel

Como discutimos anteriormente, existem muitos auxiliares disponíveis no núcleo do framework Laravel. Eles são agrupados com base na funcionalidade que fornecem. Aqui está uma lista de grupos de ajuda.

Matrizes

Os auxiliares neste grupo fornecem funcionalidade para manipular elementos de matriz. Na maioria das vezes, você está na situação em que deseja realizar diferentes operações em elementos de matriz. Então este é o lugar onde você deve olhar primeiro para ver se o que você está procurando já existe.

Caminhos

Acho ajudantes nesta categoria mais úteis. Eles retornam o caminho totalmente qualificado de diferentes diretórios, como app, storage, config e similares. Aposto que você já está usando a maioria desses auxiliares em seu aplicativo Laravel.

Cordas

A manipulação de strings é algo inevitável no seu dia-a-dia no desenvolvimento de aplicativos. Embora existam muitas funções de manipulação de strings fornecidas pelo próprio PHP, você encontrará mais algumas coisas úteis nesta seção.

URLs

Você encontrará muito poucos nesta categoria, mas eles são usados ​​em todo o aplicativo. Eles são usados ​​para gerar URLs de ação de rota, ativo e formulário.

Diversos

Esta categoria contém auxiliares que fornecem uma variedade de funcionalidades que vão desde o registro até a depuração e muito mais.

Para uma referência completa dos auxiliares do Laravel, não há lugar melhor do que a documentação oficial.

Crie seu primeiro ajudante personalizado

Agora você tem uma compreensão básica dos auxiliares do Laravel e para que eles são usados. Nesta seção, irei adiante e demonstrarei como você pode criar seu próprio auxiliar customizado que pode ser usado globalmente em seu aplicativo Laravel.

Para manter as coisas simples e fáceis de entender, será um auxiliar bastante básico que recebe um ID de usuário e retorna um nome de usuário como resposta. Claro, isso não soa extravagante, mas acredito que seja suficiente para demonstrar o conceito, e você sempre pode estendê-lo para atender aos seus requisitos complexos.

Eu suponho que você tenha uma tabela de usuários em seu banco de dados e tenha pelo menos dois campos—userid e username.

O esqueleto de um ajudante do Laravel

Antes de prosseguirmos e realmente criarmos os arquivos, vamos dar uma olhada rápida nos arquivos que vamos criar no restante do artigo.

• app/Helpers/Envato/User.php: É o nosso arquivo auxiliar que contém a lógica do nosso auxiliar.
• app/Providers/EnvatoServiceProvider.php: é um arquivo de provedor de serviços personalizado que carrega nosso arquivo de ajuda personalizado.
• config/app.php: neste arquivo, declararemos nosso provedor de serviço personalizado e também nos ajuda a definir um alias para nosso auxiliar para que não precisemos usar o nome de classe totalmente qualificado de nosso auxiliar.
• routes/web.php: Um arquivo de rota padrão do Laravel onde realmente testaremos nosso auxiliar.

Criar arquivos auxiliares

Embora você possa colocar seus arquivos auxiliares em qualquer lugar em seu aplicativo, a maneira mais intuitiva e padrão sugere que ele deve ficar sob seu app diretório.

Então vá em frente e crie um Helpers/Envato diretório sob app e criar um User.php arquivo com o seguinte conteúdo. Claro, você pode colocá-lo diretamente sob o app ou app/Helpers diretório, mas fornecer esse nível extra nos permite organizar nossos ajudantes em boa forma, especificamente quando você vai ter muitos deles.

where('userid', $user_id)->first();
        
        return (isset($user->username) ? $user->username : '');
    }
}

O arquivo começa com uma declaração de namespace bastante padrão:

namespace AppHelpersEnvato;

O objetivo do nosso ajudante personalizado é recuperar um nome de usuário com base em um ID de usuário. Portanto, precisamos interagir com o banco de dados, e isso nos obriga a incluir o DB Facade.

use IlluminateSupportFacadesDB;

Para aqueles que não estão familiarizados com o Laravel Facades, é apenas mais uma maneira conveniente de acessar os objetos em contêineres de serviço. Alternativamente, você poderia ter usado injeção de dependência.

Seguindo em frente, vem a implementação concreta do nosso ajudante. Como você pode ver, existe um método estático que define a lógica de recuperar um nome de usuário com base em um ID de usuário.

$user = DB::table('users')->where('userid', $user_id)->first();

o $user O objeto contém o registro do banco de dados com o ID de usuário correspondente. Por fim, o método retorna o nome de usuário como resposta na instrução a seguir.

return (isset($user->username) ? $user->username : '');

É isso no que diz respeito ao nosso arquivo auxiliar.

Agora criamos nosso arquivo auxiliar, mas a questão é como você vai usá-lo? Duas soluções rápidas me vêm à mente:

• Você pode incluir nosso nome de arquivo auxiliar no composer.json, para que seja carregado automaticamente. Então, você pode chamar imediatamente o método estático de nossa classe auxiliar.
• Você pode seguir em frente e criar um provedor de serviços Laravel que permita registrar seu arquivo auxiliar personalizado para que a estrutura Laravel o carregue junto com outras dependências. Registre esse provedor de serviços na configuração do Laravel e crie um alias para usar seu ajudante.

Claro, o primeiro é bem rápido e fácil de implementar, e você pode ficar tentado a fazê-lo, mas eu prefiro sugerir o último, pois parece mais artesanal e é mais sustentável.

Vá para a linha de comando e execute o seguinte comando na raiz do aplicativo para criar um novo provedor de serviços.

$php artisan make:provider EnvatoServiceProvider 
Provider created successfully.

Você deve ver a mensagem que confirma que foi criado com sucesso sob o app/Providers diretório.

Abra esse arquivo e você já deve ver dois métodos por aí. O importante no contexto deste artigo é a register método. Sim, está vazio no momento, então vamos alimentar algumas coisas para torná-lo mais útil.

public function register()
{
    require_once app_path() . '/Helpers/Envato/User.php';
}

O método register é usado para registrar suas dependências, e fizemos exatamente isso. Incluímos nosso arquivo auxiliar personalizado.

Aqui está como o app/Providers/EnvatoServiceProvider.php arquivo deve cuidar das modificações.

Então está tudo muito bem até agora.  Temos nosso ajudante personalizado e prestador de serviços na mesa.
Em seguida, precisamos informar ao Laravel sobre nosso provedor de serviços para que ele possa carregá-lo durante o bootstrap.  Vamos abrir o config/app.php e adicione a seguinte entrada no providers matriz no final.
AppProvidersEnvatoServiceProvider::class,
Para usar nosso auxiliar de maneira conveniente, poderíamos criar um alias também.  Então, vamos fazer isso adicionando a seguinte entrada no aliases array no final do mesmo arquivo.
'EnvatoUser' => AppHelpersEnvatoUser::class,
Ao definir esta entrada, podemos chamar nosso auxiliar usando o EnvatoUser palavra-chave.  Bem conveniente, hein?  Para sua referência, aqui está o completo config/app.php Arquivo.
 'Laravel',

    /*
    |--------------------------------------------------------------------------
    | Application Environment
    |--------------------------------------------------------------------------
    |
    | This value determines the "environment" your application is currently
    | running in. This may determine how you prefer to configure various
    | services your application utilizes. Set this in your ".env" file.
    |
    */

    'env' => env('APP_ENV', 'production'),

    /*
    |--------------------------------------------------------------------------
    | Application Debug Mode
    |--------------------------------------------------------------------------
    |
    | When your application is in debug mode, detailed error messages with
    | stack traces will be shown on every error that occurs within your
    | application. If disabled, a simple generic error page is shown.
    |
    */

    'debug' => env('APP_DEBUG', false),

    /*
    |--------------------------------------------------------------------------
    | Application URL
    |--------------------------------------------------------------------------
    |
    | This URL is used by the console to properly generate URLs when using
    | the Artisan command line tool. You should set this to the root of
    | your application so that it is used when running Artisan tasks.
    |
    */

    'url' => env('APP_URL', 'https://localhost'),

    /*
    |--------------------------------------------------------------------------
    | Application Timezone
    |--------------------------------------------------------------------------
    |
    | Here you may specify the default timezone for your application, which
    | will be used by the PHP date and date-time functions. We have gone
    | ahead and set this to a sensible default for you out of the box.
    |
    */

    'timezone' => 'UTC',

    /*
    |--------------------------------------------------------------------------
    | Application Locale Configuration
    |--------------------------------------------------------------------------
    |
    | The application locale determines the default locale that will be used
    | by the translation service provider. You are free to set this value
    | to any of the locales which will be supported by the application.
    |
    */

    'locale' => 'en',

    /*
    |--------------------------------------------------------------------------
    | Application Fallback Locale
    |--------------------------------------------------------------------------
    |
    | The fallback locale determines the locale to use when the current one
    | is not available. You may change the value to correspond to any of
    | the language folders that are provided through your application.
    |
    */

    'fallback_locale' => 'en',

    /*
    |--------------------------------------------------------------------------
    | Encryption Key
    |--------------------------------------------------------------------------
    |
    | This key is used by the Illuminate encrypter service and should be set
    | to a random, 32 character string, otherwise these encrypted strings
    | will not be safe. Please do this before deploying an application!
    |
    */

    'key' => env('APP_KEY'),

    'cipher' => 'AES-256-CBC',

    /*
    |--------------------------------------------------------------------------
    | Logging Configuration
    |--------------------------------------------------------------------------
    |
    | Here you may configure the log settings for your application. Out of
    | the box, Laravel uses the Monolog PHP logging library. This gives
    | you a variety of powerful log handlers / formatters to utilize.
    |
    | Available Settings: "single", "daily", "syslog", "errorlog"
    |
    */

    'log' => env('APP_LOG', 'single'),

    'log_level' => env('APP_LOG_LEVEL', 'debug'),

    /*
    |--------------------------------------------------------------------------
    | Autoloaded Service Providers
    |--------------------------------------------------------------------------
    |
    | The service providers listed here will be automatically loaded on the
    | request to your application. Feel free to add your own services to
    | this array to grant expanded functionality to your applications.
    |
    */

    'providers' => [

        /*
         * Laravel Framework Service Providers...
         */
        IlluminateAuthAuthServiceProvider::class,
        IlluminateBroadcastingBroadcastServiceProvider::class,
        IlluminateBusBusServiceProvider::class,
        IlluminateCacheCacheServiceProvider::class,
        IlluminateFoundationProvidersConsoleSupportServiceProvider::class,
        IlluminateCookieCookieServiceProvider::class,
        IlluminateDatabaseDatabaseServiceProvider::class,
        IlluminateEncryptionEncryptionServiceProvider::class,
        IlluminateFilesystemFilesystemServiceProvider::class,
        IlluminateFoundationProvidersFoundationServiceProvider::class,
        IlluminateHashingHashServiceProvider::class,
        IlluminateMailMailServiceProvider::class,
        IlluminateNotificationsNotificationServiceProvider::class,
        IlluminatePaginationPaginationServiceProvider::class,
        IlluminatePipelinePipelineServiceProvider::class,
        IlluminateQueueQueueServiceProvider::class,
        IlluminateRedisRedisServiceProvider::class,
        IlluminateAuthPasswordsPasswordResetServiceProvider::class,
        IlluminateSessionSessionServiceProvider::class,
        IlluminateTranslationTranslationServiceProvider::class,
        IlluminateValidationValidationServiceProvider::class,
        IlluminateViewViewServiceProvider::class,

        /*
         * Package Service Providers...
         */
        LaravelTinkerTinkerServiceProvider::class,

        /*
         * Application Service Providers...
         */
        AppProvidersAppServiceProvider::class,
        AppProvidersAuthServiceProvider::class,
        // AppProvidersBroadcastServiceProvider::class,
        AppProvidersEventServiceProvider::class,
        AppProvidersRouteServiceProvider::class,
        AppProvidersEnvatoServiceProvider::class,
    ],

    /*
    |--------------------------------------------------------------------------
    | Class Aliases
    |--------------------------------------------------------------------------
    |
    | This array of class aliases will be registered when this application
    | is started. However, feel free to register as many as you wish as
    | the aliases are "lazy" loaded so they don't hinder performance.
    |
    */

    'aliases' => [

        'App' => IlluminateSupportFacadesApp::class,
        'Artisan' => IlluminateSupportFacadesArtisan::class,
        'Auth' => IlluminateSupportFacadesAuth::class,
        'Blade' => IlluminateSupportFacadesBlade::class,
        'Broadcast' => IlluminateSupportFacadesBroadcast::class,
        'Bus' => IlluminateSupportFacadesBus::class,
        'Cache' => IlluminateSupportFacadesCache::class,
        'Config' => IlluminateSupportFacadesConfig::class,
        'Cookie' => IlluminateSupportFacadesCookie::class,
        'Crypt' => IlluminateSupportFacadesCrypt::class,
        'DB' => IlluminateSupportFacadesDB::class,
        'Eloquent' => IlluminateDatabaseEloquentModel::class,
        'Event' => IlluminateSupportFacadesEvent::class,
        'File' => IlluminateSupportFacadesFile::class,
        'Gate' => IlluminateSupportFacadesGate::class,
        'Hash' => IlluminateSupportFacadesHash::class,
        'Lang' => IlluminateSupportFacadesLang::class,
        'Log' => IlluminateSupportFacadesLog::class,
        'Mail' => IlluminateSupportFacadesMail::class,
        'Notification' => IlluminateSupportFacadesNotification::class,
        'Password' => IlluminateSupportFacadesPassword::class,
        'Queue' => IlluminateSupportFacadesQueue::class,
        'Redirect' => IlluminateSupportFacadesRedirect::class,
        'Redis' => IlluminateSupportFacadesRedis::class,
        'Request' => IlluminateSupportFacadesRequest::class,
        'Response' => IlluminateSupportFacadesResponse::class,
        'Route' => IlluminateSupportFacadesRoute::class,
        'Schema' => IlluminateSupportFacadesSchema::class,
        'Session' => IlluminateSupportFacadesSession::class,
        'Storage' => IlluminateSupportFacadesStorage::class,
        'URL' => IlluminateSupportFacadesURL::class,
        'Validator' => IlluminateSupportFacadesValidator::class,
        'View' => IlluminateSupportFacadesView::class,
        'EnvatoUser' => AppHelpersEnvatoUser::class,
    ],

];
Estamos quase lá!  Fizemos todo o trabalho duro para chegar até aqui e agora podemos colher os benefícios de nosso ajudante personalizado.
Seu primeiro ajudante personalizado em ação
Novamente, para manter as coisas simples e diretas, vamos definir uma rota básica do Laravel e chamar nosso ajudante de lá!
Vá em frente e crie um routes/web.php arquivo com o seguinte conteúdo.

Isso precisa de alguma explicação?  Acabamos de chamar o ajudante personalizado pela abreviação EnvatoUser::get_usernamee deve retornar o nome de usuário.
Claro, você pode chamar nosso ajudante de qualquer lugar da aplicação, seja um controller ou view.
Assim termina nossa história de hoje.
Conclusão
Helpers em Laravel são realmente um recurso poderoso, e tenho certeza de que, como desenvolvedor, você adoraria estender isso.  E esse foi o tópico de hoje - passamos pelo básico da estrutura do arquivo auxiliar do Laravel e criamos um auxiliar personalizado útil.
Espero que tenha gostado do artigo e que ele o ajude a criar seus próprios ajudantes personalizados no dia-a-dia do desenvolvimento de aplicativos Laravel.
Não hesite em deixar seus comentários e dúvidas no feed abaixo.  Eu também pego comentários no meu Twitter e responda a eles o mais rápido possível!