Helpers

• Introducción
• Métodos Disponibles
• Otras Utilidades
  • Evaluación de Rendimiento
  • Fechas
  • Lotería
  • Pipeline
  • Sleep

Introducción

Laravel incluye una variedad de funciones globales "helper" de PHP. Muchas de estas funciones son utilizadas por el propio marco; sin embargo, eres libre de usarlas en tus propias aplicaciones si las encuentras convenientes.

Métodos Disponibles

Arrays y Objetos

Rutas

URLs

Misceláneo

Arrays y Objetos

Arr::accessible()

El método Arr::accessible determina si el valor dado es accesible como array:

use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
 
$isAccessible = Arr::accessible(['a' => 1, 'b' => 2]);
 
// true
 
$isAccessible = Arr::accessible(new Collection);
 
// true
 
$isAccessible = Arr::accessible('abc');
 
// false
 
$isAccessible = Arr::accessible(new stdClass);
 
// false

Arr::add()

El método Arr::add agrega un par clave / valor dado a un array si la clave dada aún no existe en el array o está establecida en null:

use Illuminate\Support\Arr;
 
$array = Arr::add(['name' => 'Desk'], 'price', 100);
 
// ['name' => 'Desk', 'price' => 100]
 
$array = Arr::add(['name' => 'Desk', 'price' => null], 'price', 100);
 
// ['name' => 'Desk', 'price' => 100]

Arr::collapse()

El método Arr::collapse colapsa un array de arrays en un solo array:

use Illuminate\Support\Arr;
 
$array = Arr::collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
 
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

Arr::crossJoin()

El método Arr::crossJoin realiza un cruce entre los arrays dados, devolviendo un producto cartesiano con todas las posibles permutaciones:

use Illuminate\Support\Arr;
 
$matrix = Arr::crossJoin([1, 2], ['a', 'b']);
 
/*
    [
        [1, 'a'],
        [1, 'b'],
        [2, 'a'],
        [2, 'b'],
    ]
*/
 
$matrix = Arr::crossJoin([1, 2], ['a', 'b'], ['I', 'II']);
 
/*
    [
        [1, 'a', 'I'],
        [1, 'a', 'II'],
        [1, 'b', 'I'],
        [1, 'b', 'II'],
        [2, 'a', 'I'],
        [2, 'a', 'II'],
        [2, 'b', 'I'],
        [2, 'b', 'II'],
    ]
*/

Arr::divide()

El método Arr::divide devuelve dos arrays: uno que contiene las claves y el otro que contiene los valores del array dado:

use Illuminate\Support\Arr;
 
[$keys, $values] = Arr::divide(['name' => 'Desk']);
 
// $keys: ['name']
 
// $values: ['Desk']

Arr::dot()

El método Arr::dot aplana un array multidimensional en un array de un solo nivel que utiliza la notación "punto" para indicar la profundidad:

use Illuminate\Support\Arr;
 
$array = ['products' => ['desk' => ['price' => 100]]];
 
$flattened = Arr::dot($array);
 
// ['products.desk.price' => 100]

Arr::except()

El método Arr::except elimina los pares clave / valor dados de un array:

use Illuminate\Support\Arr;
 
$array = ['name' => 'Desk', 'price' => 100];
 
$filtered = Arr::except($array, ['price']);
 
// ['name' => 'Desk']

Arr::exists()

El método Arr::exists comprueba que la clave dada existe en el array proporcionado:

use Illuminate\Support\Arr;
 
$array = ['name' => 'John Doe', 'age' => 17];
 
$exists = Arr::exists($array, 'name');
 
// true
 
$exists = Arr::exists($array, 'salary');
 
// false

Arr::first()

El método Arr::first devuelve el primer elemento de un array que pasa una prueba de verdad dada:

use Illuminate\Support\Arr;
 
$array = [100, 200, 300];
 
$first = Arr::first($array, function (int $value, int $key) {
    return $value >= 150;
});
 
// 200

También se puede pasar un valor predeterminado como tercer parámetro al método. Este valor se devolverá si ningún valor pasa la prueba de verdad:

use Illuminate\Support\Arr;
 
$first = Arr::first($array, $callback, $default);

Arr::flatten()

El método Arr::flatten aplana un array multidimensional en un array de un solo nivel:

use Illuminate\Support\Arr;
 
$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];
 
$flattened = Arr::flatten($array);
 
// ['Joe', 'PHP', 'Ruby']

Arr::forget()

El método Arr::forget elimina un par clave / valor dado de un array profundamente anidado utilizando la notación "punto":

use Illuminate\Support\Arr;
 
$array = ['products' => ['desk' => ['price' => 100]]];
 
Arr::forget($array, 'products.desk');
 
// ['products' => []]

Arr::get()

El método Arr::get recupera un valor de un array profundamente anidado utilizando la notación "punto":

use Illuminate\Support\Arr;
 
$array = ['products' => ['desk' => ['price' => 100]]];
 
$price = Arr::get($array, 'products.desk.price');
 
// 100

El método Arr::get también acepta un valor predeterminado, que se devolverá si la clave especificada no está presente en el array:

use Illuminate\Support\Arr;
 
$discount = Arr::get($array, 'products.desk.discount', 0);
 
// 0

Arr::has()

El método Arr::has comprueba si un elemento o elementos dados existen en un array utilizando la notación "punto":

use Illuminate\Support\Arr;
 
$array = ['product' => ['name' => 'Desk', 'price' => 100]];
 
$contains = Arr::has($array, 'product.name');
 
// true
 
$contains = Arr::has($array, ['product.price', 'product.discount']);
 
// false

Arr::hasAny()

El método Arr::hasAny comprueba si algún elemento en un conjunto dado existe en un array utilizando la notación "punto":

use Illuminate\Support\Arr;
 
$array = ['product' => ['name' => 'Desk', 'price' => 100]];
 
$contains = Arr::hasAny($array, 'product.name');
 
// true
 
$contains = Arr::hasAny($array, ['product.name', 'product.discount']);
 
// true
 
$contains = Arr::hasAny($array, ['category', 'product.discount']);
 
// false

Arr::isAssoc()

El método Arr::isAssoc devuelve true si el array dado es un array asociativo. Un array se considera "asociativo" si no tiene claves numéricas secuenciales que comiencen desde cero:

use Illuminate\Support\Arr;
 
$isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]);
 
// true
 
$isAssoc = Arr::isAssoc([1, 2, 3]);
 
// false

Arr::isList()

El método Arr::isList devuelve true si las claves del array dado son enteros secuenciales que comienzan desde cero:

use Illuminate\Support\Arr;
 
$isList = Arr::isList(['foo', 'bar', 'baz']);
 
// true
 
$isList = Arr::isList(['product' => ['name' => 'Desk', 'price' => 100]]);
 
// false

Arr::join()

El método Arr::join une los elementos del array con una cadena. Usando el segundo argumento de este método, también puedes especificar la cadena de unión para el último elemento del array:

use Illuminate\Support\Arr;
 
$array = ['Tailwind', 'Alpine', 'Laravel', 'Livewire'];
 
$joined = Arr::join($array, ', ');
 
// Tailwind, Alpine, Laravel, Livewire
 
$joined = Arr::join($array, ', ', ' and ');
 
// Tailwind, Alpine, Laravel and Livewire

Arr::keyBy()

El método Arr::keyBy indexa el array por la clave dada. Si varios elementos tienen la misma clave, solo aparecerá el último en el nuevo array:

use Illuminate\Support\Arr;
 
$array = [
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
];
 
$keyed = Arr::keyBy($array, 'product_id');
 
/*
    [
        'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

Arr::last()

El método Arr::last devuelve el último elemento de un array que pasa una prueba de verdad dada:

use Illuminate\Support\Arr;
 
$array = [100, 200, 300, 110];
 
$last = Arr::last($array, function (int $value, int $key) {
    return $value >= 150;
});
 
// 300

Se puede pasar un valor predeterminado como tercer argumento al método. Este valor se devolverá si ningún valor pasa la prueba de verdad:

use Illuminate\Support\Arr;
 
$last = Arr::last($array, $callback, $default);

Arr::map()

El método Arr::map itera a través del array y pasa cada valor y clave al retorno de llamada dado. El valor del array se reemplaza por el valor devuelto por el retorno de llamada:

use Illuminate\Support\Arr;
 
$array = ['first' => 'james', 'last' => 'kirk'];
 
$mapped = Arr::map($array, function (string $value, string $key) {
    return ucfirst($value);
});
 
// ['first' => 'James', 'last' => 'Kirk']

Arr::mapWithKeys()

El método Arr::mapWithKeys itera a través del array y pasa cada valor al retorno de llamada dado. El retorno de llamada debe devolver un array asociativo que contenga un solo par clave / valor:

use Illuminate\Support\Arr;
 
$array = [
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => '[email protected]',
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => '[email protected]',
    ]
];
 
$mapped = Arr::mapWithKeys($array, function (array $item, int $key) {
    return [$item['email'] => $item['name']];
});
 
/*
    [
        '[email protected]' => 'John',
        '[email protected]' => 'Jane',
    ]
*/

Arr::only()

El método Arr::only devuelve solo los pares clave / valor especificados del array dado:

use Illuminate\Support\Arr;
 
$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
 
$slice = Arr::only($array, ['name', 'price']);
 
// ['name' => 'Desk', 'price' => 100]

Arr::pluck()

El método Arr::pluck recupera todos los valores de una clave dada de un array:

use Illuminate\Support\Arr;
 
$array = [
    ['developer' => ['id' => 1, 'name' => 'Taylor']],
    ['developer' => ['id' => 2, 'name' => 'Abigail']],
];
 
$names = Arr::pluck($array, 'developer.name');
 
// ['Taylor', 'Abigail']

También puedes especificar cómo deseas que se clave la lista resultante:

use Illuminate\Support\Arr;
 
$names = Arr::pluck($array, 'developer.name', 'developer.id');
 
// [1 => 'Taylor', 2 => 'Abigail']

Arr::prepend()

El método Arr::prepend agregará un elemento al principio de un array:

use Illuminate\Support\Arr;
 
$array = ['one', 'two', 'three', 'four'];
 
$array = Arr::prepend($array, 'zero');
 
// ['zero', 'one', 'two', 'three', 'four']

Si es necesario, puedes especificar la clave que se debe usar para el valor:

use Illuminate\Support\Arr;
 
$array = ['price' => 100];
 
$array = Arr::prepend($array, 'Desk', 'name');
 
// ['name' => 'Desk', 'price' => 100]

Arr::prependKeysWith()

El método Arr::prependKeysWith agrega un prefijo a todos los nombres de clave de un array asociativo:

use Illuminate\Support\Arr;
 
$array = [
    'name' => 'Desk',
    'price' => 100,
];
 
$keyed = Arr::prependKeysWith($array, 'product.');
 
/*
    [
        'product.name' => 'Desk',
        'product.price' => 100,
    ]
*/

Arr::pull()

El método Arr::pull devuelve y elimina un par clave / valor de un array:

use Illuminate\Support\Arr;
 
$array = ['name' => 'Desk', 'price' => 100];
 
$name = Arr::pull($array, 'name');
 
// $name: Desk
 
// $array: ['price' => 100]

Se puede pasar un valor predeterminado como tercer argumento al método. Este valor se devolverá si la clave no existe:

use Illuminate\Support\Arr;
 
$value = Arr::pull($array, $key, $default);

Arr::query()

El método Arr::query convierte el array en una cadena de consulta:

use Illuminate\Support\Arr;
 
$array = [
    'name' => 'Taylor',
    'order' => [
        'column' => 'created_at',
        'direction' => 'desc'
    ]
];
 
Arr::query($array);
 
// name=Taylor&order[column]=created_at&order[direction]=desc

Arr::random()

El método Arr::random devuelve un valor aleatorio de un array:

use Illuminate\Support\Arr;
 
$array = [1, 2, 3, 4, 5];
 
$random = Arr::random($array);
 
// 4 - (retrieved randomly)

También puedes especificar la cantidad de elementos a devolver como segundo argumento opcional. Ten en cuenta que proporcionar este argumento devolverá un array incluso si solo se desea un elemento:

use Illuminate\Support\Arr;
 
$items = Arr::random($array, 2);
 
// [2, 5] - (retrieved randomly)

Arr::set()

El método Arr::set establece un valor dentro de un array profundamente anidado utilizando la notación "punto":

use Illuminate\Support\Arr;
 
$array = ['products' => ['desk' => ['price' => 100]]];
 
Arr::set($array, 'products.desk.price', 200);
 
// ['products' => ['desk' => ['price' => 200]]]

Arr::shuffle()

El método Arr::shuffle mezcla aleatoriamente los elementos en el array:

use Illuminate\Support\Arr;
 
$array = Arr::shuffle([1, 2, 3, 4, 5]);
 
// [3, 2, 5, 1, 4] - (generated randomly)

Arr::sort()

El método Arr::sort ordena un array por sus valores:

use Illuminate\Support\Arr;
 
$array = ['Desk', 'Table', 'Chair'];
 
$sorted = Arr::sort($array);
 
// ['Chair', 'Desk', 'Table']

También puedes ordenar el array por los resultados de un cierre dado:

use Illuminate\Support\Arr;
 
$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];
 
$sorted = array_values(Arr::sort($array, function (array $value) {
    return $value['name'];
}));
 
/*
    [
        ['name' => 'Chair'],
        ['name' => 'Desk'],
        ['name' => 'Table'],
    ]
*/

Arr::sortDesc()

El método Arr::sortDesc ordena un array en orden descendente por sus valores:

use Illuminate\Support\Arr;
 
$array = ['Desk', 'Table', 'Chair'];
 
$sorted = Arr::sortDesc($array);
 
// ['Table', 'Desk', 'Chair']

También puedes ordenar el array por los resultados de un cierre dado:

use Illuminate\Support\Arr;
 
$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];
 
$sorted = array_values(Arr::sortDesc($array, function (array $value) {
    return $value['name'];
}));
 
/*
    [
        ['name' => 'Table'],
        ['name' => 'Desk'],
        ['name' => 'Chair'],
    ]
*/

Arr::sortRecursive()

El método Arr::sortRecursive ordena recursivamente un array utilizando la función sort para subarrays indexados numéricamente y la función ksort para subarrays asociativos:

use Illuminate\Support\Arr;
 
$array = [
    ['Roman', 'Taylor', 'Li'],
    ['PHP', 'Ruby', 'JavaScript'],
    ['one' => 1, 'two' => 2, 'three' => 3],
];
 
$sorted = Arr::sortRecursive($array);
 
/*
    [
        ['JavaScript', 'PHP', 'Ruby'],
        ['one' => 1, 'three' => 3, 'two' => 2],
        ['Li', 'Roman', 'Taylor'],
    ]
*/

Si deseas que los resultados se ordenen en orden descendente, puedes usar el método Arr::sortRecursiveDesc.

$sorted = Arr::sortRecursiveDesc($array);

Arr::toCssClasses()

El método Arr::toCssClasses compila condicionalmente una cadena de clases CSS. El método acepta un array de clases donde la clave del array contiene la clase o clases que deseas agregar, mientras que el valor es una expresión booleana. Si el elemento del array tiene una clave numérica, siempre se incluirá en la lista de clases renderizadas:

use Illuminate\Support\Arr;
 
$isActive = false;
$hasError = true;
 
$array = ['p-4', 'font-bold' => $isActive, 'bg-red' => $hasError];
 
$classes = Arr::toCssClasses($array);
 
/*
    'p-4 bg-red'
*/

Arr::toCssStyles()

El método Arr::toCssStyles compila condicionalmente una cadena de estilos CSS. El método acepta un array de estilos donde la clave del array contiene el estilo o estilos que deseas agregar, mientras que el valor es una expresión booleana. Si el elemento del array tiene una clave numérica, siempre se incluirá en la lista de estilos renderizados:

$hasColor = true;
 
$array = ['background-color: blue', 'color: blue' => $hasColor];
 
$classes = Arr::toCssStyles($array);
 
/*
    'background-color: blue; color: blue;'
*/

Este método impulsa la funcionalidad de Laravel que permite fusionar clases con la bolsa de atributos de un componente Blade así como la directiva Blade @class.

Arr::undot()

El método Arr::undot expande un array unidimensional que utiliza la notación "punto" en un array multidimensional:

use Illuminate\Support\Arr;
 
$array = [
    'user.name' => 'Kevin Malone',
    'user.occupation' => 'Accountant',
];
 
$array = Arr::undot($array);
 
// ['user' => ['name' => 'Kevin Malone', 'occupation' => 'Accountant']]

Arr::where()

El método Arr::where filtra un array utilizando el cierre dado:

use Illuminate\Support\Arr;
 
$array = [100, '200', 300, '400', 500];
 
$filtered = Arr::where($array, function (string|int $value, int $key) {
    return is_string($value);
});
 
// [1 => '200', 3 => '400']

Arr::whereNotNull()

El método Arr::whereNotNull elimina todos los valores null del array dado:

use Illuminate\Support\Arr;
 
$array = [0, null];
 
$filtered = Arr::whereNotNull($array);
 
// [0 => 0]

Arr::wrap()

El método Arr::wrap envuelve el valor dado en un array. Si el valor dado ya es un array, se devolverá sin modificación:

use Illuminate\Support\Arr;
 
$string = 'Laravel';
 
$array = Arr::wrap($string);
 
// ['Laravel']

Si el valor dado es null, se devolverá un array vacío:

use Illuminate\Support\Arr;
 
$array = Arr::wrap(null);
 
// []

data_fill()

La función data_fill establece un valor faltante dentro de un array o objeto anidado utilizando la notación "punto":

$data = ['products' => ['desk' => ['price' => 100]]];
 
data_fill($data, 'products.desk.price', 200);
 
// ['products' => ['desk' => ['price' => 100]]]
 
data_fill($data, 'products.desk.discount', 10);
 
// ['products' => ['desk' => ['price' => 100, 'discount' => 10]]]

Esta función también acepta asteriscos como comodines y llenará el destino en consecuencia:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2'],
    ],
];
 
data_fill($data, 'products.*.price', 200);
 
/*
    [
        'products' => [
            ['name' => 'Desk 1', 'price' => 100],
            ['name' => 'Desk 2', 'price' => 200],
        ],
    ]
*/

data_get()

La función data_get recupera un valor de un array o objeto anidado utilizando la notación "punto":

$data = ['products' => ['desk' => ['price' => 100]]];
 
$price = data_get($data, 'products.desk.price');
 
// 100

La función data_get también acepta un valor predeterminado, que se devolverá si no se encuentra la clave especificada:

$discount = data_get($data, 'products.desk.discount', 0);
 
// 0

La función también acepta comodines usando asteriscos, que pueden apuntar a cualquier clave del array u objeto:

$data = [
    'product-one' => ['name' => 'Desk 1', 'price' => 100],
    'product-two' => ['name' => 'Desk 2', 'price' => 150],
];
 
data_get($data, '*.name');
 
// ['Desk 1', 'Desk 2'];

data_set()

La función data_set establece un valor dentro de un array o objeto anidado utilizando la notación "punto":

$data = ['products' => ['desk' => ['price' => 100]]];
 
data_set($data, 'products.desk.price', 200);
 
// ['products' => ['desk' => ['price' => 200]]]

Esta función también acepta comodines usando asteriscos y establecerá valores en el destino en consecuencia:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2', 'price' => 150],
    ],
];
 
data_set($data, 'products.*.price', 200);
 
/*
    [
        'products' => [
            ['name' => 'Desk 1', 'price' => 200],
            ['name' => 'Desk 2', 'price' => 200],
        ],
    ]
*/

Por defecto, se sobrescriben los valores existentes. Si deseas establecer un valor solo si no existe, puedes pasar false como cuarto argumento a la función:

$data = ['products' => ['desk' => ['price' => 100]]];
 
data_set($data, 'products.desk.price', 200, overwrite: false);
 
// ['products' => ['desk' => ['price' => 100]]]

data_forget()

La función data_forget elimina un valor dentro de un array o un objeto anidado utilizando la notación "dot":

$data = ['products' => ['desk' => ['price' => 100]]];
 
data_forget($data, 'products.desk.price');
 
// ['products' => ['desk' => []]]

Esta función también acepta comodines usando asteriscos y eliminará valores en el destino en consecuencia:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2', 'price' => 150],
    ],
];
 
data_forget($data, 'products.*.price');
 
/*
    [
        'products' => [
            ['name' => 'Desk 1'],
            ['name' => 'Desk 2'],
        ],
    ]
*/

head()

La función head devuelve el primer elemento en el array dado:

$array = [100, 200, 300];
 
$first = head($array);
 
// 100

last()

La función last devuelve el último elemento en el array dado:

$array = [100, 200, 300];
 
$last = last($array);
 
// 300

Rutas

app_path()

La función app_path devuelve la ruta completamente calificada al directorio app de tu aplicación. También puedes usar la función app_path para generar una ruta completamente calificada a un archivo relativo al directorio de la aplicación:

$path = app_path();
 
$path = app_path('Http/Controllers/Controller.php');

base_path()

La función base_path devuelve la ruta completamente calificada al directorio raíz de tu aplicación. También puedes usar la función base_path para generar una ruta completamente calificada a un archivo dado relativo al directorio raíz del proyecto:

$path = base_path();
 
$path = base_path('vendor/bin');

config_path()

La función config_path devuelve la ruta completamente calificada al directorio config de tu aplicación. También puedes usar la función config_path para generar una ruta completamente calificada a un archivo dado dentro del directorio de configuración de la aplicación:

$path = config_path();
 
$path = config_path('app.php');

database_path()

La función database_path devuelve la ruta completamente calificada al directorio database de tu aplicación. También puedes usar la función database_path para generar una ruta completamente calificada a un archivo dado dentro del directorio de la base de datos:

$path = database_path();
 
$path = database_path('factories/UserFactory.php');

lang_path()

La función lang_path devuelve la ruta completamente calificada al directorio lang de tu aplicación. También puedes usar la función lang_path para generar una ruta completamente calificada a un archivo dado dentro del directorio:

$path = lang_path();
 
$path = lang_path('en/messages.php');

Nota Por defecto, el esqueleto de la aplicación Laravel no incluye el directorio lang. Si deseas personalizar los archivos de idioma de Laravel, puedes publicarlos mediante el comando Artisan lang:publish.

mix()

La función mix devuelve la ruta a un archivo Mix versionado:

$path = mix('css/app.css');

public_path()

La función public_path devuelve la ruta completamente calificada al directorio public de tu aplicación. También puedes usar la función public_path para generar una ruta completamente calificada a un archivo dado dentro del directorio público:

$path = public_path();
 
$path = public_path('css/app.css');

resource_path()

La función resource_path devuelve la ruta completamente calificada al directorio resources de tu aplicación. También puedes usar la función resource_path para generar una ruta completamente calificada a un archivo dado dentro del directorio de recursos:

$path = resource_path();
 
$path = resource_path('sass/app.scss');

storage_path()

La función storage_path devuelve la ruta completamente calificada al directorio storage de tu aplicación. También puedes usar la función storage_path para generar una ruta completamente calificada a un archivo dado dentro del directorio de almacenamiento:

$path = storage_path();
 
$path = storage_path('app/file.txt');

URLs

action()

La función action genera una URL para la acción dada del controlador:

use App\Http\Controllers\HomeController;
 
$url = action([HomeController::class, 'index']);

Si el método acepta parámetros de ruta, puedes pasarlos como segundo argumento al método:

$url = action([UserController::class, 'profile'], ['id' => 1]);

asset()

La función asset genera una URL para un recurso utilizando el esquema actual de la solicitud (HTTP o HTTPS):

$url = asset('img/photo.jpg');

Puedes configurar el host de la URL del recurso estableciendo la variable ASSET_URL en tu archivo .env. Esto puede ser útil si alojas tus recursos en un servicio externo como Amazon S3 u otro CDN:

// ASSET_URL=http://example.com/assets
 
$url = asset('img/photo.jpg'); // http://example.com/assets/img/photo.jpg

route()

La función route genera una URL para una ruta con nombre dada:

$url = route('route.name');

Si la ruta acepta parámetros, puedes pasarlos como segundo argumento a la función:

$url = route('route.name', ['id' => 1]);

Por defecto, la función route genera una URL absoluta. Si deseas generar una URL relativa, puedes pasar false como tercer argumento a la función:

$url = route('route.name', ['id' => 1], false);

secure_asset()

La función secure_asset genera una URL para un recurso utilizando HTTPS:

$url = secure_asset('img/photo.jpg');

secure_url()

La función secure_url genera una URL HTTPS completamente calificada para el camino dado. Se pueden pasar segmentos de URL adicionales en el segundo argumento de la función:

$url = secure_url('user/profile');
 
$url = secure_url('user/profile', [1]);

to_route()

La función to_route genera una respuesta HTTP de redirección para una ruta con nombre dada:

return to_route('users.show', ['user' => 1]);

Si es necesario, puedes pasar el código de estado HTTP que se asignará a la redirección y cualquier encabezado de respuesta adicional como tercer y cuarto argumento al método to_route:

return to_route('users.show', ['user' => 1], 302, ['X-Framework' => 'Laravel']);

url()

La función url genera una URL completamente calificada para el camino dado:

$url = url('user/profile');
 
$url = url('user/profile', [1]);

Si no se proporciona ningún camino, se devuelve una instancia de Illuminate\Routing\UrlGenerator:

$current = url()->current();
 
$full = url()->full();
 
$previous = url()->previous();

Misceláneo

abort()

La función abort lanza una excepción HTTP que será renderizada por el manejador de excepciones:

abort(403);

También puedes proporcionar el mensaje de la excepción y encabezados de respuesta HTTP personalizados que se enviarán al navegador:

abort(403, 'Unauthorized.', $headers);

abort_if()

La función abort_if lanza una excepción HTTP si una expresión booleana dada se evalúa como true:

abort_if(! Auth::user()->isAdmin(), 403);

Al igual que el método abort, también puedes proporcionar el texto de respuesta de la excepción como tercer argumento y un array de encabezados de respuesta personalizados como cuarto argumento a la función.

abort_unless()

La función abort_unless lanza una excepción HTTP si una expresión booleana dada se evalúa como false:

abort_unless(Auth::user()->isAdmin(), 403);

Al igual que el método abort, también puedes proporcionar el texto de respuesta de la excepción como tercer argumento y un array de encabezados de respuesta personalizados como cuarto argumento a la función.

app()

La función app devuelve la instancia del contenedor de servicios:

$container = app();

Puedes pasar un nombre de clase o interfaz para resolverlo desde el contenedor:

$api = app('HelpSpot\API');

auth()

La función auth devuelve una instancia autenticadora. Puedes usarla como alternativa a la fachada Auth:

$user = auth()->user();

Si es necesario, puedes especificar qué instancia de guardia te gustaría acceder:

$user = auth('admin')->user();

back()

La función back genera una respuesta HTTP de redirección a la ubicación anterior del usuario:

return back($status = 302, $headers = [], $fallback = '/');
 
return back();

bcrypt()

La función bcrypt hashes el valor dado utilizando Bcrypt. Puedes usar esta función como alternativa a la fachada Hash:

$password = bcrypt('my-secret-password');

blank()

La función blank determina si el valor dado está "en blanco":

blank('');
blank('   ');
blank(null);
blank(collect());
 
// true
 
blank(0);
blank(true);
blank(false);
 
// false

Para la inversa de blank, consulta el método filled.

broadcast()

La función broadcast transmite el evento dado a sus escuchadores:

broadcast(new UserRegistered($user));
 
broadcast(new UserRegistered($user))->toOthers();

cache()

La función cache se puede utilizar para obtener valores de la caché. Si la clave dada no existe en la caché, se devolverá un valor predeterminado opcional:

$value = cache('key');
 
$value = cache('key', 'default');

Puedes agregar elementos a la caché pasando un array de pares clave / valor a la función. También debes pasar el número de segundos o la duración durante la cual se considerará válido el valor almacenado en caché:

cache(['key' => 'value'], 300);
 
cache(['key' => 'value'], now()->addSeconds(10));

class_uses_recursive()

La función class_uses_recursive devuelve todos los traits utilizados por una clase, incluyendo traits utilizados por todas sus clases padre:

$traits = class_uses_recursive(App\Models\User::class);

collect()

La función collect crea una instancia de colección a partir del valor dado:

$collection = collect(['taylor', 'abigail']);

config()

La función config obtiene el valor de una variable de configuración. Los valores de configuración se pueden acceder mediante la sintaxis "dot", que incluye el nombre del archivo y la opción que deseas acceder. Se puede especificar un valor predeterminado y se devolverá si la opción de configuración no existe:

$value = config('app.timezone');
 
$value = config('app.timezone', $default);

Puedes establecer variables de configuración en tiempo de ejecución pasando un array de pares clave / valor. Sin embargo, ten en cuenta que esta función solo afecta al valor de configuración para la solicitud actual y no actualiza tus valores de configuración reales:

config(['app.debug' => true]);

cookie()

La función cookie crea una nueva instancia de cookie:

$cookie = cookie('name', 'value', $minutes);

csrf_field()

La función csrf_field genera un campo de entrada HTML hidden que contiene el valor del token CSRF. Por ejemplo, usando sintaxis de Blade:

{{ csrf_field() }}

csrf_token()

La función csrf_token obtiene el valor del token CSRF actual:

$token = csrf_token();

decrypt()

La función decrypt descifra el valor dado. Puedes usar esta función como alternativa a la fachada Crypt:

$password = decrypt($value);

dd()

La función dd muestra las variables dadas y finaliza la ejecución del script:

dd($value);
 
dd($value1, $value2, $value3, ...);

Si no deseas detener la ejecución de tu script, usa la función dump en su lugar.

dispatch()

La función dispatch coloca el trabajo dado en la cola de trabajos de Laravel:

dispatch(new App\Jobs\SendEmails);

dispatch_sync()

La función dispatch_sync coloca el trabajo dado en la cola sync para que se procese inmediatamente:

dispatch_sync(new App\Jobs\SendEmails);

dump()

La función dump muestra las variables dadas:

dump($value);
 
dump($value1, $value2, $value3, ...);

Si deseas detener la ejecución del script después de mostrar las variables, usa la función dd en su lugar.

encrypt()

La función encrypt cifra el valor dado. Puedes usar esta función como alternativa a la fachada Crypt:

$secret = encrypt('my-secret-value');

env()

La función env obtiene el valor de una variable de entorno o devuelve un valor predeterminado:

$env = env('APP_ENV');
 
$env = env('APP_ENV', 'production');

Advertencia Si ejecutas el comando config:cache durante tu proceso de implementación, asegúrate de que solo estás llamando a la función env desde tus archivos de configuración. Una vez que la configuración ha sido almacenada en caché, el archivo .env no se cargará y todas las llamadas a la función env devolverán null.

event()

La función event despacha el evento dado a sus escuchadores:

event(new UserRegistered($user));

fake()

La función fake resuelve una instancia de Faker desde el contenedor, lo cual puede ser útil al crear datos falsos en fábricas de modelos, en la siembra de la base de datos, en pruebas y en prototipos de vistas:

@for($i = 0; $i < 10; $i++)
    <dl>
        <dt>Name</dt>
        <dd>{{ fake()->name() }}</dd>
 
        <dt>Email</dt>
        <dd>{{ fake()->unique()->safeEmail() }}</dd>
    </dl>
@endfor

Por defecto, la función fake utilizará la opción de configuración app.faker_locale en tu archivo de configuración config/app.php; sin embargo, también puedes especificar el idioma pasándolo a la función fake. Cada idioma resolverá un singleton individual:

fake('nl_NL')->name()

filled()

La función filled determina si el valor dado no está "en blanco":

filled(0);
filled(true);
filled(false);
 
// true
 
filled('');
filled('   ');
filled(null);
filled(collect());
 
// false

Para la inversa de filled, consulta el método blank.

info()

La función info escribirá información en el registro de tu aplicación:

info('Some helpful information!');

También se puede pasar un array de datos contextuales a la función:

info('User login attempt failed.', ['id' => $user->id]);

logger()

La función logger se puede utilizar para escribir un mensaje de nivel debug en el registro:

logger('Debug message');

También se puede pasar un array de datos contextuales a la función:

logger('User has logged in.', ['id' => $user->id]);

Se devolverá una instancia de registro si no se pasa ningún valor a la función:

logger()->error('You are not allowed here.');

method_field()

La función method_field genera un campo de entrada HTML hidden que contiene el valor simulado del verbo HTTP del formulario. Por ejemplo, usando sintaxis de Blade:

<form method="POST">
    {{ method_field('DELETE') }}
</form>

now()

La función now crea una nueva instancia de Illuminate\Support\Carbon para la hora actual:

$now = now();

old()

La función old recupera un valor de entrada antiguo intermitente en la sesión:

$value = old('value');
 
$value = old('value', 'default');

Dado que el "valor predeterminado" proporcionado como segundo argumento a la función old suele ser un atributo de un modelo Eloquent, Laravel te permite simplemente pasar el modelo Eloquent completo como segundo argumento a la función old. Al hacerlo, Laravel asumirá que el primer argumento proporcionado a la función old es el nombre del atributo Eloquent que debe considerarse como el "valor predeterminado":

{{ old('name', $user->name) }}
 
// Equivalente a...
 
{{ old('name', $user) }}

optional()

La función optional acepta cualquier argumento y te permite acceder a propiedades o llamar a métodos en ese objeto. Si el objeto dado es null, las propiedades y métodos devolverán null en lugar de causar un error:

return optional($user->address)->street;
 
{!! old('name', optional($user)->name) !!}

La función optional también acepta un cierre como segundo argumento. El cierre se invocará si el valor proporcionado como primer argumento no es nulo:

return optional(User::find($id), function (User $user) {
    return $user->name;
});

policy()

El método policy recupera una instancia de política para una clase dada:

$policy = policy(App\Models\User::class);

redirect()

La función redirect devuelve una respuesta HTTP de redirección o devuelve la instancia de redirección si se llama sin argumentos:

return redirect($to = null, $status = 302, $headers = [], $https = null);
 
return redirect('/home');
 
return redirect()->route('route.name');

report()

La función report informará de una excepción usando tu manejador de excepciones:

report($e);

La función report también acepta una cadena como argumento. Cuando se proporciona una cadena a la función, la función creará una excepción con la cadena dada como su mensaje:

report('Something went wrong.');

report_if()

La función report_if informará de una excepción usando tu manejador de excepciones si la condición dada es true:

report_if($shouldReport, $e);
 
report_if($shouldReport, 'Something went wrong.');

report_unless()

La función report_unless informará de una excepción usando tu manejador de excepciones si la condición dada es false:

report_unless($reportingDisabled, $e);
 
report_unless($reportingDisabled, 'Something went wrong.');

request()

La función request devuelve la instancia actual de request u obtiene el valor de un campo de entrada desde la solicitud actual:

$request = request();
 
$value = request('key', $default);

rescue()

La función rescue ejecuta el cierre dado y captura cualquier excepción que ocurra durante su ejecución. Todas las excepciones capturadas se enviarán a tu manejador de excepciones; sin embargo, la solicitud continuará procesándose:

return rescue(function () {
    return $this->method();
});

También puedes pasar un segundo argumento a la función rescue. Este argumento será el valor "predeterminado" que se debe devolver si ocurre una excepción al ejecutar el cierre:

return rescue(function () {
    return $this->method();
}, false);
 
return rescue(function () {
    return $this->method();
}, function () {
    return $this->failure();
});

Se puede proporcionar un argumento report a la función rescue para determinar si la excepción debe informarse mediante la función report:

return rescue(function () {
    return $this->method();
}, report: function (Throwable $throwable) {
    return $throwable instanceof InvalidArgumentException;
});

resolve()

La función resolve resuelve un nombre de clase o interfaz dado a una instancia utilizando el contenedor de servicios:

$api = resolve('HelpSpot\API');

response()

La función response crea una instancia de respuesta o obtiene una instancia del generador de respuestas:

return response('Hello World', 200, $headers);
 
return response()->json(['foo' => 'bar'], 200, $headers);

retry()

La función retry intenta ejecutar el cierre dado hasta que se alcance el umbral máximo de intentos dado. Si el cierre no genera una excepción, se devolverá su valor de retorno. Si el cierre genera una excepción, se intentará automáticamente de nuevo. Si se supera el recuento máximo de intentos, se lanzará la excepción:

return retry(5, function () {
    // Intento 5 veces con un descanso de 100 ms entre intentos...
}, 100);

Si deseas calcular manualmente el número de milisegundos a dormir entre intentos, puedes pasar un cierre como tercer argumento a la función retry:

use Exception;
 
return retry(5, function () {
    // ...
}, function (int $attempt, Exception $exception) {
    return $attempt * 100;
});

Para mayor comodidad, puedes proporcionar un array como primer argumento a la función retry. Este array se utilizará para determinar cuántos milisegundos dormir entre intentos sucesivos:

return retry([100, 200], function () {
    // Duerme durante 100 ms en el primer reintento, 200 ms en el segundo reintento...
});

Para intentar solo bajo condiciones específicas, puedes pasar un cierre como cuarto argumento a la función retry:

use Exception;
 
return retry(5, function () {
    // ...
}, 100, function (Exception $exception) {
    return $exception instanceof RetryException;
});

session()

La función session se puede utilizar para obtener o establecer valores de sesión:

$value = session('key');

Puedes establecer valores pasando un array de pares clave / valor a la función:

session(['chairs' => 7, 'instruments' => 3]);

Se devolverá el almacén de sesiones si no se pasa ningún valor a la función:

$value = session()->get('key');
 
session()->put('key', $value);

tap()

La función tap acepta dos argumentos: un $value arbitrario y un cierre. El $value se pasará al cierre y luego se devolverá por la función tap. El valor de retorno del cierre es irrelevante:

$user = tap(User::first(), function (User $user) {
    $user->name = 'taylor';
 
    $user->save();
});

Si no se pasa un cierre a la función tap, puedes llamar a cualquier método en el $value dado. El valor de retorno del método que llames siempre será $value, independientemente de lo que realmente devuelva el método en su definición. Por ejemplo, el método update de Eloquent suele devolver un entero. Sin embargo, podemos forzar al método a que devuelva el modelo mismo encadenando la llamada al método update a través de la función tap:

$user = tap($user)->update([
    'name' => $name,
    'email' => $email,
]);

Para agregar un método tap a una clase, puedes agregar el rasgo Illuminate\Support\Traits\Tappable a la clase. El método tap de este rasgo acepta un cierre como su único argumento. La instancia del objeto en sí se pasará al cierre y luego se devolverá por el método tap:

return $user->tap(function (User $user) {
    // ...
});

throw_if()

La función throw_if lanza la excepción dada si una expresión booleana dada se evalúa como true:

throw_if(! Auth::user()->isAdmin(), AuthorizationException::class);
 
throw_if(
    ! Auth::user()->isAdmin(),
    AuthorizationException::class,
    'You are not allowed to access this page.'
);

throw_unless()

La función throw_unless lanza la excepción dada si una expresión booleana dada se evalúa como false:

throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);
 
throw_unless(
    Auth::user()->isAdmin(),
    AuthorizationException::class,
    'You are not allowed to access this page.'
);

today()

La función today crea una nueva instancia de Illuminate\Support\Carbon para la fecha actual:

$today = today();

trait_uses_recursive()

La función trait_uses_recursive devuelve todos los traits utilizados por un trait:

$traits = trait_uses_recursive(\Illuminate\Notifications\Notifiable::class);

transform()

La función transform ejecuta un cierre en un valor dado si el valor no está en blanco y luego devuelve el valor de retorno del cierre:

$callback = function (int $value) {
    return $value * 2;
};
 
$result = transform(5, $callback);
 
// 10

Se puede pasar un valor predeterminado o un cierre como tercer argumento a la función. Este valor se devolverá si el valor dado está en blanco:

$result = transform(null, $callback, 'The value is blank');
 
// El valor está en blanco

validator()

La función validator crea una nueva instancia de validador con los argumentos dados. Puedes usarla como alternativa a la fachada Validator:

$validator = validator($data, $rules, $messages);

value()

La función value devuelve el valor que se le da. Sin embargo, si pasas un cierre a la función, se ejecutará el cierre y se devolverá su valor de retorno:

$result = value(true);
 
// true
 
$result = value(function () {
    return false;
});
 
// false

Se pueden pasar argumentos adicionales a la función value. Si el primer argumento es un cierre, los parámetros adicionales se pasarán al cierre como argumentos; de lo contrario, se ignorarán:

$result = value(function (string $name) {
    return $name;
}, 'Taylor');
 
// 'Taylor'

view()

La función view recupera una instancia de vista:

return view('auth.login');

with()

La función with devuelve el valor que se le da. Si se pasa un cierre como segundo argumento a la función, se ejecutará el cierre y se devolverá su valor de retorno:

$callback = function (mixed $value) {
    return is_numeric($value) ? $value * 2 : 0;
};
 
$result = with(5, $callback);
 
// 10
 
$result = with(null, $callback);
 
// 0
 
$result = with(5, null);
 
// 5

Otras Utilidades

Evaluación de Rendimiento

A veces puede que desees probar rápidamente el rendimiento de ciertas partes de tu aplicación. En esas ocasiones, puedes utilizar la clase de soporte Benchmark para medir la cantidad de milisegundos que tardan en completarse las devoluciones de llamada dadas:

<?php
 
use App\Models\User;
use Illuminate\Support\Benchmark;
 
Benchmark::dd(fn () => User::find(1)); // 0.1 ms
 
Benchmark::dd([
    'Scenario 1' => fn () => User::count(), // 0.5 ms
    'Scenario 2' => fn () => User::all()->count(), // 20.0 ms
]);

Por defecto, las devoluciones de llamada dadas se ejecutarán una vez (una iteración), y su duración se mostrará en el navegador / consola.

Para invocar una devolución de llamada más de una vez, puedes especificar el número de iteraciones que se debe invocar la devolución de llamada como segundo argumento al método. Al ejecutar una devolución de llamada más de una vez, la clase Benchmark devolverá la cantidad promedio de milisegundos que tardó en ejecutar la devolución de llamada en todas las iteraciones:

Benchmark::dd(fn () => User::count(), iterations: 10); // 0.5 ms

A veces, es posible que desees probar el rendimiento de la ejecución de una devolución de llamada mientras aún obtienes el valor devuelto por la devolución de llamada. El método value devolverá una tupla que contiene el valor devuelto por la devolución de llamada y la cantidad de milisegundos que tardó en ejecutar la devolución de llamada:

[$count, $duration] = Benchmark::value(fn () => User::count());

Fechas

Laravel incluye Carbon, una potente biblioteca de manipulación de fechas y horas. Para crear una nueva instancia de Carbon, puedes invocar la función now. Esta función está disponible globalmente dentro de tu aplicación Laravel:

$now = now();

O puedes crear una nueva instancia de Carbon usando la clase Illuminate\Support\Carbon:

use Illuminate\Support\Carbon;
 
$now = Carbon::now();

Para obtener una discusión detallada de Carbon y sus características, consulta la documentación oficial de Carbon.

Lotería

La clase de lotería de Laravel se puede utilizar para ejecutar devoluciones de llamada según un conjunto de probabilidades dados. Esto puede ser particularmente útil cuando solo deseas ejecutar código para un porcentaje de tus solicitudes entrantes:

use Illuminate\Support\Lottery;
 
Lottery::odds(1, 20)
    ->winner(fn () => $user->won())
    ->loser(fn () => $user->lost())
    ->choose();

Puedes combinar la clase de lotería de Laravel con otras características de Laravel. Por ejemplo, es posible que desees informar solo un pequeño porcentaje de consultas lentas a tu manejador de excepciones. Y, dado que la clase de lotería es invocable, podemos pasar una instancia de la clase a cualquier método que acepte funciones llamables:

use Carbon\CarbonInterval;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Lottery;
 
DB::whenQueryingForLongerThan(
    CarbonInterval::seconds(2),
    Lottery::odds(1, 100)->winner(fn () => report('Querying > 2 seconds.')),
);

Pruebas de Lotería

Laravel proporciona algunos métodos simples que te permiten probar fácilmente las invocaciones de lotería de tu aplicación:

// La lotería siempre ganará...
Lottery::alwaysWin();
 
// La lotería siempre perderá...
Lottery::alwaysLose();
 
// La lotería ganará, luego perderá y finalmente volverá al comportamiento normal...
Lottery::fix([true, false]);
 
// La lotería volverá al comportamiento normal...
Lottery::determineResultsNormally();

Pipeline

La fachada Pipeline de Laravel proporciona una forma conveniente de "conducir" una entrada dada a través de una serie de clases invocables, cierres o funciones llamables, brindando a cada clase la oportunidad de inspeccionar o modificar la entrada e invocar la siguiente función llamable en la canalización:

use Closure;
use App\Models\User;
use Illuminate\Support\Facades\Pipeline;
 
$user = Pipeline::send($user)
            ->through([
                function (User $user, Closure $next) {
                    // ...
 
                    return $next($user);
                },
                function (User $user, Closure $next) {
                    // ...
 
                    return $next($user);
                },
            ])
            ->then(fn (User $user) => $user);

Como puedes ver, cada clase invocable o cierre en la canalización recibe la entrada y un cierre $next. Invocar el cierre $next llamará a la siguiente función llamable en la canalización. Como habrás notado, esto es muy similar a middleware.

Cuando la última función llamable en la canalización invoca el cierre $next, se invocará la función llamable proporcionada al método then. Típicamente, esta función llamable simplemente devolverá la entrada dada.

Por supuesto, como se discutió anteriormente, no estás limitado a proporcionar cierres a tu canalización. También puedes proporcionar clases invocables. Si se proporciona un nombre de clase, la clase se instanciará a través del contenedor de servicios de Laravel, lo que permitirá inyectar dependencias en la clase invocable:

$user = Pipeline::send($user)
            ->through([
                GenerateProfilePhoto::class,
                ActivateSubscription::class,
                SendWelcomeEmail::class,
            ])
            ->then(fn (User $user) => $user);

Sleep

La clase Sleep de Laravel es un envoltorio ligero alrededor de las funciones nativas sleep y usleep de PHP, ofreciendo una mayor testabilidad y, al mismo tiempo, exponiendo una API amigable para el desarrollador para trabajar con el tiempo:

use Illuminate\Support\Sleep;
 
$waiting = true;
 
while ($waiting) {
    Sleep::for(1)->second();
 
    $waiting = /* ... */;
}

La clase Sleep ofrece una variedad de métodos que te permiten trabajar con diferentes unidades de tiempo:

// Pausa la ejecución durante 90 segundos...
Sleep::for(1.5)->minutes();
 
// Pausa la ejecución durante 2 segundos...
Sleep::for(2)->seconds();
 
// Pausa la ejecución durante 500 milisegundos...
Sleep::for(500)->milliseconds();
 
// Pausa la ejecución durante 5,000 microsegundos...
Sleep::for(5000)->microseconds();
 
// Pausa la ejecución hasta un tiempo dado...
Sleep::until(now()->addMinute());
 
// Alias de la función "sleep" nativa de PHP...
Sleep::sleep(2);
 
// Alias de la función "usleep" nativa de PHP...
Sleep::usleep(5000);

Para combinar fácilmente unidades de tiempo, puedes usar el método and:

Sleep::for(1)->second()->and(10)->milliseconds();

Pruebas de Sleep

Al probar código que utiliza la clase Sleep o las funciones nativas de sueño de PHP, tu prueba pausará la ejecución. Como puedes imaginar, esto hace que tu suite de pruebas sea significativamente más lenta. Por ejemplo, imagina que estás probando el siguiente código:

$waiting = /* ... */;
 
$seconds = 1;
 
while ($waiting) {
    Sleep::for($seconds++)->seconds();
 
    $waiting = /* ... */;
}

Normalmente, probar este código llevaría al menos un segundo. Afortunadamente, la clase Sleep nos permite "simular" el sueño para que nuestra suite de pruebas se mantenga rápida:

public function test_it_waits_until_ready()
{
    Sleep::fake();
 
    // ...
}

Cuando falsificas la clase Sleep, se pasa por alto la pausa real de la ejecución, lo que conduce a una prueba sustancialmente más rápida.

Una vez que la clase Sleep ha sido falsificada, es posible hacer afirmaciones sobre los "sueños" esperados que deberían haber ocurrido. Para ilustrar esto, imaginemos que estamos probando código que pausa la ejecución tres veces, con cada pausa aumentando en un segundo. Usando el método assertSequence, podemos afirmar que nuestro código "durmió" durante la cantidad adecuada de tiempo mientras mantenemos nuestra prueba rápida:

public function test_it_checks_if_ready_four_times()
{
    Sleep::fake();
 
    // ...
 
    Sleep::assertSequence([
        Sleep::for(1)->second(),
        Sleep::for(2)->seconds(),
        Sleep::for(3)->seconds(),
    ]);
}

Por supuesto, la clase Sleep ofrece una variedad de otras afirmaciones que puedes usar al hacer pruebas:

use Carbon\CarbonInterval as Duration;
use Illuminate\Support\Sleep;
 
// Asegura que sleep fue llamado 3 veces...
Sleep::assertSleptTimes(3);
 
// Asegura contra la duración de sleep...
Sleep::assertSlept(function (Duration $duration): bool {
    return /* ... */;
}, times: 1);
 
// Asegura que la clase Sleep nunca fue invocada...
Sleep::assertNeverSlept();
 
// Asegura que, incluso si Sleep fue llamado, no ocurrió ninguna pausa en la ejecución...
Sleep::assertInsomniac();

A veces puede ser útil realizar una acción cada vez que ocurre un falso sueño en el código de tu aplicación. Para lograr esto, puedes proporcionar un retorno de llamada al método whenFakingSleep. En el siguiente ejemplo, usamos las herramientas de manipulación de tiempo de Laravel para avanzar instantáneamente en el tiempo por la duración de cada sueño:

use Carbon\CarbonInterval as Duration;
 
$this->freezeTime();
 
Sleep::fake();
 
Sleep::whenFakingSleep(function (Duration $duration) {
    // Avanza el tiempo al fingir el sleep...
    $this->travel($duration->totalMilliseconds)->milliseconds();
});

Laravel utiliza la clase Sleep internamente siempre que pausa la ejecución. Por ejemplo, el ayudante retry utiliza la clase Sleep al dormir, lo que permite una mejor testabilidad al usar ese ayudante.