Funciones de Ayuda
Introducción
Laravel incluye una variedad de funciones PHP globales de "ayuda". Muchas de estas funciones son usadas por el propio framework; sin embargo, eres libre de usarlas en tus propias aplicaciones si las encuentras convenientes.
Métodos disponibles
Matrices y objetos
Arr::accessible Arr::add Arr::collapse Arr::crossJoin Arr::divide Arr::dot Arr::except Arr::exists Arr::first Arr::flatten Arr::forget Arr::get Arr::has Arr::hasAny Arr::isAssoc Arr::isList Arr::join Arr::keyBy Arr::last Arr::map Arr::only Arr::pluck Arr::prepend Arr::prependKeysWith Arr::pull Arr::query Arr::random Arr::set Arr::shuffle Arr::sort Arr::sortRecursive Arr::toCssClasses Arr::undot Arr::where Arr::whereNotNull Arr::wrap data_fill data_get data_set head last
Rutas
Strings
__ class_basename e preg_replace_array Str::after Str::afterLast Str::ascii Str::before Str::beforeLast Str::between Str::betweenFirst Str::camel Str::contains Str::containsAll Str::endsWith Str::excerpt Str::finish Str::headline Str::inlineMarkdown Str::is Str::isAscii Str::isJson Str::isUlid Str::isUuid Str::kebab Str::lcfirst Str::length Str::limit Str::lower Str::markdown Str::mask Str::orderedUuid Str::padBoth Str::padLeft Str::padRight Str::plural Str::pluralStudly Str::random Str::remove Str::replace Str::replaceArray Str::replaceFirst Str::replaceLast Str::reverse Str::singular Str::slug Str::snake Str::squish Str::start Str::startsWith Str::studly Str::substr Str::substrCount Str::substrReplace Str::swap Str::title Str::toHtmlString Str::ucfirst Str::ucsplit Str::upper Str::ulid Str::uuid Str::wordCount Str::words str trans trans_choice
Cadenas fluidas
after afterLast append ascii basename before beforeLast between betweenFirst camel classBasename contains containsAll dirname endsWith excerpt exactly explode finish headline inlineMarkdown is isAscii isEmpty isNotEmpty isJson isUlid isUuid kebab lcfirst length limit lower ltrim markdown mask match matchAll newLine padBoth padLeft padRight pipe plural prepend remove replace replaceArray replaceFirst replaceLast replaceMatches rtrim scan singular slug snake split squish start startsWith studly substr substrReplace swap tap test title trim ucfirst ucsplit upper when whenContains whenContainsAll whenEmpty whenNotEmpty whenStartsWith whenEndsWith whenExactly whenNotExactly whenIs whenIsAscii whenIsUlid whenIsUuid whenTest wordCount words
URLs
Varios
abort abort_if abort_unless app auth back bcrypt blank broadcast cache class_uses_recursive collect config cookie csrf_field csrf_token decrypt dd dispatch dump encrypt env event fake filled info logger method_field now old optional policy redirect report report_if report_unless request rescue resolve response retry session tap throw_if throw_unless today trait_uses_recursive transform validator value view with
Method Listing
Arrays & Objectos
Arr::accessible()
El método Arr::accessible determina si el valor dado es array accesible:
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); // falseArr::add()
El método Arr::add añade un par clave / valor dado a un array si la clave dada no existe ya en el array o es nula:
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 contrae un array de arrays en un único 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 cruza lss arrays dadas, devolviendo un producto cartesiano con todas las permutaciones posibles:
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: una con las claves y otra con los valores de el array dado:
use Illuminate\Support\Arr; [$keys, $values] = Arr::divide(['name' => 'Desk']); // $keys: ['name'] // $values: ['Desk']Arr::dot()
El método Arr::dot transforma un array multidimensional en un array de un solo nivel que utiliza la notación "dot" 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 de un array los pares clave/valor dados:
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'); // falseArr::first()
El método Arr::first devuelve el primer elemento de un array que supera una condición dada:
use Illuminate\Support\Arr; $array = [100, 200, 300]; $first = Arr::first($array, function ($value, $key) { return $value >= 150;}); // 200También se puede pasar un valor por defecto como tercer parámetro del método. Este valor se devolverá si ningún valor supera la condición proporcionada:
use Illuminate\Support\Arr; $first = Arr::first($array, $callback, $default);Arr::flatten()
El método Arr::flatten transforma 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 anidado en profundidad utilizando la notación "dot":
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 anidado utilizando la notación "dot":
use Illuminate\Support\Arr; $array = ['products' => ['desk' => ['price' => 100]]]; $price = Arr::get($array, 'products.desk.price'); // 100El método Arr::get también acepta un valor por defecto, que será devuelto si la clave especificada no está presente en el array:
use Illuminate\Support\Arr; $discount = Arr::get($array, 'products.desk.discount', 0); // 0Arr::has()
El método Arr::has comprueba si uno o varios elementos existen en un array utilizando la notación "dot":
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']); // falseArr::hasAny()
El método Arr::hasAny comprueba si algún elemento de un conjunto dado existe en un array utilizando la notación "dot":
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']); // falseArr::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 empiecen por cero:
use Illuminate\Support\Arr; $isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]); // true $isAssoc = Arr::isAssoc([1, 2, 3]); // falseArr::isList()
El método Arr::isList devuelve true si las claves del array dado son enteros secuenciales empezando por cero:
use Illuminate\Support\Arr; $isList = Arr::isList(['foo', 'bar', 'baz']); // true $isList = Arr::isList(['product' => ['name' => 'Desk', 'price' => 100]]); // falseArr::join()
El método Arr::join une los elementos de array en una cadena. Utilizando el segundo argumento de este método, también puede especificar la cadena de unión para el elemento final 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 LivewireArr::keyBy()
El método Arr::keyBy ordena el array por la clave dada. Si varios elementos tienen la misma clave, sólo el último aparecerá 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 condición dada:
use Illuminate\Support\Arr; $array = [100, 200, 300, 110]; $last = Arr::last($array, function ($value, $key) { return $value >= 150;}); // 300Se puede pasar un valor por defecto como tercer argumento del método. Este valor se devolverá si ningún valor supera la condición:
use Illuminate\Support\Arr; $last = Arr::last($array, $callback, $default);Arr::map()
El método Arr::map recorre el array y pasa cada valor y clave al callback dado. El valor de array se sustituye por el valor devuelto por el callback:
use Illuminate\Support\Arr; $array = ['first' => 'james', 'last' => 'kirk']; $mapped = Arr::map($array, function ($value, $key) { return ucfirst($value);}); // ['first' => 'James', 'last' => 'Kirk']Arr::only()
El método Arr::only devuelve sólo 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 puede especificar cómo desea que sea la clave de 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 coloca 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, puede especificar la clave que se utilizará 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 antepone a todos los nombres de las claves de un array asociativo el prefijo dado:
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 por defecto como tercer argumento del 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 query string:
use Illuminate\Support\Arr; $array = [ 'name' => 'Taylor', 'order' => [ 'column' => 'created_at', 'direction' => 'desc' ]]; Arr::query($array); // name=Taylor&order[column]=created_at&order[direction]=descArr::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 puede especificar el número de elementos a devolver como segundo argumento opcional. Tenga en cuenta que este argumento devolverá un array incluso si sólo 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 anidado usando la notación "dot":
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 del 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 puede ordenar el array por los resultados de un closure dado:
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 array utilizando la función sort para sub-arrays indexados numéricamente y la función ksort para sub-arrays asociativas:
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::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 desea añadir, mientras que el valor es una expresión booleana. Si el elemento array tiene una clave numérica, siempre se incluirá en la lista de clases renderizada:
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'*/Este método potencia la funcionalidad de Laravel que permite fusionar clases con la bolsa de atributos de un componente Blade, así como la directiva de Blade @class.
Arr::undot()
El método Arr::undot expande un array unidimensional que utiliza la notación "dot" a 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 closure dado:
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::whereNotNull()
El método Arr::whereNotNull elimina todos los valores nulos 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 modificaciones:
use Illuminate\Support\Arr; $string = 'Laravel'; $array = Arr::wrap($string); // ['Laravel']Si el valor dado es nulo, se devolverá un array vacío:
use Illuminate\Support\Arr; $array = Arr::wrap(null); // []data_fill()
La función data_fill establece un valor que falta dentro de un array u objeto anidado utilizando la notación "dot":
$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 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 array u objeto anidado utilizando la notación "dot":
$data = ['products' => ['desk' => ['price' => 100]]]; $price = data_get($data, 'products.desk.price'); // 100La función data_get también acepta un valor por defecto, que se devolverá si no se encuentra la clave especificada:
$discount = data_get($data, 'products.desk.discount', 0); // 0La función también acepta comodines utilizando 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 u objeto anidado utilizando la notación "dot":
$data = ['products' => ['desk' => ['price' => 100]]]; data_set($data, 'products.desk.price', 200); // ['products' => ['desk' => ['price' => 200]]]Esta función también acepta comodines utilizando asteriscos y establecerá los 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, los valores existentes se sobrescriben. Si sólo desea establecer un valor si no existe, puede 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]]]head()
La función head devuelve el primer elemento de el array dado:
$array = [100, 200, 300]; $first = head($array); // 100last()
La función last devuelve el último elemento de el array dado:
$array = [100, 200, 300]; $last = last($array); // 300Rutas
app_path()
La función app_path devuelve la ruta completa al directorio de aplicaciones de su aplicación. También puede utilizar 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 devuelve la ruta completa al directorio raíz de la aplicación. También puede utilizar 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 devuelve la ruta completa al directorio de configuración de su aplicación. También puede utilizar la función config_path para generar una ruta completa a un archivo determinado 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 completa al directorio database de la aplicación. También puede utilizar la función database_path para generar una ruta completa a un archivo determinado 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 completa al directorio lang de su aplicación. También puede utilizar la función lang_path para generar una ruta completa a un archivo determinado dentro del directorio:
$path = lang_path(); $path = lang_path('en/messages.php');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 completa al directorio public de su aplicación. También puede utilizar la función public_path para generar una ruta completa a un archivo determinado dentro del directorio público:
$path = public_path(); $path = public_path('css/app.css');resource_path()
La función resource_path devuelve la ruta completa al directorio resources de su aplicación. También puede utilizar la función resource_path para generar una ruta completa a un archivo determinado dentro del directorio de recursos:
$path = resource_path(); $path = resource_path('sass/app.scss');storage_path()
La función storage_path devuelve la ruta completa al directorio storage su aplicación. También puede utilizar la función storage_path para generar una ruta completa a un archivo determinado dentro del directorio de almacenamiento:
$path = storage_path(); $path = storage_path('app/file.txt');Strings
__()
La función __ traduce la cadena o clave de traducción dada utilizando sus archivos de localización:
echo __('Welcome to our application'); echo __('messages.welcome');Si la cadena o clave de traducción especificada no existe, la función __ devolverá el valor dado. Así, utilizando el ejemplo anterior, la función __ devolveríamessages.welcome si esa clave de traducción no existe.
class_basename()
La función class_basename devuelve el nombre de la clase dada sin el espacio de nombres de la clase:
$class = class_basename('Foo\Bar\Baz'); // Baze()
La función e ejecuta la función htmlspecialchars de PHP con la opción double_encode activada defecto:
echo e('<html>foo</html>'); // <html>foo</html>preg_replace_array()
La función preg_replace_array reemplaza un patrón dado en la cadena secuencialmente usando un array:
$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:00Str::after()
El método Str::after devuelve todo lo que hay después del valor dado en una cadena. Se devolverá la cadena completa 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 devuelve todo lo que hay después de la última aparición del valor dado en una cadena. Se devolverá la cadena completa si el valor no existe dentro de la cadena:
use Illuminate\Support\Str; $slice = Str::afterLast('App\Http\Controllers\Controller', '\\'); // 'Controller'Str::ascii()
El método Str::ascii intentará transliterar la cadena a un valor ASCII:
use Illuminate\Support\Str; $slice = Str::ascii('û'); // 'u'Str::before()
El método Str::before devuelve todo lo anterior al 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 devuelve todo lo que hay antes de la última aparición del valor dado en una cadena:
use Illuminate\Support\Str; $slice = Str::beforeLast('This is my name', 'is'); // 'This 'Str::between()
El método Str::between devuelve la parte de una cadena comprendida entre dos valores:
use Illuminate\Support\Str; $slice = Str::between('This is my name', 'This', 'name'); // ' is my 'Str::betweenFirst()
El método Str::betweenFirst devuelve la porción más pequeña posible de una cadena entre dos valores:
use Illuminate\Support\Str; $slice = Str::betweenFirst('[a] bc [d]', '[', ']'); // 'a'Str::camel()
El método Str::camel convierte la cadena dada a camelCase:
use Illuminate\Support\Str; $converted = Str::camel('foo_bar'); // fooBarStr::contains()
El método Str::contains determina si la cadena dada contiene el valor dado. Este método distingue entre mayúsculas y minúsculas:
use Illuminate\Support\Str; $contains = Str::contains('This is my name', 'my'); // trueTambién puede pasar un array de valores para determinar si la cadena dada contiene alguno de los valores de el array:
use Illuminate\Support\Str; $contains = Str::contains('This is my name', ['my', 'foo']); // trueStr::containsAll()
El método Str::containsAll determina si la cadena dada contiene todos los valores de un array dado:
use Illuminate\Support\Str; $containsAll = Str::containsAll('This is my name', ['my', 'name']); // trueStr::endsWith()
El método Str::endsWith determina si la cadena dada termina con el valor dado:
use Illuminate\Support\Str; $result = Str::endsWith('This is my name', 'name'); // trueTambién puede pasar un array de valores para determinar si la cadena dada termina con cualquiera de los valores del array:
use Illuminate\Support\Str; $result = Str::endsWith('This is my name', ['name', 'foo']); // true $result = Str::endsWith('This is my name', ['this', 'foo']); // falseStr::excerpt()
El método Str::excerpt extrae un fragmento de una cadena dada que coincide con la primera instancia de una frase dentro de esa cadena:
use Illuminate\Support\Str; $excerpt = Str::excerpt('This is my name', 'my', [ 'radius' => 3]); // '...is my na...'La opción radius, que por defecto es 100, permite definir el número de caracteres que deben aparecer a cada lado de la cadena truncada.
Además, puede utilizar la opción omission para definir la cadena que se antepondrá y añadirá a la cadena truncada:
use Illuminate\Support\Str; $excerpt = Str::excerpt('This is my name', 'name', [ 'radius' => 3, 'omission' => '(...) ']); // '(...) my name'Str::finish()
El método Str::finish añade una única instancia del valor dado a una cadena si aún no termina con ese valor:
use Illuminate\Support\Str; $adjusted = Str::finish('this/string', '/'); // this/string/ $adjusted = Str::finish('this/string/', '/'); // this/string/Str::headline()
El método Str::headline convierte cadenas delimitadas por mayúsculas, guiones o guiones bajos en una cadena delimitada por espacios con la primera letra de cada palabra en mayúscula:
use Illuminate\Support\Str; $headline = Str::headline('steve_jobs'); // Steve Jobs $headline = Str::headline('EmailNotificationSent'); // Email Notification SentStr::inlineMarkdown()
El método Str::inlineMarkdown convierte Markdown (en su variante para GitHub) en HTML inline utilizando CommonMark. Sin embargo, a diferencia del método markdown, no envuelve todo el HTML generado en un elemento a nivel de bloque:
use Illuminate\Support\Str; $html = Str::inlineMarkdown('**Laravel**'); // <strong>Laravel</strong>Str::is()
El método Str::is determina si una cadena dada coincide con un patrón dado. Los asteriscos pueden utilizarse como comodines:
use Illuminate\Support\Str; $matches = Str::is('foo*', 'foobar'); // true $matches = Str::is('baz*', 'foobar'); // falseStr::isAscii()
El método Str::isAscii determina si una cadena dada es ASCII de 7 bits:
use Illuminate\Support\Str; $isAscii = Str::isAscii('Taylor'); // true $isAscii = Str::isAscii('ü'); // falseStr::isJson()
El método Str::isJson determina si la cadena dada es JSON válida:
use Illuminate\Support\Str; $result = Str::isJson('[1,2,3]'); // true $result = Str::isJson('{"first": "John", "last": "Doe"}'); // true $result = Str::isJson('{first: "John", last: "Doe"}'); // falseStr::isUlid()
El método Str::isUlid determina si la cadena dada es un ULID válido:
use Illuminate\Support\Str; $isUlid = Str::isUlid('01gd6r360bp37zj17nxb55yv40'); // true $isUlid = Str::isUlid('laravel'); // falseStr::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'); // falseStr::kebab()
El método Str::kebab convierte la cadena dada a kebab-case:
use Illuminate\Support\Str; $converted = Str::kebab('fooBar'); // foo-barStr::lcfirst()
El método Str::lcfirst devuelve la cadena dada con el primer carácter en minúsculas:
use Illuminate\Support\Str; $string = Str::lcfirst('Foo Bar'); // foo BarStr::length()
El método Str::length devuelve la longitud de la cadena dada:
use Illuminate\Support\Str; $length = Str::length('Laravel'); // 7Str::limit()
El método Str::limit trunca la cadena dada hasta la longitud especificada:
use Illuminate\Support\Str; $truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20); // The quick brown fox...Puede pasar un tercer argumento al método para cambiar la cadena que se añadirá al final de la cadena truncada:
use Illuminate\Support\Str; $truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)'); // The quick brown fox (...)Str::lower()
El método Str::lower convierte la cadena dada a minúsculas:
use Illuminate\Support\Str; $converted = Str::lower('LARAVEL'); // laravelStr::markdown()
El método Str::markdown convierte GitHub flavored Markdown en HTML utilizando CommonMark:
use Illuminate\Support\Str; $html = Str::markdown('# Laravel'); // <h1>Laravel</h1> $html = Str::markdown('# Taylor <b>Otwell</b>', [ 'html_input' => 'strip',]); // <h1>Taylor Otwell</h1>Str::mask()
El método Str::mask enmascara una parte de una cadena con un carácter repetido, y puede utilizarse para ofuscar segmentos de cadenas como direcciones de correo electrónico y números de teléfono:
use Illuminate\Support\Str; $string = Str::mask('taylor@example.com', '*', 3); // tay***************Si es necesario, proporcione un número negativo como tercer argumento del método mask, que indicará al método que comience a enmascarar a la distancia dada del final de la cadena:
$string = Str::mask('taylor@example.com', '*', -15, 3); // tay***@example.comStr::orderedUuid()
El método Str::orderedUuid genera un UUID "timestamp first" que puede almacenarse de forma eficiente en una columna indexada de la base de datos. Cada UUID que se genere utilizando este método se ordenará después de los UUID generados previamente utilizando el método:
use Illuminate\Support\Str; return (string) Str::orderedUuid();Str::padBoth()
El método Str::padBoth envuelve la función str_pad de PHP, rellenando ambos lados de una cadena con otra cadena hasta que la cadena final alcanza la longitud deseada:
use Illuminate\Support\Str; $padded = Str::padBoth('James', 10, '_'); // '__James___' $padded = Str::padBoth('James', 10); // ' James 'Str::padLeft()
El método Str::padLeft envuelve la función str_pad de PHP, rellenando el lado izquierdo de una cadena con otra cadena hasta que la cadena final alcanza la longitud deseada:
use Illuminate\Support\Str; $padded = Str::padLeft('James', 10, '-='); // '-=-=-James' $padded = Str::padLeft('James', 10); // ' James'Str::padRight()
El método Str::padRight envuelve la función str_pad de PHP, rellenando el lado derecho de una cadena con otra cadena hasta que la cadena final alcanza la longitud deseada:
use Illuminate\Support\Str; $padded = Str::padRight('James', 10, '-'); // 'James-----' $padded = Str::padRight('James', 10); // 'James 'Str::plural()
El método Str::plural convierte una cadena de palabras en singular a su forma plural. Esta función soporta cualquiera de los lenguajes soportados por el pluralizador de Laravel:
use Illuminate\Support\Str; $plural = Str::plural('car'); // cars $plural = Str::plural('child'); // childrenPuede proporcionar un número entero como segundo argumento de la función para recuperar la forma singular o plural de la cadena:
use Illuminate\Support\Str; $plural = Str::plural('child', 2); // children $singular = Str::plural('child', 1); // childStr::pluralStudly()
El método Str::pluralStudly convierte una palabra singular formateada en mayúsculas a su forma plural. Esta función soporta cualquiera de los lenguajes soportados por el pluralizador de Laravel:
use Illuminate\Support\Str; $plural = Str::pluralStudly('VerifiedHuman'); // VerifiedHumans $plural = Str::pluralStudly('UserFeedback'); // UserFeedbackPuede proporcionar un número entero como segundo argumento de la función para recuperar la forma singular o plural de la cadena:
use Illuminate\Support\Str; $plural = Str::pluralStudly('VerifiedHuman', 2); // VerifiedHumans $singular = Str::pluralStudly('VerifiedHuman', 1); // VerifiedHumanStr::random()
El método Str::random genera una cadena aleatoria de la longitud especificada. Esta función usa la función random_bytes de PHP:
use Illuminate\Support\Str; $random = Str::random(40);Str::remove()
El método Str::remove elimina el valor o array de valores dados de la cadena:
use Illuminate\Support\Str; $string = 'Peter Piper picked a peck of pickled peppers.'; $removed = Str::remove('e', $string); // Ptr Pipr pickd a pck of pickld ppprs.También puede pasar false como tercer argumento al método remove para ignorar mayúsculas y minúsculas al eliminar cadenas.
Str::replace()
El método Str::replace sustituye una cadena dada dentro de la cadena:
use Illuminate\Support\Str; $string = 'Laravel 8.x'; $replaced = Str::replace('8.x', '9.x', $string); // Laravel 9.xStr::replaceArray()
El método Str::replaceArray reemplaza un valor dado en la cadena secuencialmente usando un array:
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:00Str::replaceFirst()
El método Str::replaceFirst reemplaza la primera aparición 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 dogStr::replaceLast()
El método Str::replaceLast reemplaza la última aparición 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 dogStr::reverse()
El método Str::reverse invierte la cadena dada:
use Illuminate\Support\Str; $reversed = Str::reverse('Hello World'); // dlroW olleHStr::singular()
El método Str::singular convierte una cadena a su forma singular. Esta función soporta cualquiera de los lenguajes soportados por el pluralizador de Laravel:
use Illuminate\Support\Str; $singular = Str::singular('cars'); // car $singular = Str::singular('children'); // childStr::slug()
El método Str::slug genera una URL amigable "slug" a partir de la cadena dada:
use Illuminate\Support\Str; $slug = Str::slug('Laravel 5 Framework', '-'); // laravel-5-frameworkStr::snake()
El método Str::snake convierte la cadena dada a snake_case:
use Illuminate\Support\Str; $converted = Str::snake('fooBar'); // foo_bar $converted = Str::snake('fooBar', '-'); // foo-barStr::squish()
El método Str::squish elimina todos los espacios en blanco extraños de una cadena, incluidos los espacios en blanco extraños entre palabras:
use Illuminate\Support\Str; $string = Str::squish(' laravel framework '); // laravel frameworkStr::start()
El método Str::start añade una única instancia del valor dado a una cadena si no empieza ya con ese valor:
use Illuminate\Support\Str; $adjusted = Str::start('this/string', '/'); // /this/string $adjusted = Str::start('/this/string', '/'); // /this/stringStr::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'); // trueSi se pasa un array de posibles valores, el método startsWith devolverá true si la cadena empieza por alguno de los valores dados:
$result = Str::startsWith('This is my name', ['This', 'That', 'There']); // trueStr::studly()
El método Str::studly convierte la cadena dada a StudlyCase:
use Illuminate\Support\Str; $converted = Str::studly('foo_bar'); // FooBarStr::substr()
El método Str::substr devuelve la parte de la cadena especificada por los parámetros start y length:
use Illuminate\Support\Str; $converted = Str::substr('The Laravel Framework', 4, 7); // LaravelStr::substrCount()
El método Str::substrCount devuelve el número de apariciones de un valor dado en la cadena dada:
use Illuminate\Support\Str; $count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like'); // 2Str::substrReplace()
El método Str::substrReplace sustituye texto dentro de una parte de una cadena, empezando en la posición especificada por el tercer argumento y sustituyendo el número de caracteres especificado por el cuarto argumento. Pasando 0 al cuarto argumento del método se insertará la cadena en la posición especificada sin reemplazar ninguno de los caracteres existentes en la cadena:
use Illuminate\Support\Str; $result = Str::substrReplace('1300', ':', 2);// 13: $result = Str::substrReplace('1300', ':', 2, 0);// 13:00Str::swap()
El método Str::swap reemplaza múltiples valores en la cadena dada usando la función strtr de PHP:
use Illuminate\Support\Str; $string = Str::swap([ 'Tacos' => 'Burritos', 'great' => 'fantastic',], 'Tacos are great!'); // Burritos are fantastic!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 CaseStr::toHtmlString()
El método Str::toHtmlString convierte la instancia de cadena en una instancia de Illuminate\Support\HtmlString, que puede mostrarse en plantillas Blade:
use Illuminate\Support\Str; $htmlString = Str::of('Nuno Maduro')->toHtmlString();Str::ucfirst()
El método Str::ucfirst devuelve la cadena dada con el primer carácter en mayúsculas:
use Illuminate\Support\Str; $string = Str::ucfirst('foo bar'); // Foo barStr::ucsplit()
El método Str::ucsplit divide la cadena dada en un array por caracteres en mayúsculas:
use Illuminate\Support\Str; $segments = Str::ucsplit('FooBar'); // [0 => 'Foo', 1 => 'Bar']Str::upper()
El método Str::upper convierte la cadena dada a mayúsculas:
use Illuminate\Support\Str; $string = Str::upper('laravel'); // LARAVELStr::ulid()
El método Str::ulid genera un ULID:
use Illuminate\Support\Str; return (string) Str::ulid(); // 01gd6r360bp37zj17nxb55yv40Str::uuid()
El método Str::uuid genera un UUID (versión 4):
use Illuminate\Support\Str; return (string) Str::uuid();Str::wordCount()
El método Str::wordCount devuelve el número de palabras que contiene una cadena:
use Illuminate\Support\Str; Str::wordCount('Hello, world!'); // 2Str::words()
El método Str::words limita el número de palabras de una cadena. Puede pasarse una cadena adicional a este método a través de su tercer argumento para especificar qué cadena debe añadirse al final de la cadena truncada:
use Illuminate\Support\Str; return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>'); // Perfectly balanced, as >>>str()
La función str devuelve una nueva instancia Illuminate\Support\Stringable de la cadena dada. Esta función es equivalente al método Str::of:
$string = str('Taylor')->append(' Otwell'); // 'Taylor Otwell'Si no se proporciona ningún argumento a la función str, la función devuelve una instancia de Illuminate\Support\Str:
$snake = str()->snake('FooBar'); // 'foo_bar'trans()
La función trans traduce la clave de traducción dada utilizando sus archivos de localización:
echo trans('messages.welcome');Si la clave de traducción especificada no existe, la función trans devolverá la clave dada. Así, utilizando el ejemplo anterior, la función trans devolvería 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 especificada no existe, la función trans_choice devolverá la clave dada. Así, utilizando el ejemplo anterior, la función trans_choice devolvería messages.notifications si la clave de traducción no existe.
Fluent Strings
Las cadenas fluidas proporcionan una interfaz más fluida y orientada a objetos para trabajar con valores de cadena, lo que permite encadenar múltiples operaciones de cadena utilizando una sintaxis más legible en comparación con las operaciones de cadena tradicionales.
after
El método after devuelve todo lo que hay después del valor dado en una cadena. Se devolverá la cadena completa si el valor no existe dentro de la cadena:
use Illuminate\Support\Str; $slice = Str::of('This is my name')->after('This is'); // ' my name'afterLast
El método afterLast devuelve todo lo que hay después de la última aparición del valor dado en una cadena. Se devolverá la cadena entera si el valor no existe dentro de la cadena:
use Illuminate\Support\Str; $slice = Str::of('App\Http\Controllers\Controller')->afterLast('\\'); // 'Controller'append
El método append añade los valores dados a la cadena:
use Illuminate\Support\Str; $string = Str::of('Taylor')->append(' Otwell'); // 'Taylor Otwell'ascii
El método ascii intentará transcribir la cadena a un valor ASCII:
use Illuminate\Support\Str; $string = Str::of('ü')->ascii(); // 'u'basename
El método basename devolverá el componente final del nombre de la cadena dada:
use Illuminate\Support\Str; $string = Str::of('/foo/bar/baz')->basename(); // 'baz'Si es necesario, puede proporcionar una "extensión" que se eliminará del componente final:
use Illuminate\Support\Str; $string = Str::of('/foo/bar/baz.jpg')->basename('.jpg'); // 'baz'before
El método before devuelve todo lo que hay antes del valor dado en una cadena:
use Illuminate\Support\Str; $slice = Str::of('This is my name')->before('my name'); // 'This is 'beforeLast
El método beforeLast devuelve todo lo que hay antes de la última aparición del valor dado en una cadena:
use Illuminate\Support\Str; $slice = Str::of('This is my name')->beforeLast('is'); // 'This 'between
El método between devuelve la parte de una cadena comprendida entre dos valores:
use Illuminate\Support\Str; $converted = Str::of('This is my name')->between('This', 'name'); // ' is my 'betweenFirst
El método betweenFirst devuelve la porción más pequeña posible de una cadena entre dos valores:
use Illuminate\Support\Str; $converted = Str::of('[a] bc [d]')->betweenFirst('[', ']'); // 'a'camel
El método camel convierte la cadena dada a camelCase:
use Illuminate\Support\Str; $converted = Str::of('foo_bar')->camel(); // fooBarclassBasename
El método classBasename devuelve el nombre de la clase dada sin su espacio de nombres:
use Illuminate\Support\Str; $class = Str::of('Foo\Bar\Baz')->classBasename(); // Bazcontains
El método contains determina si la cadena dada contiene el valor dado. Este método distingue entre mayúsculas y minúsculas:
use Illuminate\Support\Str; $contains = Str::of('This is my name')->contains('my'); // trueTambién puede pasar un array de valores para determinar si la cadena dada contiene alguno de los valores de el array:
use Illuminate\Support\Str; $contains = Str::of('This is my name')->contains(['my', 'foo']); // truecontainsAll
El método containsAll determina si la cadena dada contiene todos los valores de el array dado:
use Illuminate\Support\Str; $containsAll = Str::of('This is my name')->containsAll(['my', 'name']); // truedirname
El método dirname devuelve la parte del directorio padre de la cadena dada:
use Illuminate\Support\Str; $string = Str::of('/foo/bar/baz')->dirname(); // '/foo/bar'Si es necesario, puede especificar cuántos niveles de directorio desea recortar de la cadena:
use Illuminate\Support\Str; $string = Str::of('/foo/bar/baz')->dirname(2); // '/foo'excerpt
El método excerpt extrae un fragmento de la cadena que coincide con la primera instancia de una frase dentro de esa cadena:
use Illuminate\Support\Str; $excerpt = Str::of('This is my name')->excerpt('my', [ 'radius' => 3]); // '...is my na...'La opción radio, que por defecto es 100, le permite definir el número de caracteres que deben aparecer a cada lado de la cadena truncada.
Además, puede utilizar la opción de omisión para cambiar la cadena que se antepondrá y añadirá a la cadena truncada:
use Illuminate\Support\Str; $excerpt = Str::of('This is my name')->excerpt('name', [ 'radius' => 3, 'omission' => '(...) ']); // '(...) my name'endsWith
El método endsWith determina si la cadena dada termina con el valor dado:
use Illuminate\Support\Str; $result = Str::of('This is my name')->endsWith('name'); // trueTambién puede pasar un array de valores para determinar si la cadena dada termina con cualquiera de los valores de el array:
use Illuminate\Support\Str; $result = Str::of('This is my name')->endsWith(['name', 'foo']); // true $result = Str::of('This is my name')->endsWith(['this', 'foo']); // falseexactly
El método exactly determina si la cadena dada coincide exactamente con otra cadena:
use Illuminate\Support\Str; $result = Str::of('Laravel')->exactly('Laravel'); // trueexplode
El método explode divide la cadena por el delimitador dado y devuelve una colección que contiene cada sección de la cadena dividida:
use Illuminate\Support\Str; $collection = Str::of('foo bar baz')->explode(' '); // collect(['foo', 'bar', 'baz'])finish
El método finish añade una única instancia del valor dado a una cadena si no termina ya con ese valor:
use Illuminate\Support\Str; $adjusted = Str::of('this/string')->finish('/'); // this/string/ $adjusted = Str::of('this/string/')->finish('/'); // this/string/headline
El método headline convierte cadenas delimitadas por mayúsculas, guiones o guiones bajos en una cadena delimitada por espacios con la primera letra de cada palabra en mayúscula:
use Illuminate\Support\Str; $headline = Str::of('taylor_otwell')->headline(); // Taylor Otwell $headline = Str::of('EmailNotificationSent')->headline(); // Email Notification SentinlineMarkdown
El método inlineMarkdown convierte Markdown (tipo GitHub) en HTML en línea utilizando CommonMark. Sin embargo, a diferencia del método markdown, no envuelve todo el HTML generado en un elemento a nivel de bloque:
use Illuminate\Support\Str; $html = Str::of('**Laravel**')->inlineMarkdown(); // <strong>Laravel</strong>is
El método is determina si una cadena dada coincide con un patrón dado. Los asteriscos pueden utilizarse como comodines
use Illuminate\Support\Str; $matches = Str::of('foobar')->is('foo*'); // true $matches = Str::of('foobar')->is('baz*'); // falseisAscii
El método isAscii determina si una cadena dada es una cadena ASCII:
use Illuminate\Support\Str; $result = Str::of('Taylor')->isAscii(); // true $result = Str::of('ü')->isAscii(); // falseisEmpty
El método isEmpty determina si la cadena dada está vacía:
use Illuminate\Support\Str; $result = Str::of(' ')->trim()->isEmpty(); // true $result = Str::of('Laravel')->trim()->isEmpty(); // falseisNotEmpty
El método isNotEmpty determina si la cadena dada no está vacía:
use Illuminate\Support\Str; $result = Str::of(' ')->trim()->isNotEmpty(); // false $result = Str::of('Laravel')->trim()->isNotEmpty(); // trueisJson
El método isJson determina si una cadena dada es un JSON válido:
use Illuminate\Support\Str; $result = Str::of('[1,2,3]')->isJson(); // true $result = Str::of('{"first": "John", "last": "Doe"}')->isJson(); // true $result = Str::of('{first: "John", last: "Doe"}')->isJson(); // falseisUlid
El método isUlid determina si una cadena dada es un ULID:
use Illuminate\Support\Str; $result = Str::of('01gd6r360bp37zj17nxb55yv40')->isUlid(); // true $result = Str::of('Taylor')->isUlid(); // falseisUuid
El método isUuid determina si una cadena dada es un UUID:
use Illuminate\Support\Str; $result = Str::of('5ace9ab9-e9cf-4ec6-a19d-5881212a452c')->isUuid(); // true $result = Str::of('Taylor')->isUuid(); // falsekebab
El método kebab convierte la cadena dada a kebab-case:
use Illuminate\Support\Str; $converted = Str::of('fooBar')->kebab(); // foo-barlcfirst
El método lcfirst devuelve la cadena dada con el primer carácter en minúsculas:
use Illuminate\Support\Str; $string = Str::of('Foo Bar')->lcfirst(); // foo Barlength
El método length devuelve la longitud de la cadena dada:
use Illuminate\Support\Str; $length = Str::of('Laravel')->length(); // 7limit
El método limit trunca la cadena dada hasta la longitud especificada:
use Illuminate\Support\Str; $truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20); // The quick brown fox...También puede pasar un segundo argumento para cambiar la cadena que se añadirá al final de la cadena truncada:
use Illuminate\Support\Str; $truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)'); // The quick brown fox (...)lower
El método lower convierte la cadena dada a minúsculas:
use Illuminate\Support\Str; $result = Str::of('LARAVEL')->lower(); // 'laravel'ltrim
El método ltrim recorta el lado izquierdo de la cadena:
use Illuminate\Support\Str; $string = Str::of(' Laravel ')->ltrim(); // 'Laravel ' $string = Str::of('/Laravel/')->ltrim('/'); // 'Laravel/'markdown
El método markdown convierte Markdown (en su variante GitHub) en HTML:
use Illuminate\Support\Str; $html = Str::of('# Laravel')->markdown(); // <h1>Laravel</h1> $html = Str::of('# Taylor <b>Otwell</b>')->markdown([ 'html_input' => 'strip',]); // <h1>Taylor Otwell</h1>mask
El método mask enmascara una parte de una cadena con un carácter repetido, y puede utilizarse para ofuscar segmentos de cadenas como direcciones de correo electrónico y números de teléfono:
use Illuminate\Support\Str; $string = Str::of('taylor@example.com')->mask('*', 3); // tay***************Si es necesario, proporcione un número negativo como tercer argumento al método mask, que le indicará que comience a enmascarar a la distancia dada del final de la cadena:
$string = Str::of('taylor@example.com')->mask('*', -15, 3); // tay***@example.commatch
El método match devuelve la parte de una cadena que coincide con un patrón de expresión regular dado:
use Illuminate\Support\Str; $result = Str::of('foo bar')->match('/bar/'); // 'bar' $result = Str::of('foo bar')->match('/foo (.*)/'); // 'bar'matchAll
El método matchAll devuelve una colección que contiene las partes de una cadena que coinciden con un patrón de expresión regular dado:
use Illuminate\Support\Str; $result = Str::of('bar foo bar')->matchAll('/bar/'); // collect(['bar', 'bar'])Si especifica un grupo coincidente dentro de la expresión, Laravel devolverá una colección con las coincidencias de ese grupo:
use Illuminate\Support\Str; $result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/'); // collect(['un', 'ly']);Si no se encuentra ninguna coincidencia, se devolverá una colección vacía.
newLine
El método newLine añade un carácter de "fin de línea" a una cadena:
use Illuminate\Support\Str; $padded = Str::of('Laravel')->newLine()->append('Framework'); // 'Laravel// Framework'padBoth
El método padBoth envuelve la función str_pad de PHP, rellenando ambos lados de una cadena con otra cadena hasta que la cadena final alcanza la longitud deseada:
use Illuminate\Support\Str; $padded = Str::of('James')->padBoth(10, '_'); // '__James___' $padded = Str::of('James')->padBoth(10); // ' James 'padLeft
El método padLeft envuelve la función str_pad de PHP, rellenando el lado izquierdo de una cadena con otra cadena hasta que la cadena final alcanza la longitud deseada:
use Illuminate\Support\Str; $padded = Str::of('James')->padLeft(10, '-='); // '-=-=-James' $padded = Str::of('James')->padLeft(10); // ' James'padRight
El método padRight envuelve la función str_pad de PHP, rellenando el lado derecho de una cadena con otra cadena hasta que la cadena final alcance la longitud deseada:
use Illuminate\Support\Str; $padded = Str::of('James')->padRight(10, '-'); // 'James-----' $padded = Str::of('James')->padRight(10); // 'James 'pipe
El método pipe permite transformar la cadena pasando su valor actual a la llamada dada:
use Illuminate\Support\Str; $hash = Str::of('Laravel')->pipe('md5')->prepend('Checksum: '); // 'Checksum: a5c95b86291ea299fcbe64458ed12702' $closure = Str::of('foo')->pipe(function ($str) { return 'bar';}); // 'bar'plural
El método plural convierte una cadena de palabras en singular a su forma plural. Esta función soporta cualquiera de los lenguajes soportados por el pluralizador de Laravel:
use Illuminate\Support\Str; $plural = Str::of('car')->plural(); // cars $plural = Str::of('child')->plural(); // childrenPuede proporcionar un número entero como segundo argumento de la función para recuperar la forma singular o plural de la cadena:
use Illuminate\Support\Str; $plural = Str::of('child')->plural(2); // children $plural = Str::of('child')->plural(1); // childprepend
El método prepend añade los valores dados a la cadena:
use Illuminate\Support\Str; $string = Str::of('Framework')->prepend('Laravel '); // Laravel Frameworkremove
El método remove elimina el valor o el array de valores dados de la cadena:
use Illuminate\Support\Str; $string = Str::of('Arkansas is quite beautiful!')->remove('quite'); // Arkansas is beautiful!También puede pasar false como segundo parámetro para ignorar mayúsculas y minúsculas al eliminar cadenas.
replace
El método replace reemplaza una cadena dada dentro de la cadena:
use Illuminate\Support\Str; $replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x'); // Laravel 7.xreplaceArray
El método replaceArray reemplaza un valor dado en la cadena secuencialmente usando un array:
use Illuminate\Support\Str; $string = 'The event will take place between ? and ?'; $replaced = Str::of($string)->replaceArray('?', ['8:30', '9:00']); // The event will take place between 8:30 and 9:00replaceFirst
El método replaceFirst reemplaza la primera aparición de un valor dado en una cadena:
use Illuminate\Support\Str; $replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceFirst('the', 'a'); // a quick brown fox jumps over the lazy dogreplaceLast
El método replaceLast reemplaza la última aparición de un valor dado en una cadena:
use Illuminate\Support\Str; $replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceLast('the', 'a'); // the quick brown fox jumps over a lazy dogreplaceMatches
El método replaceMatches sustituye todas las partes de una cadena que coincidan con un patrón por la cadena de sustitución dada:
use Illuminate\Support\Str; $replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '') // '15015551000'El método replaceMatches también acepta un closure que será invocado con cada porción de la cadena que coincida con el patrón dado, permitiéndole realizar la lógica de reemplazo dentro del closure y devolver el valor reemplazado:
use Illuminate\Support\Str; $replaced = Str::of('123')->replaceMatches('/\d/', function ($match) { return '['.$match[0].']';}); // '[1][2][3]'rtrim
El método rtrim recorta el lado derecho de la cadena dada:
use Illuminate\Support\Str; $string = Str::of(' Laravel ')->rtrim(); // ' Laravel' $string = Str::of('/Laravel/')->rtrim('/'); // '/Laravel'scan
El método scan analiza la entrada de una cadena en una colección de acuerdo a un formato soportado por la función PHPsscanf:
use Illuminate\Support\Str; $collection = Str::of('filename.jpg')->scan('%[^.].%s'); // collect(['filename', 'jpg'])singular
El método singular convierte una cadena a su forma singular. Esta función soporta cualquiera de los lenguajes soportados por el pluralizador de Laravel:
use Illuminate\Support\Str; $singular = Str::of('cars')->singular(); // car $singular = Str::of('children')->singular(); // childslug
El método slug genera una URL amigable "slug" a partir de la cadena dada:
use Illuminate\Support\Str; $slug = Str::of('Laravel Framework')->slug('-'); // laravel-frameworksnake
El método snake convierte la cadena dada a snake_case:
use Illuminate\Support\Str; $converted = Str::of('fooBar')->snake(); // foo_barsplit
El método split divide una cadena en una colección utilizando una expresión regular:
use Illuminate\Support\Str; $segments = Str::of('one, two, three')->split('/[\s,]+/'); // collect(["one", "two", "three"])squish
El método squish elimina todos los espacios en blanco extraños de una cadena, incluidos los espacios en blanco extraños entre palabras:
use Illuminate\Support\Str; $string = Str::of(' laravel framework ')->squish(); // laravel frameworkstart
El método start añade una única instancia del valor dado a una cadena si no empieza ya con ese valor:
use Illuminate\Support\Str; $adjusted = Str::of('this/string')->start('/'); // /this/string $adjusted = Str::of('/this/string')->start('/'); // /this/stringstartsWith
El método startsWith determina si la cadena dada empieza por el valor dado:
use Illuminate\Support\Str; $result = Str::of('This is my name')->startsWith('This'); // truestudly
El método studly convierte la cadena dada a StudlyCase:
use Illuminate\Support\Str; $converted = Str::of('foo_bar')->studly(); // FooBarsubstr
El método substr devuelve la parte de la cadena especificada por los parámetros start y length dados:
use Illuminate\Support\Str; $string = Str::of('Laravel Framework')->substr(8); // Framework $string = Str::of('Laravel Framework')->substr(8, 5); // FramesubstrReplace
El método substrReplace sustituye texto dentro de una parte de una cadena, empezando en la posición especificada por el segundo argumento y sustituyendo el número de caracteres especificado por el tercer argumento. Si se pasa 0 al tercer argumento del método, se insertará la cadena en la posición especificada sin reemplazar ninguno de los caracteres existentes en la cadena:
use Illuminate\Support\Str; $string = Str::of('1300')->substrReplace(':', 2); // 13: $string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0); // The Laravel Frameworkswap
El método swap reemplaza múltiples valores en la cadena usando la función strtr de PHP:
use Illuminate\Support\Str; $string = Str::of('Tacos are great!') ->swap([ 'Tacos' => 'Burritos', 'great' => 'fantastic', ]); // Burritos are fantastic!tap
El método tap pasa la cadena al closure dado, permitiéndole examinar e interactuar con la cadena sin afectar a la propia cadena. La cadena original es devuelta por el método tap independientemente de lo que sea devuelto por el closure:
use Illuminate\Support\Str; $string = Str::of('Laravel') ->append(' Framework') ->tap(function ($string) { dump('String after append: '.$string); }) ->upper(); // LARAVEL FRAMEWORKtest
El método test determina si una cadena coincide con el patrón de expresión regular dado:
use Illuminate\Support\Str; $result = Str::of('Laravel Framework')->test('/Laravel/'); // truetitle
El método title convierte la cadena dada a Title Case:
use Illuminate\Support\Str; $converted = Str::of('a nice title uses the correct case')->title(); // A Nice Title Uses The Correct Casetrim
El método trim recorta la cadena dada:
use Illuminate\Support\Str; $string = Str::of(' Laravel ')->trim(); // 'Laravel' $string = Str::of('/Laravel/')->trim('/'); // 'Laravel'ucfirst
El método ucfirst devuelve la cadena dada con el primer carácter en mayúscula:
use Illuminate\Support\Str; $string = Str::of('foo bar')->ucfirst(); // Foo barucsplit
El método ucsplit divide la cadena dada en una colección por caracteres en mayúsculas:
use Illuminate\Support\Str; $string = Str::of('Foo Bar')->ucsplit(); // collect(['Foo', 'Bar'])upper
El método upper convierte la cadena dada a mayúsculas:
use Illuminate\Support\Str; $adjusted = Str::of('laravel')->upper(); // LARAVELwhen
El método when invoca el closure dado si una condición dada es true. El closure recibirá la instancia de la cadena fluent:
use Illuminate\Support\Str; $string = Str::of('Taylor') ->when(true, function ($string) { return $string->append(' Otwell'); }); // 'Taylor Otwell'Si es necesario, puede pasar otro closure como tercer parámetro al método when. Este closure se ejecutará si el parámetro de la condición se evalúa como false.
whenContains
El método whenContains invoca el closure dado si la cadena contiene el valor dado. El closure recibirá la instancia fluent string:
use Illuminate\Support\Str; $string = Str::of('tony stark') ->whenContains('tony', function ($string) { return $string->title(); }); // 'Tony Stark'Si es necesario, puede pasar otro closure como tercer parámetro al método when. Este closure se ejecutará si la cadena no contiene el valor dado.
También puede pasar un array de valores para determinar si la cadena dada contiene alguno de los valores de el array:
use Illuminate\Support\Str; $string = Str::of('tony stark') ->whenContains(['tony', 'hulk'], function ($string) { return $string->title(); }); // Tony StarkwhenContainsAll
El método whenContainsAll invoca el closure dado si la cadena contiene todas las subcadenas dadas. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('tony stark') ->whenContainsAll(['tony', 'stark'], function ($string) { return $string->title(); }); // 'Tony Stark'Si es necesario, puede pasar otro closure como tercer parámetro al método when. Este closure se ejecutará si el parámetro de condición es false.
whenEmpty
El método whenEmpty invoca el closure dado si la cadena está vacía. Si el closure devuelve un valor, éste también será devuelto por el método whenEmpty. Si el closure no devuelve ningún valor, se devolverá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of(' ')->whenEmpty(function ($string) { return $string->trim()->prepend('Laravel');}); // 'Laravel'whenNotEmpty
El método whenNotEmpty invoca el closure dado si la cadena no está vacía. Si el closure devuelve un valor, éste también será devuelto por el método whenNotEmpty. Si el closure no devuelve ningún valor, se devolverá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('Framework')->whenNotEmpty(function ($string) { return $string->prepend('Laravel ');}); // 'Laravel Framework'whenStartsWith
El método whenStartsWith invoca el closure dado si la cadena comienza con la subcadena dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('disney world')->whenStartsWith('disney', function ($string) { return $string->title();}); // 'Disney World'whenEndsWith
El método whenEndsWith invoca el closure dado si la cadena termina con la subcadena dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('disney world')->whenEndsWith('world', function ($string) { return $string->title();}); // 'Disney World'whenExactly
El método whenExactly invoca el closure dado si la cadena coincide exactamente con la cadena dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('laravel')->whenExactly('laravel', function ($string) { return $string->title();}); // 'Laravel'whenNotExactly
El método whenNotExactly invoca el closure dado si la cadena no coincide exactamente con la cadena dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('framework')->whenNotExactly('laravel', function ($string) { return $string->title();}); // 'Framework'whenIs
El método whenIs invoca el closure dado si la cadena coincide con un patrón dado. Se pueden utilizar asteriscos como comodines. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('foo/bar')->whenIs('foo/*', function ($string) { return $string->append('/baz');}); // 'foo/bar/baz'whenIsAscii
El método whenIsAscii invoca el closure dado si la cadena es ASCII de 7 bits. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('laravel')->whenIsAscii(function ($string) { return $string->title();}); // 'Laravel'whenIsUlid
El método whenIsUlid invoca el closure dado si la cadena es un ULID válido. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function ($string) { return $string->substr(0, 8);}); // '01gd6r36'whenIsUuid
El método whenIsUuid invoca el closure dado si la cadena es un UUID válido. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('a0a2a2d2-0b87-4a18-83f2-2529882be2de')->whenIsUuid(function ($string) { return $string->substr(0, 8);}); // 'a0a2a2d2'whenTest
El método whenTest invoca el closure dado si la cadena coincide con la expresión regular dada. El closure recibirá la instancia de cadena fluida:
use Illuminate\Support\Str; $string = Str::of('laravel framework')->whenTest('/laravel/', function ($string) { return $string->title();}); // 'Laravel Framework'wordCount
El método wordCount devuelve el número de palabras que contiene una cadena:
use Illuminate\Support\Str; Str::of('Hello, world!')->wordCount(); // 2words
El método words limita el número de palabras de una cadena. Si es necesario, puede especificar una cadena adicional que se añadirá a la cadena truncada:
use Illuminate\Support\Str; $string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>'); // Perfectly balanced, as >>>URLs
action()
La función action genera una URL para la acción del controlador dada:
use App\Http\Controllers\HomeController; $url = action([HomeController::class, 'index']);Si el método acepta parámetros de ruta, puede pasarlos como segundo argumento al método:
$url = action([UserController::class, 'profile'], ['id' => 1]);asset()
La función asset genera una URL para un asset utilizando el esquema actual de la petición (HTTP o HTTPS):
$url = asset('img/photo.jpg');Puede configurar el host de la URL de asset estableciendo la variable ASSET_URL en su archivo .env. Esto puede ser útil si aloja sus activos 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.jpgroute()
La función route genera una URL para una ruta dada:
$url = route('route.name');Si la ruta acepta parámetros, puede 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 desea generar una URL relativa, puede 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 activo utilizando HTTPS:
$url = secure_asset('img/photo.jpg');secure_url()
La función secure_url genera una URL HTTPS completa para la ruta indicada. 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 determinada:
return to_route('users.show', ['user' => 1]);Si es necesario, puede pasar el código de estado HTTP que debe asignarse a la redirección y cualquier cabecera de respuesta adicional como tercer y cuarto argumento del método to_route:
return to_route('users.show', ['user' => 1], 302, ['X-Framework' => 'Laravel']);url()
La función url genera una URL completa para la ruta dada:
$url = url('user/profile'); $url = url('user/profile', [1]);Si no se proporciona ninguna ruta, se devuelve una instancia de Illuminate\Routing\UrlGenerator:
$current = url()->current(); $full = url()->full(); $previous = url()->previous();Varios
abort()
La función abort lanza una excepción HTTP que será procesada por el gestor de excepciones:
abort(403);También puede proporcionar el mensaje de la excepción y las cabeceras de respuesta HTTP personalizadas que deben enviarse 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 puede proporcionar el texto de respuesta de la excepción como tercer argumento y un array de cabeceras de respuesta personalizadas como cuarto argumento de 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 en el método abort, también puede proporcionar el texto de respuesta de la excepción como tercer argumento y un array de encabezados de respuesta personalizados como cuarto argumento de la función.
app()
La función app devuelve la instancia del contenedor de servicios:
$container = app();Puede pasar un nombre de clase o interfaz para resolverlo desde el contenedor:
$api = app('HelpSpot\API');auth()
La función auth devuelve una instancia authenticator. Puede utilizarla como alternativa a la facade Auth:
$user = auth()->user();Si es necesario, puede especificar a qué instancia de guard desea 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 realiza el hash del valor dado utilizando Bcrypt. Puede utilizar esta función como alternativa a la facade Hash:
$password = bcrypt('my-secret-password');blank()
La función blank determina si el valor dado es "blank":
blank('');blank(' ');blank(null);blank(collect()); // true blank(0);blank(true);blank(false); // falsePara la inversa de blank, véase el método filled.
broadcast()
La función broadcast realiza el broadcast del evento dado a sus oyentes:
broadcast(new UserRegistered($user)); broadcast(new UserRegistered($user))->toOthers();cache()
La función cache puede utilizarse para obtener valores de la cache. Si la clave dada no existe en la cache, se devolverá un valor por defecto opcional:
$value = cache('key'); $value = cache('key', 'default');Puede añadir elementos a la cache pasando un array de pares clave / valor a la función. También debe pasar el número de segundos o 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 devuelve todos los traits utilizados por una clase, incluyendo los traits utilizados por todas sus clases padre:
$traits = class_uses_recursive(App\Models\User::class);collect()
La función collect crea una instancia de collection a partir del valor dado:
$collection = collect(['taylor', 'abigail']);config()
La función config obtiene el valor de una variable de configuración. Se puede acceder a los valores de configuración utilizando la sintaxis "dot", que incluye el nombre del archivo y la opción a la que se desea acceder. Se puede especificar un valor por defecto, que se devuelve si la opción de configuración no existe:
$value = config('app.timezone'); $value = config('app.timezone', $default);Puede establecer variables de configuración en tiempo de ejecución pasando un array de pares clave / valor. Sin embargo, tenga en cuenta que esta función sólo afecta al valor de configuración para la solicitud actual y no actualiza sus 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 hidden HTML que contiene el valor del token CSRF. Por ejemplo, utilizando la sintaxis Blade:
{{ csrf_field() }}csrf_token()
La función csrf_token recupera el valor del token CSRF actual:
$token = csrf_token();decrypt()
La función decrypt descifra el valor dado. Puede utilizar esta función como alternativa a la facade Crypt:
$password = decrypt($value);dd()
La función dd vuelca las variables dadas y finaliza la ejecución del script:
dd($value); dd($value1, $value2, $value3, ...);Si no desea detener la ejecución de su script, utilice en su lugar la función dump.
dispatch()
La función dispatch manda el trabajo (job) dado a la cola de trabajos de Laravel:
dispatch(new App\Jobs\SendEmails);dump()
La función dump vuelca las variables dadas:
dump($value); dump($value1, $value2, $value3, ...);Si desea detener la ejecución del script después de volcar las variables, utilice 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 facade Crypt:
$secret = encrypt('my-secret-value');env()
La función env recupera el valor de una variable de entorno o devuelve un valor por defecto:
$env = env('APP_ENV'); $env = env('APP_ENV', 'production');Advertencia
Si ejecutas el comandoconfig:cachedurante tu proceso de despliegue, debes asegurarte de que sólo estás llamando a la funciónenvdesde dentro de tus archivos de configuración. Una vez que la configuración ha sido cacheada, el archivo.envno será cargado y todas las llamadas a la funciónenvdevolveránnull.
event()
La función event envía el evento dado a sus "oyentes":
event(new UserRegistered($user));fake()
La función fake resuelve un singleton Faker del contenedor, lo que puede ser útil al crear datos falsos en factories, seeders, tests o prototipando vistas:
@for($i = 0; $i < 10; $i++) <dl> <dt>Name</dt> <dd>{{ fake()->name() }}</dd> <dt>Email</dt> <dd>{{ fake()->unique()->safeEmail() }}</dd> </dl>@endforPor defecto, la función fake utilizará la opción de configuración app.faker_locale en su fichero de configuración config/app.php; sin embargo, también puede especificar la configuración regional pasándola a la función fake. Cada configuración regional resolverá un singleton individual:
fake('nl_NL')->name()filled()
La función filled determina si el valor dado no es "blank":
filled(0);filled(true);filled(false); // true filled('');filled(' ');filled(null);filled(collect()); // falsePara la inversa de filled, véase el método blank.
info()
La función info escribirá información en el log de su aplicación:
info('Some helpful information!');También se puede pasar a la función un array de datos contextuales:
info('User login attempt failed.', ['id' => $user->id]);logger()
La función logger puede utilizarse para escribir un mensaje de nivel de depuración en el log:
logger('Debug message');También se puede pasar a la función un array de datos contextuales:
logger('User has logged in.', ['id' => $user->id]);Se devolverá una instancia de logger 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 hidden HTML que contiene el valor "para burlar" verbo HTTP del formulario. Por ejemplo, utilizando la sintaxis de Blade:
<form method="POST"> {{ method_field('DELETE') }}</form>now()
La función now crea una nueva instancia Illuminate\Support\Carbon para la hora actual:
$now = now();old()
La función old recupera un valor de entrada antiguo introducido en la sesión:
$value = old('value'); $value = old('value', 'default');Dado que el "valor por defecto" proporcionado como segundo argumento a la función old es a menudo un atributo de un modelo Eloquent, Laravel le permite simplemente pasar todo el modelo Eloquent 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 de Eloquent que debe considerarse el "valor por defecto":
{{ old('name', $user->name) }} // Is equivalent to... {{ old('name', $user) }}optional()
La función optional acepta cualquier argumento y permite acceder a propiedades o llamar a métodos de ese objeto. Si el objeto dado es null, las propiedades y métodos devolverán null en lugar de provocar un error:
return optional($user->address)->street; {!! old('name', optional($user)->name) !!}La función opcional también acepta un closure como segundo argumento. El closure se invocará si el valor proporcionado como primer argumento no es nulo:
return optional(User::find($id), function ($user) { return $user->name;});policy()
El método policy recupera una instancia de policy 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 del redirector 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 utilizando su gestor de excepciones:
report($e);La función report también acepta una cadena como argumento. Cuando se da una cadena a la función, ésta creará una excepción con la cadena dada como mensaje:
report('Something went wrong.');report_if()
La función report_if informará de una excepción utilizando su gestor 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 utilizando su gestor 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 de request actual u obtiene el valor de un campo de entrada de la petición actual:
$request = request(); $value = request('key', $default);rescue()
La función rescue ejecuta el closure dado y captura cualquier excepción que ocurra durante su ejecución. Todas las excepciones capturadas serán enviadas a su gestor de excepciones; sin embargo, la petición continuará procesándose:
return rescue(function () { return $this->method();});También puede pasar un segundo argumento a la función de rescue. Este argumento será el valor "por defecto" que se devolverá si se produce una excepción durante la ejecución del 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 una instancia utilizando el contenedor de servicios:
$api = resolve('HelpSpot\API');response()
La función response crea una instancia de response u obtiene una instancia de la fábrica de respuestas:
return response('Hello World', 200, $headers); return response()->json(['foo' => 'bar'], 200, $headers);retry()
La función retry intenta ejecutar la llamada de retorno dada hasta que se alcanza el umbral máximo de intentos dado. Si la llamada de retorno no lanza una excepción, se devolverá su valor. Si la llamada de retorno lanza una excepción, se reintentará automáticamente. Si se supera el número máximo de intentos, se lanzará la excepción:
return retry(5, function () { // Attempt 5 times while resting 100ms between attempts...}, 100);Si desea calcular manualmente el número de milisegundos que deben transcurrir entre los intentos, puede pasar un closure como tercer argumento a la función de retry:
return retry(5, function () { // ...}, function ($attempt, $exception) { return $attempt * 100;});Para mayor comodidad, puede proporcionar un array como primer argumento de la función retry. Esta array se utilizará para determinar cuántos milisegundos deben transcurrir entre los siguientes intentos:
return retry([100, 200], function () { // Sleep for 100ms on first retry, 200ms on second retry...});Para reintentar sólo bajo condiciones específicas, puedes pasar un closure como cuarto argumento a la función retry:
return retry(5, function () { // ...}, 100, function ($exception) { return $exception instanceof RetryException;});session()
La función session puede utilizarse para obtener o establecer valores de session:
$value = session('key');Puede establecer valores pasando un array de pares clave / valor a la función:
session(['chairs' => 7, 'instruments' => 3]);El almacén de sesiones se devolverá 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 $valor arbitrario y un closure. El $valor será pasado al closure y luego devuelto por la función tap. El valor de retorno del closure es irrelevante:
$user = tap(User::first(), function ($user) { $user->name = 'taylor'; $user->save();});Si no se pasa ningún closure a la función tap, puede llamar a cualquier método con el $valor dado. El valor de retorno del método al que llame siempre será $valor, independientemente de lo que el método devuelva realmente en su definición. Por ejemplo, el método update de Eloquent normalmente devuelve un entero. Sin embargo, podemos forzar que el método devuelva el propio modelo encadenando la llamada al método update a través de la función tap:
$user = tap($user)->update([ 'name' => $name, 'email' => $email,]);Para añadir un método tap a una clase, puede añadir el trait Illuminate\Support\Traits\Tappable a la clase. El método tap de este trait acepta un closure como único argumento. La propia instancia del objeto se pasará al closure y luego será devuelta por el método tap:
return $user->tap(function ($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 es 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 closure sobre un valor dado si el valor no es blank y luego devuelve el valor de retorno del closure:
$callback = function ($value) { return $value * 2;}; $result = transform(5, $callback); // 10Se puede pasar un valor por defecto o un closure como tercer argumento de la función. Este valor se devolverá si el valor dado está vacío:
$result = transform(null, $callback, 'The value is blank'); // The value is blankvalidator()
La función validator crea una nueva instancia de validator con los argumentos dados. Se puede utilizar como alternativa a la facade Validator:
$validator = validator($data, $rules, $messages);value()
La función value devuelve el valor que se le da. Sin embargo, si se pasa un closure a la función, el closure se ejecutará y se devolverá su valor:
$result = value(true); // true $result = value(function () { return false;}); // falseview()
La función view recupera una instancia de view:
return view('auth.login');with()
La función with devuelve el valor que se le pasa. Si se pasa un closure como segundo argumento a la función, se ejecutará el closure y se devolverá su valor:
$callback = function ($value) { return is_numeric($value) ? $value * 2 : 0;}; $result = with(5, $callback); // 10 $result = with(null, $callback); // 0 $result = with(5, null); // 5Otras utilidades
Benchmarking
A veces es posible que desee probar rápidamente el rendimiento de ciertas partes de su aplicación. En esas ocasiones, puedes utilizar la clase de soporte Benchmark para medir el número de milisegundos que tardan en completarse las llamadas de retorno 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, los callbacks dados se ejecutarán una vez (una iteración), y su duración se mostrará en el navegador / consola.
Para invocar una llamada de retorno más de una vez, puede especificar el número de iteraciones que la llamada de retorno debe ser invocada como segundo argumento del método. Cuando se ejecuta un callback más de una vez, la clase Benchmark devolverá la cantidad media de milisegundos que se tardó en ejecutar el callback en todas las iteraciones:
Benchmark::dd(fn () => User::count(), iterations: 10); // 0.5 msLottery
La clase Lottery de Laravel puede utilizarse para ejecutar callbacks basados en un conjunto de probabilidades dadas. Esto puede ser particularmente útil cuando sólo se desea ejecutar código para un porcentaje de las peticiones entrantes:
use Illuminate\Support\Lottery; Lottery::odds(1, 20) ->winner(fn () => $user->won()) ->loser(fn () => $user->lost()) ->choose();Puede combinar la clase Lottery de Laravel con otras características de Laravel. Por ejemplo, es posible que sólo desee informar de un pequeño porcentaje de consultas lentas a su gestor de excepciones. Y, puesto que la clase Lottery es invocable, podemos pasar una instancia de la clase a cualquier método que acepte invocables:
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.')),);Testing Lottery
Laravel proporciona algunos métodos simples que te permiten probar fácilmente las invocaciones de lotería de tu aplicación:
// Lottery will always win...Lottery::alwaysWin(); // Lottery will always lose...Lottery::alwaysLose(); // Lottery will win then lose, and finally return to normal behavior...Lottery::fix([true, false]); // Lottery will return to normal behavior...Lottery::determineResultsNormally();