Utilidades de Laravel que deberías conocer

Foto de Daniil Komov en Pexels

Laravel viene con un montón de funciones helper pequeñas que aparecen constantemente. Son muy sencillas de usar, conocerlas te va a ahorra tiempo de desarrollo y hará el código más limpio. Repasamos las que más uso (este artículo lo he escrito usando la última versión de Laravel disponible hasta la fecha, la 13).

1. tap()

tap() recibe un valor, lo pasa a un callback y devuelve el valor original. Es útil para introducir un efecto secundario en medio de una cadena sin interrumpirla:

$resultado = tap('Hola', fn ($valor) => 'Adiós');
$resultado; // "Hola"

La clave es que tap() no devuelve el resultado del callback, sino el valor original, esto permite, por ejemplo, depurar una query sin interrumpirla:

// También útil para depurar en medio de una query
$users = User::published()
    ->tap(fn ($query) => Log::debug($query->toSql()))
    ->get();

Esto me ha resultado extremadamente útil porque hasta hace poco lo que hacía cuando tenía que depurar una query era algo muy bestia, en vez de un get() sustituirlo por un dd() o un dump().

Esto puede estar bien para un entorno local de desarrollo pero la cosa cambia cuando tienes que hacerlo en un entorno accesible y público.

Más info

2. rescue()

rescue() es como un try catch pero mejor, ejecuta un callback y devuelve su resultado. Si se lanza una excepción, la captura, la reporta (opcionalmente) y devuelve un valor por defecto en su lugar:

// Sin rescue - try/catch verboso
try {
    return $this->externalApiService->fetchUser($id);
} catch (Throwable $e) {
    report($e);
    return null;
}

// Con rescue
$user = rescue(fn () => $this->externalApiService->fetchUser($id), null);

// Con un valor de fallback
$price = rescue(fn () => CurrencyConverter::convert($amount, $currency), $amount);

// Sin reportar la excepción (tercer argumento: report: false)
$data = rescue(fn () => json_decode($raw, true, 512, JSON_THROW_ON_ERROR), [], report: false);

Puedes usarlo por ejemplo si tienes una llamada a una API externa y quieres devolver un valor por defecto en caso de que la llamada falle, esto me ha pasado en mis proyectos y resulta muy cómodo usarlo para que de cara al front tu api no devuelva un error no controlado.

Más info

3. optional()

optional() permite trabajar con un valor que puede ser null sin provocar un error. Si el valor existe, puedes acceder a sus propiedades o métodos; si es null, devuelve null:

// Sin optional - comprobación verbosa
$city = $user->profile ? $user->profile->city : null;

// Con optional
$city = optional($user->profile)->city;

// También funciona con llamadas a métodos
$formatted = optional($user->profile)->getFormattedAddress();

En PHP moderno, para este tipo de acceso normalmente puedes usar el operador null-safe ?->:

$city = $user->profile?->city;

Por eso, para accesos directos, ?-> suele ser una opción más sencilla. optional() sigue siendo útil en algunos casos específicos de Laravel, especialmente cuando quieres aprovechar el helper para trabajar con el valor de otras formas.

Más info

4. blank() y filled()

blank() comprueba si un valor está vacío según las reglas de Laravel. Devuelve true para valores como null, '', strings que solo contienen espacios, arrays vacíos o colecciones vacías.

filled() hace justo lo contrario: devuelve true cuando el valor no está vacío.

blank(null);        // true
blank('');           // true
blank('   ');        // true
blank([]);            // true
blank(0);              // false - 0 no está en blanco
blank('0');            // false

filled('hola');       // true
filled(0);              // true
filled($collection->where('status', 'active')); // true si la colección tiene elementos

En resumen:

blank() → “¿está vacío?”
filled() → “¿tiene contenido?

Más info sobre blank · Más info sobre filled

5. Métodos útiles de Request

Más allá de $request->input() y $request->all():

// Comprobar si una clave está presente (aunque sea null)
$request->has('name');         // true si la clave 'name' existe en la petición
$request->missing('name');     // su inversa

// Comprobar si una clave está presente Y no está vacía
$request->filled('name');      // true si 'name' existe y no está en blanco

// Obtener con un valor por defecto
$request->input('per_page', 15);

// Obtener solo ciertas claves
$request->only(['title', 'body', 'status']);

// Obtener todo excepto ciertas claves
$request->except(['_token', 'password_confirmation']);

// Input booleano - interpreta "true", "1", "on", "yes" como true
$request->boolean('is_featured');

// Input entero
$request->integer('page');

// Detectar el tipo de petición
$request->isJson();
$request->expectsJson();   // true si la petición espera JSON (XHR o Accept: application/json)
$request->wantsJson();     // alias de expectsJson()

Más info

6. Helpers de String y Array

use Illuminate\Support\Str;
use Illuminate\Support\Arr;

// Strings
Str::slug('Hello World!');             // 'hello-world'
Str::camel('hello_world');             // 'helloWorld'
Str::studly('hello_world');            // 'HelloWorld'
Str::snake('helloWorld');              // 'hello_world'
Str::title('hello world');             // 'Hello World'
Str::limit('Texto largo...', 50);      // trunca añadiendo '...'
Str::contains('Hello', 'ell');         // true
Str::startsWith('Hello', 'He');        // true
Str::endsWith('Hello', 'lo');          // true
Str::uuid();                            // genera un UUID
Str::random(32);                        // string aleatorio

// Arrays
Arr::get($array, 'user.name', 'default');  // acceso con notación de puntos y valor por defecto
Arr::set($array, 'user.name', 'Jane');     // asignación con notación de puntos
Arr::forget($array, 'user.password');      // elimina con notación de puntos
Arr::only($array, ['id', 'name']);         // conserva solo estas claves
Arr::except($array, ['password']);         // elimina estas claves
Arr::pluck($array, 'name', 'id');          // extrae una columna, indexada por otra
Arr::flatten($nested);                     // aplana arrays anidados un nivel
Arr::wrap(null);                           // [] - envuelve un escalar en un array, deja pasar los arrays
Arr::first($array, fn($v) => $v > 10);    // primer elemento que cumple el callback

Más info sobre Str · Más info sobre Arr

---

Too long, didn’t read, lol!

Para resumir lo que hemos aprendido hoy:

1. tap() — mete un efecto secundario sin interrumpir la cadena de ejecución ni necesitar una variable intermedia.
2. rescue() — sustituye un try/catch cuando solo quieres un valor por defecto si algo falla.
3. optional() — accede a propiedades o métodos de un valor que puede ser null sin que reviente.
4. blank() / filled() — comprueban si un valor está “vacío” de forma consistente entre tipos, mejor que empty().
5. Métodos de Request — has, filled, boolean, integer, only, except y expectsJson cubren casi todo lo que necesitas sin tocar $request->all() a pelo.
6. Str y Arr — decenas de helpers para transformar strings y manipular arrays con notación de puntos (dot notation), en vez de reinventarlos con funciones nativas de PHP.