Utilizando tus propios helpers en Laravel (o cualquier proyecto PHP)
Tags: php, laravel, castellano
Published: 2020-09-29 18:22:37

---
title: Utilizando tus propios helpers en Laravel (o cualquier proyecto PHP)
published: true
description: Dos maneras de implementar tus propias funciones globales en cualquier proyecto PHP de manera muy sencilla.
tags: PHP, Laravel, castellano
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/exlvbmlpt6pvp2klmgmr.png
---

En Laravel, al igual que en cualquier proyecto PHP, puedes incluir tus propios helpers o funciones globales para facilitar ciertas tareas comunes y que se usan en diferentes partes.

Este artículo mostrará dos formas de hacerlo, y después cada uno ya decide según sus preferencias.

# La parte común

Comenzamos indicando a `composer` que usaremos un fichero con una serie de funciones globales que debe cargar en el `autoload` junto con el resto de definiciones.

En este caso mi fichero es `app/Services/Helper/functions.php`:

```
"autoload": {
    "classmap": [
        "database/migrations"
    ],
    "psr-4": {
        "App\\": "app/"
    },
    "files": [
        "app/Services/Helper/functions.php"
    ]
}
```

A partir de este momento lo que incluya este fichero ya estará disponible en toda la aplicación.

# La forma tradicional

Básicamente la forma tradicional significa colocar tus funciones directamente, como por ejemplo:

```php
<?php declare(strict_types=1);

if (function_exists('ids') === false) {
    /**
     * @param array $ids
     *
     * @return array
     */
    function ids(array $ids): array
    {
        return array_values(array_filter(array_map('intval', $ids)));
    }
}

if (function_exists('uniqidReal') === false) {
    /**
     * @param int $length
     * @param bool $safe = false
     *
     * @return string
     */
    function uniqidReal(int $length, bool $safe = false): string
    {
        if ($safe) {
            $string = '23456789bcdfghjkmnpqrstwxyzBCDFGHJKMNPQRSTWXYZ';
        } else {
            $string = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        }

        return substr(str_shuffle(str_repeat($string, rand((int)($length / 2), $length))), 0, $length);
    }
}

if (function_exists('dateLocal') === false) {
    /**
     * @param string $date
     * @param string $format = 'Y-m-d'
     *
     * @return string
     */
    function dateLocal(string $date, string $format = 'd/m/Y'): string
    {
        return date($format, strtotime($date));
    }
}

if (function_exists('arrayMapRecursive') === false) {
    /**
     * @param array $array
     * @param callable $callback
     *
     * @return array
     */
    function arrayMapRecursive(array $array, callable $callback): array
    {
        return array_map($func = static function ($value) use ($callback, &$func) {
            return is_array($value) ? array_map($func, $value) : $callback($value);
        }, $array);
    }
}
```

Ahora ya podrás utilizar estas funciones de en cualquier parte de la aplicación como si fuera una función nativa de PHP más.

# La forma encapsulada o libre de conflictos

La alternativa a la forma tradicional es mediante una función única que nos sirva el acceso al resto de helpers.

Esto nos permitirá crear todos los métodos que necesitemos sin temer por conflictos con otros métodos nativos de PHP y también con otros métodos globales que puedan definir el resto de paquetes de nuestro proyecto.

Para hacer esto crearemos el fichero de `app/Services/Helper/functions.php` con una única función:

```php
<?php declare(strict_types=1);

/**
 * @return \App\Services\Helper\Helper
 */
function helper(): App\Services\Helper\Helper
{
    static $helper;

    return $helper ??= new App\Services\Helper\Helper();
}
```

y a partir de aquí crearemos los métodos que necesitemos dentro de la clase `App\Services\Helper\Helper`:

```php
<?php declare(strict_types=1);

namespace App\Services\Helper;

class Helper
{
    /**
     * @param array $ids
     *
     * @return array
     */
    public function ids(array $ids): array
    {
        return array_values(array_filter(array_map('intval', $ids)));
    }

    /**
     * @param int $length
     * @param bool $safe = false
     *
     * @return string
     */
    public function uniqidReal(int $length, bool $safe = false): string
    {
        if ($safe) {
            $string = '23456789bcdfghjkmnpqrstwxyzBCDFGHJKMNPQRSTWXYZ';
        } else {
            $string = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        }

        return substr(str_shuffle(str_repeat($string, rand((int)($length / 2), $length))), 0, $length);
    }

    /**
     * @param string $date
     * @param string $format = 'Y-m-d'
     *
     * @return string
     */
    public function dateLocal(string $date, string $format = 'd/m/Y'): string
    {
        return date($format, strtotime($date));
    }

    /**
     * @param array $array
     * @param callable $callback
     *
     * @return array
     */
    public function arrayMapRecursive(array $array, callable $callback): array
    {
        return array_map($func = static function ($value) use ($callback, &$func) {
            return is_array($value) ? array_map($func, $value) : $callback($value);
        }, $array);
    }
}
```

De este modo para llamar a cualquier método del helper haremos por ejemplo: `helper()->uniqidReal(6)` o podemos renombrar a la función global `helper` como `h` para acortar las llamadas `h()->uniqidReal(6)`.

Yo personalmente prefiero la segunda opción, pero eso ya es cosa de cada uno :)

Si te ha parecido interesante, compárteme!