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()

El método 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()

El método 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::crossJoin()

El método Arr::crossJoin hace un cross join de los arreglos 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 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()

El método 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()

El método 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()

El método 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()

El método 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()

El método 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()

El método 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

El método 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()

El método 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::isAssoc()

Arr::isAssoc retorna true si el arreglo dado es un arreglo asociativo. Un arreglo es considerado «asociativo» si no tiene claves numéricas secuenciales comenzando por cero:

use Illuminate\Support\Arr;

$isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]);

// true

$isAssoc = Arr::isAssoc([1, 2, 3]);

// false

Arr::last()

El método 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()

El método 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()

El método 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 cómo 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()

El método 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()

El método 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()

El método 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::query()

El método Arr::query convierte el contenido del arreglo a 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::set()

El método 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::shuffle()

El método Arr::shuffle ordena de forma aleatoria los elementos en el arreglo:

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 arreglo por sus valores:

use Illuminate\Support\Arr;

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

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

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

Puedes además ordenar el arreglo por los resultados de la Closure 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()

El método Arr::sortRecursive ordena recursivamente un arreglo usando la función sort para sub-arreglos numéricos 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()

El método Arr::where filtra un arreglo usando la Closure 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()

El método 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()

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()

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 comodines usando asteriscos, 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()

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()

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

$array = [100, 200, 300];

$first = head($array);

// 100

last()

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

$array = [100, 200, 300];

$last = last($array);

// 300

Rutas

app_path()

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()

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()

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()

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()

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

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

public_path()

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()

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()

La función storage_path retorna la ruta completa 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

__()

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 anterior, la función __ podría retornar messages.welcome si esa clave de traducción no existe.

class_basename()

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()

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

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

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

preg_replace_array()

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()

El método Str::after retorna todo después del valor dado en una cadena. La cadena entera será retornada si el valor no existe dentro de la cadena:

use Illuminate\Support\Str;

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

// ' my name'

Str::afterLast()

El método Str::afterLast retorna todo luego de la última ocurrencia del valor dado en una cadena. La cadena entera será retornada si el valor no existe dentro de la cadena:

use Illuminate\Support\Str;

$slice = Str::afterLast('App\Http\Controllers\Controller', '\\');

// 'Controller'

Str::before()

El método 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::beforeLast()

El método Str::beforeLast retorna todo antes de la última ocurrencia del valor dado en una cadena:

use Illuminate\Support\Str;

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

// 'This '

Str::camel()

El método Str::camel convierte la cadena dada a camelCase:

use Illuminate\Support\Str;

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

// fooBar

Str::contains()

El método 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()

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()

El método 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

También puedes pasar un arreglo de valores para determinar si la cadena dada termina con alguno de los valores dados:

use Illuminate\Support\Str;

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

// true

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

// false

Str::finish()

El método 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()

El método 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::ucfirst()

El método Str::ucfirst devuelve la cadena dada con el primer carácter en mayúscula.

use Illuminate\Support\Str;

$string = Str::ucfirst('foo bar');

// Foo bar

Str::isUuid()

El método Str::isUuid determina si la cadena dada es un UUID válido:

use Illuminate\Support\Str;

$isUuid = Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');

// true

$isUuid = Str::isUuid('laravel');

// false

Str::kebab()

El método Str::kebab convierte la cadena dada a kebab-case:

use Illuminate\Support\Str;

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

// foo-bar

Str::limit()

El método 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

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()

El método Str::plural convierte una cadena de una única palabra 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()

El método Str::random genera una cadena aleatoria con la longitud especificada. Este método usa la función PHP random_bytes:

use Illuminate\Support\Str;

$random = Str::random(40);

Str::replaceArray()

El método 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()

El método 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()

El método 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()

El método 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()

El método Str::slug genera un «slug» de URL amigable con la cadena dada:

use Illuminate\Support\Str;

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

// laravel-5-framework

Str::snake()

El método Str::snake convierte la cadena dada a snake_case:

use Illuminate\Support\Str;

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

// foo_bar

Str::start()

El método 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()

El método 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()

El método Str::studly convierte la cadena dada a StudlyCase:

use Illuminate\Support\Str;

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

// FooBar

Str::title()

El método 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()

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

use Illuminate\Support\Str;

return (string) Str::uuid();

Str::words()

El método Str:words limita el número de palabras en una cadena:

use Illuminate\Support\Str;

return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>');

// Perfectly balanced, as >>>

trans()

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 anterior, la función trans podría retornar messages.welcome si la clave de traducción no existe.

trans_choice()

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 anterior, la función trans_choice podría retornar messages.notifications si la clave de traducción no existe.

URLs

action()

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

$url = action('[email protected]');

$url = action([HomeController::class, 'index']);

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

$url = action('[email protected]', ['id' => 1]);

asset()

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()

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()

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

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

secure_url()

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()

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()

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()

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()

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()

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()

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 cuál instancia del guard podrías acceder:

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

back()

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()

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

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

blank()

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()

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

broadcast(new UserRegistered($user));

cache()

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

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

Puedes agregar elementos a la caché 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()

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

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

collect()

La función collect crea una instancia de colecciones 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 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]);

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 hidden que contiene el valor del token CSRF. Por ejemplo, usando la sintaxis de Blade:

{{ csrf_field() }}

csrf_token()

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

$token = csrf_token();

dd()

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()

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

$decrypted = decrypt($encrypted_value);

dispatch()

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

dispatch(new App\Jobs\SendEmails);

dispatch_now()

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()

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()

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

$encrypted = encrypt($unencrypted_value);

env()

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');

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()

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

event(new UserRegistered($user));

factory()

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()

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()

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()

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()

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()

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

$now = now();

old()

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

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

optional()

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()

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

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

redirect()

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()

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

report($e);

request()

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

$request = request();

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

rescue()

La función rescue ejecuta Closure dada y almacena en caché 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 Closure:

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

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

resolve()

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

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

response()

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()

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()

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()

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

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

    $user->save();
});

Si no hay Closure pasada a la función tap, puedes llamar cualquier método en el $value dado. El valor de retorno del método al que llamas 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 Closure 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()

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()

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()

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 retorna todos los traits usados por un trait:

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

transform()

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

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

$result = transform(5, $callback);

// 10

Un valor por defecto 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()

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()

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()

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

return view('auth.login');

with()

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

Regístrate hoy en Styde y obtén acceso a todo nuestro contenido.

Lección anterior Almacenamiento De Archivos - Documentación de Laravel 6 Lección siguiente Correos Electrónicos - Documentación de Laravel 6