# Helpers

# Introducción

Laravel incluye una variedad de funciones "helpers" globales de PHP. Muchas de esas funciones son usadas por el mismo framework; sin embargo, eres libre de usarlas en tus aplicaciones si lo encuentras conveniente.

# Métodos disponibles

# Arreglos & Objetos

# Rutas

# Cadenas

# URLs

# Variados

# Listado de Métodos

# Arreglos & Objetos

# Arr::add() {#collection-method .first-collection-method}

La función Arr::add agrega una clave / valor dada a un arreglo si la clave no existe previamente en el arreglo o existe pero con un valor 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() {#collection-method}

La función Arr::collapse colapsa un arreglo de arreglos en un único arreglo:

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::divide() {#collection-method}

La función Arr::divide retorna dos arreglos, uno contiene las claves y el otro contiene los valores del arreglo dado:

use Illuminate\Support\Arr;

[$keys, $values] = Arr::divide(['name' => 'Desk']);

// $keys: ['name']

// $values: ['Desk']

# Arr::dot() {#collection-method}

La función Arr::dot() aplana un arreglo multidimensional en un arreglo de un sólo nivel que usa la notación de "punto" para indicar la profundidad:

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

$flattened = Arr::dot($array);

// ['products.desk.price' => 100]

# Arr::except() {#collection-method}

La función Arr::except() remueve los pares clave / valor de un arreglo:

use Illuminate\Support\Arr;

$array = ['name' => 'Desk', 'price' => 100];

$filtered = Arr::except($array, ['price']);

// ['name' => 'Desk']

# Arr::first() {#collection-method}

La función Arr::first() devuelve el primer elemento de un arreglo que cumpla la condición dada:

use Illuminate\Support\Arr;

$array = [100, 200, 300];

$first = Arr::first($array, function ($value, $key) {
    return $value >= 150;
});

// 200

Un valor por defecto puede ser pasado como un tercer parámetro al método. Este valor será retornado si no hay un valor que cumpla la condición:

use Illuminate\Support\Arr;

$first = Arr::first($array, $callback, $default);

# Arr::flatten() {#collection-method}

La función Arr::flatten unifica un arreglo multidimensional en un arreglo de un solo nivel:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];

$flattened = Arr::flatten($array);

// ['Joe', 'PHP', 'Ruby']

# Arr::forget() {#collection-method}

La función Arr::forget remueve un par clave / valor de un arreglo anidado usando la notación de "punto":

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

Arr::forget($array, 'products.desk');

// ['products' => []]

# Arr::get() {#collection-method}

La función Arr::get recupera un valor de un arreglo anidado usando la notación de "punto":

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

$price = Arr::get($array, 'products.desk.price');

// 100

La función Arr::get acepta un valor por defecto, el cual será devuelto si la clave especificada no es encontrada:

use Illuminate\Support\Arr;

$discount = Arr::get($array, 'products.desk.discount', 0);

// 0

# Arr::has() {#collection-method}

La función Arr::has comprueba si un elemento o elementos dados existen en un arreglo usando la notación de "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::last() {#collection-method}

La función Arr::last retorna el último elemento de un arreglo que cumpla la condición dada:

use Illuminate\Support\Arr;

$array = [100, 200, 300, 110];

$last = Arr::last($array, function ($value, $key) {
    return $value >= 150;
});

// 300

Un valor por defecto puede ser pasado como tercer argumento al método. Este valor será devuelto si ningún valor cumple la condición:

use Illuminate\Support\Arr;

$last = Arr::last($array, $callback, $default);

# Arr::only() {#collection-method}

La función Arr::only retorna solo el par clave / valor especificado del arreglo dado:

use Illuminate\Support\Arr;

$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];

$slice = Arr::only($array, ['name', 'price']);

// ['name' => 'Desk', 'price' => 100]

# Arr::pluck() {#collection-method}

La función Arr::pluck recupera todos los valores para una clave dada de un arreglo:

use Illuminate\Support\Arr;

$array = [
    ['developer' => ['id' => 1, 'name' => 'Taylor']],
    ['developer' => ['id' => 2, 'name' => 'Abigail']],
];

$names = Arr::pluck($array, 'developer.name');

// ['Taylor', 'Abigail']

Puedes además especificar como deseas que la lista resultante sea codificada:

use Illuminate\Support\Arr;

$names = Arr::pluck($array, 'developer.name', 'developer.id');

// [1 => 'Taylor', 2 => 'Abigail']

# Arr::prepend() {#collection-method}

La función Arr::prepend colocará un elemento al comienzo de un arreglo:

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 debería ser usada por el valor:

use Illuminate\Support\Arr;

$array = ['price' => 100];

$array = Arr::prepend($array, 'Desk', 'name');

// ['name' => 'Desk', 'price' => 100]

# Arr::pull() {#collection-method}

La función Arr::pull retorna y remueve un par clave / valor de un arreglo:

use Illuminate\Support\Arr;

$array = ['name' => 'Desk', 'price' => 100];

$name = Arr::pull($array, 'name');

// $name: Desk

// $array: ['price' => 100]

Un valor por defecto puede ser pasado como tercer argumento del método. Este valor será devuelto si la clave no existe:

use Illuminate\Support\Arr;

$value = Arr::pull($array, $key, $default);

# Arr::random() {#collection-method}

La función Arr::random retorna un valor aleatorio de un arreglo:

use Illuminate\Support\Arr;

$array = [1, 2, 3, 4, 5];

$random = Arr::random($array);

// 4 - (retrieved randomly)

Puedes además especificar el número de elementos a retornar como un segundo argumento opcional. Nota que proveer este argumento retornará un arreglo, incluso si solo deseas un elemento:

use Illuminate\Support\Arr;

$items = Arr::random($array, 2);

// [2, 5] - (retrieved randomly)

# Arr::set() {#collection-method}

La función Arr::set establece un valor dentro de un arreglo anidado usando la notación de "punto":

use Illuminate\Support\Arr;

$array = ['products' => ['desk' => ['price' => 100]]];

Arr::set($array, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 200]]]

# Arr::sort() {#collection-method}

La función Arr::sort clasifica un arreglo por sus valores:

use Illuminate\Support\Arr;

$array = ['Desk', 'Table', 'Chair'];

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

// ['Chair', 'Desk', 'Table']

Puedes además clasificar el arreglo por los resultados de la función de retorno dada:

use Illuminate\Support\Arr;

$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];

$sorted = array_values(Arr::sort($array, function ($value) {
    return $value['name'];
}));

/*
    [
        ['name' => 'Chair'],
        ['name' => 'Desk'],
        ['name' => 'Table'],
    ]
*/

# Arr::sortRecursive() {#collection-method}

La función array_sort_recursive clasifica recursivamente un arreglo usando la función sort para sub-arreglos numericos y ksort para sub-arreglos 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'],
    ]
*/

# Arr::where() {#collection-method}

La función Arr::where filtra un arreglo usando la función de retorno dada:

use Illuminate\Support\Arr;

$array = [100, '200', 300, '400', 500];

$filtered = Arr::where($array, function ($value, $key) {
    return is_string($value);
});

// [1 => '200', 3 => '400']

# Arr::wrap() {#collection-method}

La función Arr::wrap envuelve el valor dado en un arreglo. Si el valor dado ya es un arreglo este no será cambiado:

use Illuminate\Support\Arr;

$string = 'Laravel';

$array = Arr::wrap($string);

// ['Laravel']

Si el valor dado es nulo, un arreglo vacío será devuelto:

use Illuminate\Support\Arr;

$nothing = null;

$array = Arr::wrap($nothing);

// []

# data_fill() {#collection-method}

La función data_fill establece un valor faltante dentro de un arreglo anidado u objeto usando la notación de "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 además acepta asteriscos como comodines y rellenará el objetivo 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() {#collection-method}

La función data_get recupera un valor de un arreglo anidado u objeto usando la notación de "punto":

$data = ['products' => ['desk' => ['price' => 100]]];

$price = data_get($data, 'products.desk.price');

// 100

La función data_get acepta además un valor por defecto, el cual será retornado si la clave especificada no es encontrada:

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

// 0

La función también acepta wildcards usando astericos, que pueden tener como objetivo cualquier clave del arreglo 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() {#collection-method}

La función data_set establece un valor dentro de un arreglo anidado u objeto usando la notación de "punto":

$data = ['products' => ['desk' => ['price' => 100]]];

data_set($data, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 200]]]

Esta función además acepta comodines y establecerá valores en el objetivo 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, cualquier valor existente es sobrescrito. Si deseas solo establecer un valor si no existe, puedes pasar false como cuarto argumento:

$data = ['products' => ['desk' => ['price' => 100]]];

data_set($data, 'products.desk.price', 200, false);

// ['products' => ['desk' => ['price' => 100]]]

# head() {#collection-method}

La función head retorna el primer elemento en el arreglo dado:

$array = [100, 200, 300];

$first = head($array);

// 100

# last() {#collection-method}

La función last retorna el último elemento en el arreglo dado:

$array = [100, 200, 300];

$last = last($array);

// 300

# Rutas

# app_path() {#collection-method}

La función app_path retorna la ruta completa al directorio app. Además puedes usar la función app_path para generar una ruta completa a un archivo relativo al directorio de la aplicación:

$path = app_path();

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

# base_path() {#collection-method}

La función base_path retorna la ruta completa a la raíz del proyecto. Además puedes usar la función base_path para generar una ruta completa a un archivo dado relativo al directorio raíz del proyecto:

$path = base_path();

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

# config_path() {#collection-method}

La función config_path retorna la ruta completa al directorio config. Puedes además usar la función config_path para generar una ruta completa a un archivo dado dentro del directorio de configuración de la aplicación:

$path = config_path();

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

# database_path() {#collection-method}

La función database_path retorna la ruta completa al directorio database. Puedes además usar la función database_path para generar una ruta completa a un archivo dado dentro del directorio database:

$path = database_path();

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

# mix() {#collection-method}

La función mix retorna la ruta al archivo versionado Mix:

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

# public_path() {#collection-method}

La función public_path retorna la ruta completa al directorio public. Puedes además usar la función public_path para generar una ruta completa a un archivo dado dentro del directorio public:

$path = public_path();

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

# resource_path() {#collection-method}

La función resource_path retorna la ruta completa al directorio resources. Puedes además usar la función resource_path para generar una ruta completa a un archivo dado dentro del directorio resources:

$path = resource_path();

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

# storage_path() {#collection-method}

La función storage_path retorna la ruta compelta al directorio storage. Puedes además usar la función storage_path para generar una ruta completa a un archivo dado dentro del directorio storage:

$path = storage_path();

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

# Cadenas

# __() {#collection-method}

La función __ traduce la cadena de traducción dada o clave de traducción dada usando tus archivos de localización:

echo __('Welcome to our application');

echo __('messages.welcome');

Si la cadena o llave de traducción especificada no existe, la función __ retornará el valor dado. Así, usando el ejemplo de arriba, la función __ podría retornar messages.welcome si esa clave de traducción no existe.

# class_basename() {#collection-method}

La función class_basename retorna el nombre de la clase dada con el espacio de nombre de la clase removido:

$class = class_basename('Foo\Bar\Baz');

// Baz

# e() {#collection-method}

La función e ejecuta la función de PHP htmlspecialchars con la opción double_encode establecida establecida a true por defecto:

echo e('<html>foo</html>');

// &lt;html&gt;foo&lt;/html&gt;

# preg_replace_array() {#collection-method}

La función preg_replace_array reemplaza un patrón dado en la cadena secuencialmente usando un arreglo:

$string = 'The event will take place between :start and :end';

$replaced = preg_replace_array('/:[a-z_]+/', ['8:30', '9:00'], $string);

// The event will take place between 8:30 and 9:00

# Str::after() {#collection-method}

La función Str::after retorna todo después del valor dado en una cadena:

use Illuminate\Support\Str;

$slice = Str::after('This is my name', 'This is');

// ' my name'

# Str::before() {#collection-method}

La función Str::before retorna todo antes del valor dado en una cadena:

use Illuminate\Support\Str;

$slice = Str::before('This is my name', 'my name');

// 'This is '

# Str::camel() {#collection-method}

La función Str::camel convierte la cadena dada a camelCase:

use Illuminate\Support\Str;

$converted = Str::camel('foo_bar');

// fooBar

# Str::contains() {#collection-method}

La función Str::contains determina si la cadena dada contiene el valor dado (sensible a mayúsculas y minúsculas):

use Illuminate\Support\Str;

$contains = Str::contains('This is my name', 'my');

// true

Puedes además pasar un arreglo de valores para determinar si la cadena dada contiene cualquiera de los valores:

use Illuminate\Support\Str;

$contains = Str::contains('This is my name', ['my', 'foo']);

// true

# Str::containsAll() {#collection-method}

El método Str::containsAll determina si la cadena dada contiene todos los valores del arreglo:

use Illuminate\Support\Str;

$containsAll = Str::containsAll('This is my name', ['my', 'name']);

// true

# Str::endsWith() {#collection-method}

La función Str::endsWith determina si la cadena dada finaliza con el valor dado:

use Illuminate\Support\Str;

$result = Str::endsWith('This is my name', 'name');

// true

# Str::finish() {#collection-method}

La función Str::finish agrega una instancia individual del valor dado a una cadena si éste no finaliza con el valor:

use Illuminate\Support\Str;

$adjusted = Str::finish('this/string', '/');

// this/string/

$adjusted = Str::finish('this/string/', '/');

// this/string/

# Str::is() {#collection-method}

La función Str::is determina si una cadena dada concuerda con un patrón dado. Asteriscos pueden ser usados para indicar comodines:

use Illuminate\Support\Str;

$matches = Str::is('foo*', 'foobar');

// true

$matches = Str::is('baz*', 'foobar');

// false

# Str::kebab() {#collection-method}

La función Str::kebab convierte la cadena dada a kebab-case:

use Illuminate\Support\Str;

$converted = Str::kebab('fooBar');

// foo-bar

# Str::limit() {#collection-method}

La función Str::limit trunca la cadena dada en la longitud especificada:

use Illuminate\Support\Str;

$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20);

// The quick brown fox...

Puedes además pasar un tercer argumento para cambiar la cadena que será adjuntada al final:

use Illuminate\Support\Str;

$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');

// The quick brown fox (...)

# Str::orderedUuid {#collection-method}

El método Str::orderedUuid genera una "primera marca de tiempo" UUID que puede ser eficientemente almacenada en una columna indexada de la base de datos:

use Illuminate\Support\Str;

return (string) Str::orderedUuid();

# Str::plural() {#collection-method}

La función Str::plural convierte una cadena a su forma plural. Esta función actualmente solo soporta el idioma inglés:

use Illuminate\Support\Str;

$plural = Str::plural('car');

// cars

$plural = Str::plural('child');

// children

Puedes además proporcionar un entero como segundo argumento a la función para recuperar la forma singular o plural de la cadena:

use Illuminate\Support\Str;

$plural = Str::plural('child', 2);

// children

$plural = Str::plural('child', 1);

// child

# Str::random() {#collection-method}

La función Str::random genera una cadena aleatoria con la longitud especificada. Esta función usa la función PHP random_bytes:

use Illuminate\Support\Str;

$random = Str::random(40);

# Str::replaceArray() {#collection-method}

La función Str::replaceArray reemplaza un valor dado en la cadena secuencialmente usando un arreglo:

use Illuminate\Support\Str;

$string = 'The event will take place between ? and ?';

$replaced = Str::replaceArray('?', ['8:30', '9:00'], $string);

// The event will take place between 8:30 and 9:00

# Str::replaceFirst() {#collection-method}

La función Str::replaceFirst reemplaza la primera ocurrencia de un valor dado en una cadena:

use Illuminate\Support\Str;

$replaced = Str::replaceFirst('the', 'a', 'the quick brown fox jumps over the lazy dog');

// a quick brown fox jumps over the lazy dog

# Str::replaceLast() {#collection-method}

La función Str::replaceLast reemplaza la última ocurrencia de un valor dado en una cadena:

use Illuminate\Support\Str;

$replaced = Str::replaceLast('the', 'a', 'the quick brown fox jumps over the lazy dog');

// the quick brown fox jumps over a lazy dog

# Str::singular() {#collection-method}

La función Str::singular convierte una cadena a su forma singular. Esta función actualmente solo soporta el idioma inglés:

use Illuminate\Support\Str;

$singular = Str::singular('cars');

// car

$singular = Str::singular('children');

// child

# Str::slug() {#collection-method}

La función Str::slug genera una URL amigable con la cadena dada:

use Illuminate\Support\Str;

$slug = Str::slug('Laravel 5 Framework', '-');

// laravel-5-framework

# Str::snake() {#collection-method}

La función Str::snake() convierte la cadena dada a snake_case:

use Illuminate\Support\Str;

$converted = Str::snake('fooBar');

// foo_bar

# Str::start() {#collection-method}

La función Str::start agrega una instancia individual del valor dado a una cadena si ésta no inicia con ese valor:

use Illuminate\Support\Str;

$adjusted = Str::start('this/string', '/');

// /this/string

$adjusted = Str::start('/this/string', '/');

// /this/string

# Str::startsWith() {#collection-method}

La función Str::startsWith determina si la cadena dada comienza con el valor dado:

use Illuminate\Support\Str;

$result = Str::startsWith('This is my name', 'This');

// true

# Str::studly() {#collection-method}

La función Str::studly convierte la cadena dada a StudlyCase:

use Illuminate\Support\Str;

$converted = Str::studly('foo_bar');

// FooBar

# Str::title() {#collection-method}

La función Str::title convierte la cadena dada a Title Case:

use Illuminate\Support\Str;

$converted = Str::title('a nice title uses the correct case');

// A Nice Title Uses The Correct Case

# Str::uuid() {#collection-method}

El método Str::uuid genera un UUID (versión 4):

use Illuminate\Support\Str;

return (string) Str::uuid();

# trans() {#collection-method}

La función trans traduce la clave de traducción dada usando tus archivos de localización:

echo trans('messages.welcome');

Si la clave de traducción especificada no existe, la función trans retornará la clave dada. Así, usando el ejemplo de arriba, la función trans podría retornar messages.welcome si la clave de traducción no existe.

# trans_choice() {#collection-method}

La función trans_choice traduce la clave de traducción dada con inflexión:

echo trans_choice('messages.notifications', $unreadCount);

Si la clave de traducción dada no existe, la función trans_choice retornará la clave dada. Así, usando el ejemplo de arriba, la función trans_choice podría retornar messages.notifications si la clave de traducción no existe.

# URLs

# action() {#collection-method}

La función action genera una URL para la acción del controlador dada. No necesitas pasar el espacio de nombre completo. En lugar de eso, pasa al controlador el nombre de clase relativo al espacio de nombre App\Http\Controllers:

$url = action('HomeController@index');

$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@profile', ['id' => 1]);

# asset() {#collection-method}

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

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

Puedes configurar la URL host del asset estableciendo la variable ASSET_URL en tu archivo .env. Esto puede ser útil si alojas tus assets en un servicio externo como Amazon S3:

// ASSET_URL=http://example.com/assets

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

# route() {#collection-method}

La función route genera una URL para el nombre de ruta dado:

$url = route('routeName');

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

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

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

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

# secure_asset() {#collection-method}

La función secure_asset genera una URL para un asset usando HTTPS:

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

# secure_url() {#collection-method}

La función secure_url genera una URL HTTPS completa a la ruta dada:

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

# url() {#collection-method}

La función url genera una URL completa a la ruta dada:

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

Si una ruta no es proporcionada, una instancia de Illuminate\Routing\UrlGenerator es retornada:

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

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

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

# Variados

# abort() {#collection-method}

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

abort(403);

Puedes además proporcionar el texto de respuesta de la excepción y las cabeceras de la respuesta personalizados:

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

# abort_if() {#collection-method}

La función abort_if arroja una excepción HTTP si una expresión booleana dada es evaluada a true:

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

Como el método abort, puedes proporcionar además el texto de respuesta para la excepción como tercer argumento y un arreglo de cabeceras de respuesta personalizadas como cuarto argumento.

# abort_unless() {#collection-method}

La función abort_unless arroja una excepción HTTP si una expresión booleana dada es evaluada a false:

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

Como el método abort, puedes proporcionar además el texto de respuesta para la excepción como tercer argumento y un arreglo de cabeceras de respuesta personalizadas como cuarto argumento.

# app() {#collection-method}

La función app retorna la instancia del contenedor de servicio:

$container = app();

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

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

# auth() {#collection-method}

La función auth retorna una instancia del autenticador. Puedes usarla en vez del facade Auth por conveniencia:

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

Si es necesario, puedes especificar con cual instancia del guard podrías acceder:

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

# back() {#collection-method}

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

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

return back();

# bcrypt() {#collection-method}

La función bcrypt encripta el valor dado usando Bcrypt. Puedes usarlo como una alternativa al facade Hash:

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

# blank() {#collection-method}

La función blank retorna true si el valor dado es "vacío":

blank('');
blank('   ');
blank(null);
blank(collect());

// true

blank(0);
blank(true);
blank(false);

// false

Para lo inverso de blank, mira el método filled.

# broadcast() {#collection-method}

La función broadcast emite el evento dado a sus listeners:

broadcast(new UserRegistered($user));

# cache() {#collection-method}

La función cache puede ser usada para obtener un valor de la cache. Si la clave dada no existe en la cache, un valor opcional por defecto será retornado:

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

Puedes agregar elementos a la cache pasando un arreglo de pares clave / valor a la función. También debes pasar la cantidad de segundos o la duración que el valor almacenado en caché debe considerarse válido:

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

# class_uses_recursive() {#collection-method}

La función class_uses_recursive retorna todos los traits usados por una clase, incluyendo traits por todas las clases padre:

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

# collect() {#collection-method}

La función collect crea una instancia de colecciones del valor dado:

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

# config() {#collection-method}

La función config obtiene el valor de una variable de configuración. Los valores de configuración pueden ser accesados usando la sintaxis de "punto", la cual incluye el nombre del archivo y la opción que deseas acceder. Un valor por defecto puede ser especificado y es retornado 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 arreglo de pares clave / valor:

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

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

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

# csrf_field() {#collection-method}

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

{{ csrf_field() }}

# csrf_token() {#collection-method}

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

$token = csrf_token();

# dd() {#collection-method}

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

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

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

# decrypt() {#collection-method}

La función decrypt desencripta el valor dado usando el encriptador de Laravel:

$decrypted = decrypt($encrypted_value);

# dispatch() {#collection-method}

La función dispatch empuja el trabajo dado sobre la cola de trabajos de Laravel:

dispatch(new App\Jobs\SendEmails);

# dispatch_now() {#collection-method}

La función dispatch_now ejecuta el trabajo dado inmediatamente y retorna el valor de su método handle:

$result = dispatch_now(new App\Jobs\SendEmails);

# dump() {#collection-method}

La función dump desecha las variables dadas:

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

Si quieres parar de ejecutar el script después de desechar las variables, usa la función dd en su lugar.

# encrypt() {#collection-method}

La función encrypt encripta el valor dado usando el encriptador de Laravel:

$encrypted = encrypt($unencrypted_value);

# env() {#collection-method}

La función env recupera el valor de una variable de entorno o retorna un valor por defecto:

$env = env('APP_ENV');

// Returns 'production' if APP_ENV is not set...
$env = env('APP_ENV', 'production');

Nota

Si ejecutas el comando config:cache durante tu proceso de despliegue, deberías estar seguro de que eres el único llamando a la función env desde dentro de tus archivos de configuración. Una vez que la configuración está en caché, el archivo .env no será cargado y todas las llamadas a la función .env retornarán null.

# event() {#collection-method}

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

event(new UserRegistered($user));

# factory() {#collection-method}

La función factory crea un constructor de model factories para una clase dada, nombre y cantidad. Este puede ser usado mientras pruebas o haces seeding:

$user = factory(App\User::class)->make();

# filled() {#collection-method}

La función filled retorna el valor dado que no esté "vacío":

filled(0);
filled(true);
filled(false);

// true

filled('');
filled('   ');
filled(null);
filled(collect());

// false

Para el inverso de filled, mira el método blank.

# info() {#collection-method}

La funcióninfo escribirá información al log:

info('Some helpful information!');

Un arreglo de datos contextuales puede además ser pasado a la función:

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

# logger() {#collection-method}

La función logger puede ser usada para escribir mensaje de nivel debug al log:

logger('Debug message');

Un arreglo de datos contextuales puede además ser pasado a la función:

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

Una instancia del logger será retornada si no hay un valor pasado a la función:

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

# method_field() {#collection-method}

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

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

# now() {#collection-method}

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

$now = now();

# old() {#collection-method}

La función old recupera un viejo valor de entrada flasheado en la sesión:

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

# optional() {#collection-method}

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

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

La función optional también acepta un Closure como segundo argumento. El Closure será invocado si el valor proporcionado como primer argumento no es null:

return optional(User::find($id), function ($user) {
    return new DummyUser;
});

# policy() {#collection-method}

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

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

# redirect() {#collection-method}

La función redirect retorna una respuesta de redirección HTTP o retorna la instancia del redirector si no hay argumentos llamados:

return redirect($to = null, $status = 302, $headers = [], $secure = null);

return redirect('/home');

return redirect()->route('route.name');

# report() {#collection-method}

La función report reportará una excepción usando el método report de tu manejador de excepciones:

report($e);

# request() {#collection-method}

La función request retorna la instancia de la solicitud actual u obtiene un elemento de entrada:

$request = request();

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

# rescue() {#collection-method}

La función rescue ejecuta la función de retorno dada y almacena en cache cualquier excepción que ocurra durante su ejecución. Todas las excepciones que son capturadas serán enviadas al método report de tu manejador de excepciones; no obstante, la solicitud continuará procesando:

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

También puedes pasar un segundo argumento a la función rescue. Este argumento será el valor por "defecto" que debería ser retornado si una excepción ocurre mientras se ejecuta la función de retorno:

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

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

# resolve() {#collection-method}

La función resolve resuelve un nombre de clase o interfaz dado a su instancia usando elcontenedor de servicios:

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

# response() {#collection-method}

La función response crea una instancia de respuesta u obtiene una instancia del factory de respuesta:

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

# retry() {#collection-method}

La función retry intenta ejecutar la función de retorno dada hasta que el máximo número de intentos límite se cumple. Si la función de retorno no arroja una excepción, su valor de retorno será retornado. Si la función de retorno arroja una excepción, se volverá a intentar automáticamente. Si el máximo número de intentos es excedido, la excepción será arrojada:

return retry(5, function () {
    // Attempt 5 times while resting 100ms in between attempts...
}, 100);

# session() {#collection-method}

La función session puede ser usada para obtener o establecer valores de session:

$value = session('key');

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

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

La sesión almacenada será retornada si no se pasa un valor a la función:

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

# tap() {#collection-method}

La función tap acepta dos argumentos: un $value arbitrario y una función de retorno. El $value será pasado a la función de retorno y será retornado por la función tap. El valor de retorno de la función de retorno es irrelevante:

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

    $user->save();
});

Si no hay función de retorno para la función tap, puedes llamar cualquier método en el $value dado. El valor de retorno del método al que llama siempre será $value, sin importar lo que el método retorna en su definición. Por ejemplo, el método de Eloquent update típicamente retorna un entero. Sin embargo, podemos forzar que el método retorne el modelo en sí mismo encadenando el 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 trait Illuminate\Support\Traits\Tappable a la clase. El método tap de este trait acepta un Closoure como único argumento. La instancia del objeto será pasada al Closure y luego retornada por el método tap:

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

# throw_if() {#collection-method}

La función throw_if arroja la excepción dada si una expresión booleana dada es evaluada a 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() {#collection-method}

La función throw_unless arroja la excepción dada si una expresión booleana dada es evaluada a false:

throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);

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

# today() {#collection-method}

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

$today = today();

# trait_uses_recursive() {#collection-method}

La función trait_uses_recursive retorna todos los traits usados por un trait:

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

# transform() {#collection-method}

La función transform ejecuta una función de retorno en un valor dado si el valor no está en vacío y retorna el resultado de la función de retorno:

$callback = function ($value) {
    return $value * 2;
};

$result = transform(5, $callback);

// 10

Un valor o Closure puede ser pasado como el tercer parámetro al método. Este valor será retornado si el valor dado está vacío:

$result = transform(null, $callback, 'The value is blank');

// The value is blank

# validator() {#collection-method}

La función validator crea un nueva instancia del validador con los argumentos dados. Puedes usarlo en vez del facade Validator por conveniencia:

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

# value() {#collection-method}

La función value retorna el valor dado. Sin embargo, si pasas un Closure a la función, el Closure será ejecutado y su resultado será devuelto:

$result = value(true);

// true

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

// false

# view() {#collection-method}

La función view recupera una instancia de la vista:

return view('auth.login');

# with() {#collection-method}

La función with retorna el valor dado. Si se le pasa un Closure como segundo argumento a la función, el Closure será ejecutado y su resultado será devuelto:

$callback = function ($value) {
    return (is_numeric($value)) ? $value * 2 : 0;
};

$result = with(5, $callback);

// 10

$result = with(null, $callback);

// 0

$result = with(5, null);

// 5