Home

⌘K

WARNING You're browsing the documentation for an old version of Laravel. Consider upgrading your project toLaravel 12.x.

Helpers

Introduction

Laravel includes a variety of global "helper" PHP functions. Many of these functions are used by the framework itself; however, you are free to use them in your own applications if you find them convenient.

Available Methods

Method Listing

Arrays & Objects

`Arr::accessible()`

TheArr::accessible method checks that the given value is array accessible:

 1use Illuminate\Support\Arr;
 2use Illuminate\Support\Collection;
 3 
 4$isAccessible=Arr::accessible(['a'=>1,'b'=>2]);
 5 
 6// true
 7 
 8$isAccessible=Arr::accessible(newCollection);
 9 
10// true
11 
12$isAccessible=Arr::accessible('abc');
13 
14// false
15 
16$isAccessible=Arr::accessible(newstdClass);
17 
18// false
use Illuminate\Support\Arr;use Illuminate\Support\Collection;$isAccessible = Arr::accessible(['a' => 1, 'b' => 2]);// true$isAccessible = Arr::accessible(new Collection);// true$isAccessible = Arr::accessible('abc');// false$isAccessible = Arr::accessible(new stdClass);// false

`Arr::add()`

TheArr::add method adds a given key / value pair to an array if the given key doesn't already exist in the array or is set tonull:

1use Illuminate\Support\Arr;
2 
3$array=Arr::add(['name'=>'Desk'],'price',100);
4 
5// ['name' => 'Desk', 'price' => 100]
6 
7$array=Arr::add(['name'=>'Desk','price'=>null],'price',100);
8 
9// ['name' => 'Desk', 'price' => 100]
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()`

TheArr::collapse method collapses an array of arrays into a single array:

1use Illuminate\Support\Arr;
2 
3$array=Arr::collapse([[1,2,3], [4,5,6], [7,8,9]]);
4 
5// [1, 2, 3, 4, 5, 6, 7, 8, 9]
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()`

TheArr::crossJoin method cross joins the given arrays, returning a Cartesian product with all possible permutations:

 1use Illuminate\Support\Arr;
 2 
 3$matrix=Arr::crossJoin([1,2], ['a','b']);
 4 
 5/*
 6    [
 7        [1, 'a'],
 8        [1, 'b'],
 9        [2, 'a'],
10        [2, 'b'],
11    ]
12*/
13 
14$matrix=Arr::crossJoin([1,2], ['a','b'], ['I','II']);
15 
16/*
17    [
18        [1, 'a', 'I'],
19        [1, 'a', 'II'],
20        [1, 'b', 'I'],
21        [1, 'b', 'II'],
22        [2, 'a', 'I'],
23        [2, 'a', 'II'],
24        [2, 'b', 'I'],
25        [2, 'b', 'II'],
26    ]
27*/
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()`

TheArr::divide method returns two arrays, one containing the keys, and the other containing the values of the given array:

1use Illuminate\Support\Arr;
2 
3[$keys,$values]=Arr::divide(['name'=>'Desk']);
4 
5// $keys: ['name']
6 
7// $values: ['Desk']
use Illuminate\Support\Arr;[$keys, $values] = Arr::divide(['name' => 'Desk']);// $keys: ['name']// $values: ['Desk']

`Arr::dot()`

TheArr::dot method flattens a multi-dimensional array into a single level array that uses "dot" notation to indicate depth:

1use Illuminate\Support\Arr;
2 
3$array= ['products'=> ['desk'=> ['price'=>100]]];
4 
5$flattened=Arr::dot($array);
6 
7// ['products.desk.price' => 100]
use Illuminate\Support\Arr;$array = ['products' => ['desk' => ['price' => 100]]];$flattened = Arr::dot($array);// ['products.desk.price' => 100]

`Arr::except()`

TheArr::except method removes the given key / value pairs from an array:

1use Illuminate\Support\Arr;
2 
3$array= ['name'=>'Desk','price'=>100];
4 
5$filtered=Arr::except($array, ['price']);
6 
7// ['name' => 'Desk']
use Illuminate\Support\Arr;$array = ['name' => 'Desk', 'price' => 100];$filtered = Arr::except($array, ['price']);// ['name' => 'Desk']

`Arr::exists()`

TheArr::exists method checks that the given key exists in the provided array:

 1use Illuminate\Support\Arr;
 2 
 3$array= ['name'=>'John Doe','age'=>17];
 4 
 5$exists=Arr::exists($array,'name');
 6 
 7// true
 8 
 9$exists=Arr::exists($array,'salary');
10 
11// false
use Illuminate\Support\Arr;$array = ['name' => 'John Doe', 'age' => 17];$exists = Arr::exists($array, 'name');// true$exists = Arr::exists($array, 'salary');// false

`Arr::first()`

TheArr::first method returns the first element of an array passing a given truth test:

1use Illuminate\Support\Arr;
2 
3$array= [100,200,300];
4 
5$first=Arr::first($array,function($value,$key) {
6return$value>=150;
7});
8 
9// 200
use Illuminate\Support\Arr;$array = [100, 200, 300];$first = Arr::first($array, function ($value, $key) {    return $value >= 150;});// 200

A default value may also be passed as the third parameter to the method. This value will be returned if no value passes the truth test:

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

`Arr::flatten()`

TheArr::flatten method flattens a multi-dimensional array into a single level array:

1use Illuminate\Support\Arr;
2 
3$array= ['name'=>'Joe','languages'=> ['PHP','Ruby']];
4 
5$flattened=Arr::flatten($array);
6 
7// ['Joe', 'PHP', 'Ruby']
use Illuminate\Support\Arr;$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];$flattened = Arr::flatten($array);// ['Joe', 'PHP', 'Ruby']

`Arr::forget()`

TheArr::forget method removes a given key / value pair from a deeply nested array using "dot" notation:

1use Illuminate\Support\Arr;
2 
3$array= ['products'=> ['desk'=> ['price'=>100]]];
4 
5Arr::forget($array,'products.desk');
6 
7// ['products' => []]
use Illuminate\Support\Arr;$array = ['products' => ['desk' => ['price' => 100]]];Arr::forget($array, 'products.desk');// ['products' => []]

`Arr::get()`

TheArr::get method retrieves a value from a deeply nested array using "dot" notation:

1use Illuminate\Support\Arr;
2 
3$array= ['products'=> ['desk'=> ['price'=>100]]];
4 
5$price=Arr::get($array,'products.desk.price');
6 
7// 100
use Illuminate\Support\Arr;$array = ['products' => ['desk' => ['price' => 100]]];$price = Arr::get($array, 'products.desk.price');// 100

TheArr::get method also accepts a default value, which will be returned if the specific key is not found:

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

`Arr::has()`

TheArr::has method checks whether a given item or items exists in an array using "dot" notation:

 1use Illuminate\Support\Arr;
 2 
 3$array= ['product'=> ['name'=>'Desk','price'=>100]];
 4 
 5$contains=Arr::has($array,'product.name');
 6 
 7// true
 8 
 9$contains=Arr::has($array, ['product.price','product.discount']);
10 
11// false
use Illuminate\Support\Arr;$array = ['product' => ['name' => 'Desk', 'price' => 100]];$contains = Arr::has($array, 'product.name');// true$contains = Arr::has($array, ['product.price', 'product.discount']);// false

`Arr::hasAny()`

TheArr::hasAny method checks whether any item in a given set exists in an array using "dot" notation:

 1use Illuminate\Support\Arr;
 2 
 3$array= ['product'=> ['name'=>'Desk','price'=>100]];
 4 
 5$contains=Arr::hasAny($array,'product.name');
 6 
 7// true
 8 
 9$contains=Arr::hasAny($array, ['product.name','product.discount']);
10 
11// true
12 
13$contains=Arr::hasAny($array, ['category','product.discount']);
14 
15// false
use Illuminate\Support\Arr;$array = ['product' => ['name' => 'Desk', 'price' => 100]];$contains = Arr::hasAny($array, 'product.name');// true$contains = Arr::hasAny($array, ['product.name', 'product.discount']);// true$contains = Arr::hasAny($array, ['category', 'product.discount']);// false

`Arr::isAssoc()`

TheArr::isAssoc returnstrue if the given array is an associative array. An array is considered "associative" if it doesn't have sequential numerical keys beginning with zero:

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

`Arr::last()`

TheArr::last method returns the last element of an array passing a given truth test:

1use Illuminate\Support\Arr;
2 
3$array= [100,200,300,110];
4 
5$last=Arr::last($array,function($value,$key) {
6return$value>=150;
7});
8 
9// 300
use Illuminate\Support\Arr;$array = [100, 200, 300, 110];$last = Arr::last($array, function ($value, $key) {    return $value >= 150;});// 300

A default value may be passed as the third argument to the method. This value will be returned if no value passes the truth test:

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

`Arr::only()`

TheArr::only method returns only the specified key / value pairs from the given array:

1use Illuminate\Support\Arr;
2 
3$array= ['name'=>'Desk','price'=>100,'orders'=>10];
4 
5$slice=Arr::only($array, ['name','price']);
6 
7// ['name' => 'Desk', 'price' => 100]
use Illuminate\Support\Arr;$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];$slice = Arr::only($array, ['name', 'price']);// ['name' => 'Desk', 'price' => 100]

`Arr::pluck()`

TheArr::pluck method retrieves all of the values for a given key from an array:

 1use Illuminate\Support\Arr;
 2 
 3$array= [
 4    ['developer'=> ['id'=>1,'name'=>'Taylor']],
 5    ['developer'=> ['id'=>2,'name'=>'Abigail']],
 6];
 7 
 8$names=Arr::pluck($array,'developer.name');
 9 
10// ['Taylor', 'Abigail']
use Illuminate\Support\Arr;$array = [    ['developer' => ['id' => 1, 'name' => 'Taylor']],    ['developer' => ['id' => 2, 'name' => 'Abigail']],];$names = Arr::pluck($array, 'developer.name');// ['Taylor', 'Abigail']

You may also specify how you wish the resulting list to be keyed:

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

`Arr::prepend()`

TheArr::prepend method will push an item onto the beginning of an array:

1use Illuminate\Support\Arr;
2 
3$array= ['one','two','three','four'];
4 
5$array=Arr::prepend($array,'zero');
6 
7// ['zero', 'one', 'two', 'three', 'four']
use Illuminate\Support\Arr;$array = ['one', 'two', 'three', 'four'];$array = Arr::prepend($array, 'zero');// ['zero', 'one', 'two', 'three', 'four']

If needed, you may specify the key that should be used for the value:

1use Illuminate\Support\Arr;
2 
3$array= ['price'=>100];
4 
5$array=Arr::prepend($array,'Desk','name');
6 
7// ['name' => 'Desk', 'price' => 100]
use Illuminate\Support\Arr;$array = ['price' => 100];$array = Arr::prepend($array, 'Desk', 'name');// ['name' => 'Desk', 'price' => 100]

`Arr::pull()`

TheArr::pull method returns and removes a key / value pair from an array:

1use Illuminate\Support\Arr;
2 
3$array= ['name'=>'Desk','price'=>100];
4 
5$name=Arr::pull($array,'name');
6 
7// $name: Desk
8 
9// $array: ['price' => 100]
use Illuminate\Support\Arr;$array = ['name' => 'Desk', 'price' => 100];$name = Arr::pull($array, 'name');// $name: Desk// $array: ['price' => 100]

A default value may be passed as the third argument to the method. This value will be returned if the key doesn't exist:

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

`Arr::query()`

TheArr::query method converts the array into a query string:

1use Illuminate\Support\Arr;
2 
3$array= ['name'=>'Taylor','order'=> ['column'=>'created_at','direction'=>'desc']];
4 
5Arr::query($array);
6 
7// name=Taylor&order[column]=created_at&order[direction]=desc
use Illuminate\Support\Arr;$array = ['name' => 'Taylor', 'order' => ['column' => 'created_at', 'direction' => 'desc']];Arr::query($array);// name=Taylor&order[column]=created_at&order[direction]=desc

`Arr::random()`

TheArr::random method returns a random value from an array:

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

You may also specify the number of items to return as an optional second argument. Note that providing this argument will return an array, even if only one item is desired:

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

`Arr::set()`

TheArr::set method sets a value within a deeply nested array using "dot" notation:

1use Illuminate\Support\Arr;
2 
3$array= ['products'=> ['desk'=> ['price'=>100]]];
4 
5Arr::set($array,'products.desk.price',200);
6 
7// ['products' => ['desk' => ['price' => 200]]]
use Illuminate\Support\Arr;$array = ['products' => ['desk' => ['price' => 100]]];Arr::set($array, 'products.desk.price', 200);// ['products' => ['desk' => ['price' => 200]]]

`Arr::shuffle()`

TheArr::shuffle method randomly shuffles the items in the array:

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

`Arr::sort()`

TheArr::sort method sorts an array by its values:

1use Illuminate\Support\Arr;
2 
3$array= ['Desk','Table','Chair'];
4 
5$sorted=Arr::sort($array);
6 
7// ['Chair', 'Desk', 'Table']
use Illuminate\Support\Arr;$array = ['Desk', 'Table', 'Chair'];$sorted = Arr::sort($array);// ['Chair', 'Desk', 'Table']

You may also sort the array by the results of the given Closure:

 1use Illuminate\Support\Arr;
 2 
 3$array= [
 4    ['name'=>'Desk'],
 5    ['name'=>'Table'],
 6    ['name'=>'Chair'],
 7];
 8 
 9$sorted=array_values(Arr::sort($array,function($value){
10return$value['name'];
11}));
12 
13/*
14    [
15        ['name' => 'Chair'],
16        ['name' => 'Desk'],
17        ['name' => 'Table'],
18    ]
19*/
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()`

TheArr::sortRecursive method recursively sorts an array using thesort function for numeric sub=arrays andksort for associative subarrays:

 1use Illuminate\Support\Arr;
 2 
 3$array= [
 4    ['Roman','Taylor','Li'],
 5    ['PHP','Ruby','JavaScript'],
 6    ['one'=>1,'two'=>2,'three'=>3],
 7];
 8 
 9$sorted=Arr::sortRecursive($array);
10 
11/*
12    [
13        ['JavaScript', 'PHP', 'Ruby'],
14        ['one' => 1, 'three' => 3, 'two' => 2],
15        ['Li', 'Roman', 'Taylor'],
16    ]
17*/
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()`

TheArr::where method filters an array using the given Closure:

1use Illuminate\Support\Arr;
2 
3$array= [100,'200',300,'400',500];
4 
5$filtered=Arr::where($array,function($value,$key) {
6returnis_string($value);
7});
8 
9// [1 => '200', 3 => '400']
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()`

TheArr::wrap method wraps the given value in an array. If the given value is already an array it will not be changed:

1use Illuminate\Support\Arr;
2 
3$string='Laravel';
4 
5$array=Arr::wrap($string);
6 
7// ['Laravel']
use Illuminate\Support\Arr;$string = 'Laravel';$array = Arr::wrap($string);// ['Laravel']

If the given value is null, an empty array will be returned:

1use Illuminate\Support\Arr;
2 
3$nothing=null;
4 
5$array=Arr::wrap($nothing);
6 
7// []
use Illuminate\Support\Arr;$nothing = null;$array = Arr::wrap($nothing);// []

`data_fill()`

Thedata_fill function sets a missing value within a nested array or object using "dot" notation:

1$data= ['products'=> ['desk'=> ['price'=>100]]];
2 
3data_fill($data,'products.desk.price',200);
4 
5// ['products' => ['desk' => ['price' => 100]]]
6 
7data_fill($data,'products.desk.discount',10);
8 
9// ['products' => ['desk' => ['price' => 100, 'discount' => 10]]]
$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]]]

This function also accepts asterisks as wildcards and will fill the target accordingly:

 1$data= [
 2'products'=> [
 3        ['name'=>'Desk 1','price'=>100],
 4        ['name'=>'Desk 2'],
 5    ],
 6];
 7 
 8data_fill($data,'products.*.price',200);
 9 
10/*
11    [
12        'products' => [
13            ['name' => 'Desk 1', 'price' => 100],
14            ['name' => 'Desk 2', 'price' => 200],
15        ],
16    ]
17*/
$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()`

Thedata_get function retrieves a value from a nested array or object using "dot" notation:

1$data= ['products'=> ['desk'=> ['price'=>100]]];
2 
3$price=data_get($data,'products.desk.price');
4 
5// 100
$data = ['products' => ['desk' => ['price' => 100]]];$price = data_get($data, 'products.desk.price');// 100

Thedata_get function also accepts a default value, which will be returned if the specified key is not found:

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

The function also accepts wildcards using asterisks, which may target any key of the array or object:

1$data= [
2'product-one'=> ['name'=>'Desk 1','price'=>100],
3'product-two'=> ['name'=>'Desk 2','price'=>150],
4];
5 
6data_get($data,'*.name');
7 
8// ['Desk 1', 'Desk 2'];
$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()`

Thedata_set function sets a value within a nested array or object using "dot" notation:

1$data= ['products'=> ['desk'=> ['price'=>100]]];
2 
3data_set($data,'products.desk.price',200);
4 
5// ['products' => ['desk' => ['price' => 200]]]
$data = ['products' => ['desk' => ['price' => 100]]];data_set($data, 'products.desk.price', 200);// ['products' => ['desk' => ['price' => 200]]]

This function also accepts wildcards and will set values on the target accordingly:

 1$data= [
 2'products'=> [
 3        ['name'=>'Desk 1','price'=>100],
 4        ['name'=>'Desk 2','price'=>150],
 5    ],
 6];
 7 
 8data_set($data,'products.*.price',200);
 9 
10/*
11    [
12        'products' => [
13            ['name' => 'Desk 1', 'price' => 200],
14            ['name' => 'Desk 2', 'price' => 200],
15        ],
16    ]
17*/
$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],        ],    ]*/

By default, any existing values are overwritten. If you wish to only set a value if it doesn't exist, you may passfalse as the fourth argument:

1$data= ['products'=> ['desk'=> ['price'=>100]]];
2 
3data_set($data,'products.desk.price',200, false);
4 
5// ['products' => ['desk' => ['price' => 100]]]
$data = ['products' => ['desk' => ['price' => 100]]];data_set($data, 'products.desk.price', 200, false);// ['products' => ['desk' => ['price' => 100]]]

`head()`

Thehead function returns the first element in the given array:

1$array= [100,200,300];
2 
3$first=head($array);
4 
5// 100
$array = [100, 200, 300];$first = head($array);// 100

`last()`

Thelast function returns the last element in the given array:

1$array= [100,200,300];
2 
3$last=last($array);
4 
5// 300
$array = [100, 200, 300];$last = last($array);// 300

Paths

`app_path()`

Theapp_path function returns the fully qualified path to theapp directory. You may also use theapp_path function to generate a fully qualified path to a file relative to the application directory:

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

`base_path()`

Thebase_path function returns the fully qualified path to the project root. You may also use thebase_path function to generate a fully qualified path to a given file relative to the project root directory:

1$path=base_path();
2 
3$path=base_path('vendor/bin');
$path = base_path();$path = base_path('vendor/bin');

`config_path()`

Theconfig_path function returns the fully qualified path to theconfig directory. You may also use theconfig_path function to generate a fully qualified path to a given file within the application's configuration directory:

1$path=config_path();
2 
3$path=config_path('app.php');
$path = config_path();$path = config_path('app.php');

`database_path()`

Thedatabase_path function returns the fully qualified path to thedatabase directory. You may also use thedatabase_path function to generate a fully qualified path to a given file within the database directory:

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

`mix()`

Themix function returns the path to aversioned Mix file:

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

`public_path()`

Thepublic_path function returns the fully qualified path to thepublic directory. You may also use thepublic_path function to generate a fully qualified path to a given file within the public directory:

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

`resource_path()`

Theresource_path function returns the fully qualified path to theresources directory. You may also use theresource_path function to generate a fully qualified path to a given file within the resources directory:

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

`storage_path()`

Thestorage_path function returns the fully qualified path to thestorage directory. You may also use thestorage_path function to generate a fully qualified path to a given file within the storage directory:

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

Strings

`__()`

The__ function translates the given translation string or translation key using yourlocalization files:

1echo__('Welcome to our application');
2 
3echo__('messages.welcome');
echo __('Welcome to our application');echo __('messages.welcome');

If the specified translation string or key does not exist, the__ function will return the given value. So, using the example above, the__ function would returnmessages.welcome if that translation key does not exist.

`class_basename()`

Theclass_basename function returns the class name of the given class with the class's namespace removed:

1$class=class_basename('Foo\Bar\Baz');
2 
3// Baz
$class = class_basename('Foo\Bar\Baz');// Baz

`e()`

Thee function runs PHP'shtmlspecialchars function with thedouble_encode option set totrue by default:

1echoe('<html>foo</html>');
2 
3// &lt;html&gt;foo&lt;/html&gt;
echo e('<html>foo</html>');// &lt;html&gt;foo&lt;/html&gt;

`preg_replace_array()`

Thepreg_replace_array function replaces a given pattern in the string sequentially using an array:

1$string='The event will take place between :start and :end';
2 
3$replaced=preg_replace_array('/:[a-z_]+/',['8:30','9:00'],$string);
4 
5// The event will take place between 8:30 and 9:00
$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()`

TheStr::after method returns everything after the given value in a string. The entire string will be returned if the value does not exist within the string:

1use Illuminate\Support\Str;
2 
3$slice=Str::after('This is my name','This is');
4 
5// ' my name'
use Illuminate\Support\Str;$slice = Str::after('This is my name', 'This is');// ' my name'

`Str::afterLast()`

TheStr::afterLast method returns everything after the last occurrence of the given value in a string. The entire string will be returned if the value does not exist within the string:

1use Illuminate\Support\Str;
2 
3$slice=Str::afterLast('App\Http\Controllers\Controller','\\');
4 
5// 'Controller'
use Illuminate\Support\Str;$slice = Str::afterLast('App\Http\Controllers\Controller', '\\');// 'Controller'

`Str::ascii()`

TheStr::ascii method will attempt to transliterate the string into an ASCII value:

1use Illuminate\Support\Str;
2 
3$slice=Str::ascii('û');
4 
5// 'u'
use Illuminate\Support\Str;$slice = Str::ascii('û');// 'u'

`Str::before()`

TheStr::before method returns everything before the given value in a string:

1use Illuminate\Support\Str;
2 
3$slice=Str::before('This is my name','my name');
4 
5// 'This is '
use Illuminate\Support\Str;$slice = Str::before('This is my name', 'my name');// 'This is '

`Str::beforeLast()`

TheStr::beforeLast method returns everything before the last occurrence of the given value in a string:

1use Illuminate\Support\Str;
2 
3$slice=Str::beforeLast('This is my name','is');
4 
5// 'This '
use Illuminate\Support\Str;$slice = Str::beforeLast('This is my name', 'is');// 'This '

`Str::between()`

TheStr::between method returns the portion of a string between two values:

1use Illuminate\Support\Str;
2 
3$slice=Str::between('This is my name','This','name');
4 
5// ' is my '
use Illuminate\Support\Str;$slice = Str::between('This is my name', 'This', 'name');// ' is my '

`Str::camel()`

TheStr::camel method converts the given string tocamelCase:

1use Illuminate\Support\Str;
2 
3$converted=Str::camel('foo_bar');
4 
5// fooBar
use Illuminate\Support\Str;$converted = Str::camel('foo_bar');// fooBar

`Str::contains()`

TheStr::contains method determines if the given string contains the given value (case sensitive):

1use Illuminate\Support\Str;
2 
3$contains=Str::contains('This is my name','my');
4 
5// true
use Illuminate\Support\Str;$contains = Str::contains('This is my name', 'my');// true

You may also pass an array of values to determine if the given string contains any of the values:

1use Illuminate\Support\Str;
2 
3$contains=Str::contains('This is my name', ['my','foo']);
4 
5// true
use Illuminate\Support\Str;$contains = Str::contains('This is my name', ['my', 'foo']);// true

`Str::containsAll()`

TheStr::containsAll method determines if the given string contains all array values:

1use Illuminate\Support\Str;
2 
3$containsAll=Str::containsAll('This is my name', ['my','name']);
4 
5// true
use Illuminate\Support\Str;$containsAll = Str::containsAll('This is my name', ['my', 'name']);// true

`Str::endsWith()`

TheStr::endsWith method determines if the given string ends with the given value:

1use Illuminate\Support\Str;
2 
3$result=Str::endsWith('This is my name','name');
4 
5// true
use Illuminate\Support\Str;$result = Str::endsWith('This is my name', 'name');// true

You may also pass an array of values to determine if the given string ends with any of the given values:

1use Illuminate\Support\Str;
2 
3$result=Str::endsWith('This is my name', ['name','foo']);
4 
5// true
6 
7$result=Str::endsWith('This is my name', ['this','foo']);
8 
9// false
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()`

TheStr::finish method adds a single instance of the given value to a string if it does not already end with the value:

1use Illuminate\Support\Str;
2 
3$adjusted=Str::finish('this/string','/');
4 
5// this/string/
6 
7$adjusted=Str::finish('this/string/','/');
8 
9// this/string/
use Illuminate\Support\Str;$adjusted = Str::finish('this/string', '/');// this/string/$adjusted = Str::finish('this/string/', '/');// this/string/

`Str::is()`

TheStr::is method determines if a given string matches a given pattern. Asterisks may be used to indicate wildcards:

1use Illuminate\Support\Str;
2 
3$matches=Str::is('foo*','foobar');
4 
5// true
6 
7$matches=Str::is('baz*','foobar');
8 
9// false
use Illuminate\Support\Str;$matches = Str::is('foo*', 'foobar');// true$matches = Str::is('baz*', 'foobar');// false

`Str::isAscii()`

TheStr::isAscii method determines if a given string is 7 bit ASCII:

1use Illuminate\Support\Str;
2 
3$isAscii=Str::isAscii('Taylor');
4 
5// true
6 
7$isAscii=Str::isAscii('ü');
8 
9// false
use Illuminate\Support\Str;$isAscii = Str::isAscii('Taylor');// true$isAscii = Str::isAscii('ü');// false

`Str::isUuid()`

TheStr::isUuid method determines if the given string is a valid UUID:

1use Illuminate\Support\Str;
2 
3$isUuid=Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');
4 
5// true
6 
7$isUuid=Str::isUuid('laravel');
8 
9// false
use Illuminate\Support\Str;$isUuid = Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');// true$isUuid = Str::isUuid('laravel');// false

`Str::kebab()`

TheStr::kebab method converts the given string tokebab-case:

1use Illuminate\Support\Str;
2 
3$converted=Str::kebab('fooBar');
4 
5// foo-bar
use Illuminate\Support\Str;$converted = Str::kebab('fooBar');// foo-bar

`Str::length()`

TheStr::length method returns the length of the given string:

1use Illuminate\Support\Str;
2 
3$length=Str::length('Laravel');
4 
5// 7
use Illuminate\Support\Str;$length = Str::length('Laravel');// 7

`Str::limit()`

TheStr::limit method truncates the given string at the specified length:

1use Illuminate\Support\Str;
2 
3$truncated=Str::limit('The quick brown fox jumps over the lazy dog',20);
4 
5// The quick brown fox...
use Illuminate\Support\Str;$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20);// The quick brown fox...

You may also pass a third argument to change the string that will be appended to the end:

1use Illuminate\Support\Str;
2 
3$truncated=Str::limit('The quick brown fox jumps over the lazy dog',20,' (...)');
4 
5// The quick brown fox (...)
use Illuminate\Support\Str;$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');// The quick brown fox (...)

`Str::lower()`

TheStr::lower method converts the given string to lowercase:

1use Illuminate\Support\Str;
2 
3$converted=Str::lower('LARAVEL');
4 
5// laravel
use Illuminate\Support\Str;$converted = Str::lower('LARAVEL');// laravel

`Str::orderedUuid()`

TheStr::orderedUuid method generates a "timestamp first" UUID that may be efficiently stored in an indexed database column:

1use Illuminate\Support\Str;
2 
3return (string)Str::orderedUuid();
use Illuminate\Support\Str;return (string) Str::orderedUuid();

`Str::padBoth()`

TheStr::padBoth method wraps PHP'sstr_pad function, padding both sides of a string with another:

1use Illuminate\Support\Str;
2 
3$padded=Str::padBoth('James',10,'_');
4 
5// '__James___'
6 
7$padded=Str::padBoth('James',10);
8 
9// '  James   '
use Illuminate\Support\Str;$padded = Str::padBoth('James', 10, '_');// '__James___'$padded = Str::padBoth('James', 10);// '  James   '

`Str::padLeft()`

TheStr::padLeft method wraps PHP'sstr_pad function, padding the left side of a string with another:

1use Illuminate\Support\Str;
2 
3$padded=Str::padLeft('James',10,'-=');
4 
5// '-=-=-James'
6 
7$padded=Str::padLeft('James',10);
8 
9// '     James'
use Illuminate\Support\Str;$padded = Str::padLeft('James', 10, '-=');// '-=-=-James'$padded = Str::padLeft('James', 10);// '     James'

`Str::padRight()`

TheStr::padRight method wraps PHP'sstr_pad function, padding the right side of a string with another:

1use Illuminate\Support\Str;
2 
3$padded=Str::padRight('James',10,'-');
4 
5// 'James-----'
6 
7$padded=Str::padRight('James',10);
8 
9// 'James     '
use Illuminate\Support\Str;$padded = Str::padRight('James', 10, '-');// 'James-----'$padded = Str::padRight('James', 10);// 'James     '

`Str::plural()`

TheStr::plural method converts a single word string to its plural form. This function currently only supports the English language:

1use Illuminate\Support\Str;
2 
3$plural=Str::plural('car');
4 
5// cars
6 
7$plural=Str::plural('child');
8 
9// children
use Illuminate\Support\Str;$plural = Str::plural('car');// cars$plural = Str::plural('child');// children

You may provide an integer as a second argument to the function to retrieve the singular or plural form of the string:

1use Illuminate\Support\Str;
2 
3$plural=Str::plural('child',2);
4 
5// children
6 
7$plural=Str::plural('child',1);
8 
9// child
use Illuminate\Support\Str;$plural = Str::plural('child', 2);// children$plural = Str::plural('child', 1);// child

`Str::random()`

TheStr::random method generates a random string of the specified length. This function uses PHP'srandom_bytes function:

1use Illuminate\Support\Str;
2 
3$random=Str::random(40);
use Illuminate\Support\Str;$random = Str::random(40);

`Str::replaceArray()`

TheStr::replaceArray method replaces a given value in the string sequentially using an array:

1use Illuminate\Support\Str;
2 
3$string='The event will take place between ? and ?';
4 
5$replaced=Str::replaceArray('?', ['8:30','9:00'],$string);
6 
7// The event will take place between 8:30 and 9:00
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()`

TheStr::replaceFirst method replaces the first occurrence of a given value in a string:

1use Illuminate\Support\Str;
2 
3$replaced=Str::replaceFirst('the','a','the quick brown fox jumps over the lazy dog');
4 
5// a quick brown fox jumps over the lazy dog
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()`

TheStr::replaceLast method replaces the last occurrence of a given value in a string:

1use Illuminate\Support\Str;
2 
3$replaced=Str::replaceLast('the','a','the quick brown fox jumps over the lazy dog');
4 
5// the quick brown fox jumps over a lazy dog
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()`

TheStr::singular method converts a string to its singular form. This function currently only supports the English language:

1use Illuminate\Support\Str;
2 
3$singular=Str::singular('cars');
4 
5// car
6 
7$singular=Str::singular('children');
8 
9// child
use Illuminate\Support\Str;$singular = Str::singular('cars');// car$singular = Str::singular('children');// child

`Str::slug()`

TheStr::slug method generates a URL friendly "slug" from the given string:

1use Illuminate\Support\Str;
2 
3$slug=Str::slug('Laravel 5 Framework','-');
4 
5// laravel-5-framework
use Illuminate\Support\Str;$slug = Str::slug('Laravel 5 Framework', '-');// laravel-5-framework

`Str::snake()`

TheStr::snake method converts the given string tosnake_case:

1use Illuminate\Support\Str;
2 
3$converted=Str::snake('fooBar');
4 
5// foo_bar
use Illuminate\Support\Str;$converted = Str::snake('fooBar');// foo_bar

`Str::start()`

TheStr::start method adds a single instance of the given value to a string if it does not already start with the value:

1use Illuminate\Support\Str;
2 
3$adjusted=Str::start('this/string','/');
4 
5// /this/string
6 
7$adjusted=Str::start('/this/string','/');
8 
9// /this/string
use Illuminate\Support\Str;$adjusted = Str::start('this/string', '/');// /this/string$adjusted = Str::start('/this/string', '/');// /this/string

`Str::startsWith()`

TheStr::startsWith method determines if the given string begins with the given value:

1use Illuminate\Support\Str;
2 
3$result=Str::startsWith('This is my name','This');
4 
5// true
use Illuminate\Support\Str;$result = Str::startsWith('This is my name', 'This');// true

`Str::studly()`

TheStr::studly method converts the given string toStudlyCase:

1use Illuminate\Support\Str;
2 
3$converted=Str::studly('foo_bar');
4 
5// FooBar
use Illuminate\Support\Str;$converted = Str::studly('foo_bar');// FooBar

`Str::substr()`

TheStr::substr method returns the portion of string specified by the start and length parameters:

1use Illuminate\Support\Str;
2 
3$converted=Str::substr('The Laravel Framework',4,7);
4 
5// Laravel
use Illuminate\Support\Str;$converted = Str::substr('The Laravel Framework', 4, 7);// Laravel

`Str::title()`

TheStr::title method converts the given string toTitle Case:

1use Illuminate\Support\Str;
2 
3$converted=Str::title('a nice title uses the correct case');
4 
5// A Nice Title Uses The Correct Case
use Illuminate\Support\Str;$converted = Str::title('a nice title uses the correct case');// A Nice Title Uses The Correct Case

`Str::ucfirst()`

TheStr::ucfirst method returns the given string with the first character capitalized:

1use Illuminate\Support\Str;
2 
3$string=Str::ucfirst('foo bar');
4 
5// Foo bar
use Illuminate\Support\Str;$string = Str::ucfirst('foo bar');// Foo bar

`Str::upper()`

TheStr::upper method converts the given string to uppercase:

1use Illuminate\Support\Str;
2 
3$string=Str::upper('laravel');
4 
5// LARAVEL
use Illuminate\Support\Str;$string = Str::upper('laravel');// LARAVEL

`Str::uuid()`

TheStr::uuid method generates a UUID (version 4):

1use Illuminate\Support\Str;
2 
3return (string)Str::uuid();
use Illuminate\Support\Str;return (string) Str::uuid();

`Str::words()`

TheStr::words method limits the number of words in a string:

1use Illuminate\Support\Str;
2 
3returnStr::words('Perfectly balanced, as all things should be.',3,' >>>');
4 
5// Perfectly balanced, as >>>
use Illuminate\Support\Str;return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>');// Perfectly balanced, as >>>

`trans()`

Thetrans function translates the given translation key using yourlocalization files:

1echotrans('messages.welcome');
echo trans('messages.welcome');

If the specified translation key does not exist, thetrans function will return the given key. So, using the example above, thetrans function would returnmessages.welcome if the translation key does not exist.

`trans_choice()`

Thetrans_choice function translates the given translation key with inflection:

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

If the specified translation key does not exist, thetrans_choice function will return the given key. So, using the example above, thetrans_choice function would returnmessages.notifications if the translation key does not exist.

Fluent Strings

Fluent strings provide a more fluent, object-oriented interface for working with string values, allowing you to chain multiple string operations together using a more readable syntax compared to traditional string operations.

`after`

Theafter method returns everything after the given value in a string. The entire string will be returned if the value does not exist within the string:

1use Illuminate\Support\Str;
2 
3$slice=Str::of('This is my name')->after('This is');
4 
5// ' my name'
use Illuminate\Support\Str;$slice = Str::of('This is my name')->after('This is');// ' my name'

`afterLast`

TheafterLast method returns everything after the last occurrence of the given value in a string. The entire string will be returned if the value does not exist within the string:

1use Illuminate\Support\Str;
2 
3$slice=Str::of('App\Http\Controllers\Controller')->afterLast('\\');
4 
5// 'Controller'
use Illuminate\Support\Str;$slice = Str::of('App\Http\Controllers\Controller')->afterLast('\\');// 'Controller'

`append`

Theappend method appends the given values to the string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('Taylor')->append(' Otwell');
4 
5// 'Taylor Otwell'
use Illuminate\Support\Str;$string = Str::of('Taylor')->append(' Otwell');// 'Taylor Otwell'

`ascii`

Theascii method will attempt to transliterate the string into an ASCII value:

1use Illuminate\Support\Str;
2 
3$string=Str::of('ü')->ascii();
4 
5// 'u'
use Illuminate\Support\Str;$string = Str::of('ü')->ascii();// 'u'

`basename`

Thebasename method will return the trailing name component of the given string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('/foo/bar/baz')->basename();
4 
5// 'baz'
use Illuminate\Support\Str;$string = Str::of('/foo/bar/baz')->basename();// 'baz'

If needed, you may provide an "extension" that will be removed from the trailing component:

1use Illuminate\Support\Str;
2 
3$string=Str::of('/foo/bar/baz.jpg')->basename('.jpg');
4 
5// 'baz'
use Illuminate\Support\Str;$string = Str::of('/foo/bar/baz.jpg')->basename('.jpg');// 'baz'

`before`

Thebefore method returns everything before the given value in a string:

1use Illuminate\Support\Str;
2 
3$slice=Str::of('This is my name')->before('my name');
4 
5// 'This is '
use Illuminate\Support\Str;$slice = Str::of('This is my name')->before('my name');// 'This is '

`beforeLast`

ThebeforeLast method returns everything before the last occurrence of the given value in a string:

1use Illuminate\Support\Str;
2 
3$slice=Str::of('This is my name')->beforeLast('is');
4 
5// 'This '
use Illuminate\Support\Str;$slice = Str::of('This is my name')->beforeLast('is');// 'This '

`camel`

Thecamel method converts the given string tocamelCase:

1use Illuminate\Support\Str;
2 
3$converted=Str::of('foo_bar')->camel();
4 
5// fooBar
use Illuminate\Support\Str;$converted = Str::of('foo_bar')->camel();// fooBar

`contains`

Thecontains method determines if the given string contains the given value (case sensitive):

1use Illuminate\Support\Str;
2 
3$contains=Str::of('This is my name')->contains('my');
4 
5// true
use Illuminate\Support\Str;$contains = Str::of('This is my name')->contains('my');// true

You may also pass an array of values to determine if the given string contains any of the values:

1use Illuminate\Support\Str;
2 
3$contains=Str::of('This is my name')->contains(['my','foo']);
4 
5// true
use Illuminate\Support\Str;$contains = Str::of('This is my name')->contains(['my', 'foo']);// true

`containsAll`

ThecontainsAll method determines if the given string contains all array values:

1use Illuminate\Support\Str;
2 
3$containsAll=Str::of('This is my name')->containsAll(['my','name']);
4 
5// true
use Illuminate\Support\Str;$containsAll = Str::of('This is my name')->containsAll(['my', 'name']);// true

`dirname`

Thedirname method returns the parent directory portion of the given string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('/foo/bar/baz')->dirname();
4 
5// '/foo/bar'
use Illuminate\Support\Str;$string = Str::of('/foo/bar/baz')->dirname();// '/foo/bar'

Optionally, You may specify how many directory levels you wish to trim from the string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('/foo/bar/baz')->dirname(2);
4 
5// '/foo'
use Illuminate\Support\Str;$string = Str::of('/foo/bar/baz')->dirname(2);// '/foo'

`endsWith`

TheendsWith method determines if the given string ends with the given value:

1use Illuminate\Support\Str;
2 
3$result=Str::of('This is my name')->endsWith('name');
4 
5// true
use Illuminate\Support\Str;$result = Str::of('This is my name')->endsWith('name');// true

You may also pass an array of values to determine if the given string ends with any of the given values:

1use Illuminate\Support\Str;
2 
3$result=Str::of('This is my name')->endsWith(['name','foo']);
4 
5// true
6 
7$result=Str::of('This is my name')->endsWith(['this','foo']);
8 
9// false
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']);// false

`exactly`

Theexactly method determines if the given string is an exact match with another string:

1use Illuminate\Support\Str;
2 
3$result=Str::of('Laravel')->exactly('Laravel');
4 
5// true
use Illuminate\Support\Str;$result = Str::of('Laravel')->exactly('Laravel');// true

`explode`

Theexplode method splits the string by the given delimiter and returns a collection containing each section of the split string:

1use Illuminate\Support\Str;
2 
3$collection=Str::of('foo bar baz')->explode('');
4 
5// collect(['foo', 'bar', 'baz'])
use Illuminate\Support\Str;$collection = Str::of('foo bar baz')->explode(' ');// collect(['foo', 'bar', 'baz'])

`finish`

Thefinish method adds a single instance of the given value to a string if it does not already end with the value:

1use Illuminate\Support\Str;
2 
3$adjusted=Str::of('this/string')->finish('/');
4 
5// this/string/
6 
7$adjusted=Str::of('this/string/')->finish('/');
8 
9// this/string/
use Illuminate\Support\Str;$adjusted = Str::of('this/string')->finish('/');// this/string/$adjusted = Str::of('this/string/')->finish('/');// this/string/

`is`

Theis method determines if a given string matches a given pattern. Asterisks may be used to indicate wildcards:

1use Illuminate\Support\Str;
2 
3$matches=Str::of('foobar')->is('foo*');
4 
5// true
6 
7$matches=Str::of('foobar')->is('baz*');
8 
9// false
use Illuminate\Support\Str;$matches = Str::of('foobar')->is('foo*');// true$matches = Str::of('foobar')->is('baz*');// false

`isAscii`

TheisAscii method determines if a given string is an ASCII string:

1use Illuminate\Support\Str;
2 
3$result=Str::of('Taylor')->isAscii();
4 
5// true
6 
7$result=Str::of('ü')->isAscii();
8 
9// false
use Illuminate\Support\Str;$result = Str::of('Taylor')->isAscii();// true$result = Str::of('ü')->isAscii();// false

`isEmpty`

TheisEmpty method determines if the given string is empty:

1use Illuminate\Support\Str;
2 
3$result=Str::of('')->trim()->isEmpty();
4 
5// true
6 
7$result=Str::of('Laravel')->trim()->isEmpty();
8 
9// false
use Illuminate\Support\Str;$result = Str::of('  ')->trim()->isEmpty();// true$result = Str::of('Laravel')->trim()->isEmpty();// false

`isNotEmpty`

TheisNotEmpty method determines if the given string is not empty:

1use Illuminate\Support\Str;
2 
3$result=Str::of('')->trim()->isNotEmpty();
4 
5// false
6 
7$result=Str::of('Laravel')->trim()->isNotEmpty();
8 
9// true
use Illuminate\Support\Str;$result = Str::of('  ')->trim()->isNotEmpty();// false$result = Str::of('Laravel')->trim()->isNotEmpty();// true

`kebab`

Thekebab method converts the given string tokebab-case:

1use Illuminate\Support\Str;
2 
3$converted=Str::of('fooBar')->kebab();
4 
5// foo-bar
use Illuminate\Support\Str;$converted = Str::of('fooBar')->kebab();// foo-bar

`length`

Thelength method returns the length of the given string:

1use Illuminate\Support\Str;
2 
3$length=Str::of('Laravel')->length();
4 
5// 7
use Illuminate\Support\Str;$length = Str::of('Laravel')->length();// 7

`limit`

Thelimit method truncates the given string at the specified length:

1use Illuminate\Support\Str;
2 
3$truncated=Str::of('The quick brown fox jumps over the lazy dog')->limit(20);
4 
5// The quick brown fox...
use Illuminate\Support\Str;$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20);// The quick brown fox...

You may also pass a second argument to change the string that will be appended to the end:

1use Illuminate\Support\Str;
2 
3$truncated=Str::of('The quick brown fox jumps over the lazy dog')->limit(20,' (...)');
4 
5// The quick brown fox (...)
use Illuminate\Support\Str;$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)');// The quick brown fox (...)

`lower`

Thelower method converts the given string to lowercase:

1use Illuminate\Support\Str;
2 
3$result=Str::of('LARAVEL')->lower();
4 
5// 'laravel'
use Illuminate\Support\Str;$result = Str::of('LARAVEL')->lower();// 'laravel'

`ltrim`

Theltrim method left trims the given string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('  Laravel')->ltrim();
4 
5// 'Laravel  '
6 
7$string=Str::of('/Laravel/')->ltrim('/');
8 
9// 'Laravel/'
use Illuminate\Support\Str;$string = Str::of('  Laravel  ')->ltrim();// 'Laravel  '$string = Str::of('/Laravel/')->ltrim('/');// 'Laravel/'

`match`

Thematch method will return the portion of a string that matches a given regular expression pattern:

1use Illuminate\Support\Str;
2 
3$result=Str::of('foo bar')->match('/bar/');
4 
5// 'bar'
6 
7$result=Str::of('foo bar')->match('/foo (.*)/');
8 
9// 'bar'
use Illuminate\Support\Str;$result = Str::of('foo bar')->match('/bar/');// 'bar'$result = Str::of('foo bar')->match('/foo (.*)/');// 'bar'

`matchAll`

ThematchAll method will return a collection containing the portions of a string that match a given regular expression pattern:

1use Illuminate\Support\Str;
2 
3$result=Str::of('bar foo bar')->matchAll('/bar/');
4 
5// collect(['bar', 'bar'])
use Illuminate\Support\Str;$result = Str::of('bar foo bar')->matchAll('/bar/');// collect(['bar', 'bar'])

If you specify a matching group within the expression, Laravel will return a collection of that group's matches:

1use Illuminate\Support\Str;
2 
3$result=Str::of('bar fun bar fly')->matchAll('/f(\w*)/');
4 
5// collect(['un', 'ly']);
use Illuminate\Support\Str;$result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/');// collect(['un', 'ly']);

If no matches are found, an empty collection will be returned.

`padBoth`

ThepadBoth method wraps PHP'sstr_pad function, padding both sides of a string with another:

1use Illuminate\Support\Str;
2 
3$padded=Str::of('James')->padBoth(10,'_');
4 
5// '__James___'
6 
7$padded=Str::of('James')->padBoth(10);
8 
9// '  James   '
use Illuminate\Support\Str;$padded = Str::of('James')->padBoth(10, '_');// '__James___'$padded = Str::of('James')->padBoth(10);// '  James   '

`padLeft`

ThepadLeft method wraps PHP'sstr_pad function, padding the left side of a string with another:

1use Illuminate\Support\Str;
2 
3$padded=Str::of('James')->padLeft(10,'-=');
4 
5// '-=-=-James'
6 
7$padded=Str::of('James')->padLeft(10);
8 
9// '     James'
use Illuminate\Support\Str;$padded = Str::of('James')->padLeft(10, '-=');// '-=-=-James'$padded = Str::of('James')->padLeft(10);// '     James'

`padRight`

ThepadRight method wraps PHP'sstr_pad function, padding the right side of a string with another:

1use Illuminate\Support\Str;
2 
3$padded=Str::of('James')->padRight(10,'-');
4 
5// 'James-----'
6 
7$padded=Str::of('James')->padRight(10);
8 
9// 'James     '
use Illuminate\Support\Str;$padded = Str::of('James')->padRight(10, '-');// 'James-----'$padded = Str::of('James')->padRight(10);// 'James     '

`plural`

Theplural method converts a single word string to its plural form. This function currently only supports the English language:

1use Illuminate\Support\Str;
2 
3$plural=Str::of('car')->plural();
4 
5// cars
6 
7$plural=Str::of('child')->plural();
8 
9// children
use Illuminate\Support\Str;$plural = Str::of('car')->plural();// cars$plural = Str::of('child')->plural();// children

You may provide an integer as a second argument to the function to retrieve the singular or plural form of the string:

1use Illuminate\Support\Str;
2 
3$plural=Str::of('child')->plural(2);
4 
5// children
6 
7$plural=Str::of('child')->plural(1);
8 
9// child
use Illuminate\Support\Str;$plural = Str::of('child')->plural(2);// children$plural = Str::of('child')->plural(1);// child

`prepend`

Theprepend method prepends the given values onto the string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('Framework')->prepend('Laravel');
4 
5// Laravel Framework
use Illuminate\Support\Str;$string = Str::of('Framework')->prepend('Laravel ');// Laravel Framework

`replace`

Thereplace method replaces a given string within the string:

1use Illuminate\Support\Str;
2 
3$replaced=Str::of('Laravel 6.x')->replace('6.x','7.x');
4 
5// Laravel 7.x
use Illuminate\Support\Str;$replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x');// Laravel 7.x

`replaceArray`

ThereplaceArray method replaces a given value in the string sequentially using an array:

1use Illuminate\Support\Str;
2 
3$string='The event will take place between ? and ?';
4 
5$replaced=Str::of($string)->replaceArray('?', ['8:30','9:00']);
6 
7// The event will take place between 8:30 and 9:00
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:00

`replaceFirst`

ThereplaceFirst method replaces the first occurrence of a given value in a string:

1use Illuminate\Support\Str;
2 
3$replaced=Str::of('the quick brown fox jumps over the lazy dog')->replaceFirst('the','a');
4 
5// a quick brown fox jumps over the lazy dog
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 dog

`replaceLast`

ThereplaceLast method replaces the last occurrence of a given value in a string:

1use Illuminate\Support\Str;
2 
3$replaced=Str::of('the quick brown fox jumps over the lazy dog')->replaceLast('the','a');
4 
5// the quick brown fox jumps over a lazy dog
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 dog

`replaceMatches`

ThereplaceMatches method replaces all portions of a string matching a given pattern with the given replacement string:

1use Illuminate\Support\Str;
2 
3$replaced=Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/','')
4 
5// '15015551000'
use Illuminate\Support\Str;$replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '')// '15015551000'

ThereplaceMatches method also accepts a Closure that will be invoked with each portion of the string matching the given party, allowing you to perform the replacement logic within the Closure and return the replaced value:

1use Illuminate\Support\Str;
2 
3$replaced=Str::of('123')->replaceMatches('/\d/',function($match) {
4return'['.$match[0].']';
5});
6 
7// '[1][2][3]'
use Illuminate\Support\Str;$replaced = Str::of('123')->replaceMatches('/\d/', function ($match) {    return '['.$match[0].']';});// '[1][2][3]'

`rtrim`

Thertrim method right trims the given string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('  Laravel')->rtrim();
4 
5// '  Laravel'
6 
7$string=Str::of('/Laravel/')->rtrim('/');
8 
9// '/Laravel'
use Illuminate\Support\Str;$string = Str::of('  Laravel  ')->rtrim();// '  Laravel'$string = Str::of('/Laravel/')->rtrim('/');// '/Laravel'

`singular`

Thesingular method converts a string to its singular form. This function currently only supports the English language:

1use Illuminate\Support\Str;
2 
3$singular=Str::of('cars')->singular();
4 
5// car
6 
7$singular=Str::of('children')->singular();
8 
9// child
use Illuminate\Support\Str;$singular = Str::of('cars')->singular();// car$singular = Str::of('children')->singular();// child

`slug`

Theslug method generates a URL friendly "slug" from the given string:

1use Illuminate\Support\Str;
2 
3$slug=Str::of('Laravel Framework')->slug('-');
4 
5// laravel-framework
use Illuminate\Support\Str;$slug = Str::of('Laravel Framework')->slug('-');// laravel-framework

`snake`

Thesnake method converts the given string tosnake_case:

1use Illuminate\Support\Str;
2 
3$converted=Str::of('fooBar')->snake();
4 
5// foo_bar
use Illuminate\Support\Str;$converted = Str::of('fooBar')->snake();// foo_bar

`split`

Thesplit method splits a string into a collection using a regular expression:

1use Illuminate\Support\Str;
2 
3$segments=Str::of('one, two, three')->split('/[\s,]+/');
4 
5// collect(["one", "two", "three"])
use Illuminate\Support\Str;$segments = Str::of('one, two, three')->split('/[\s,]+/');// collect(["one", "two", "three"])

`start`

Thestart method adds a single instance of the given value to a string if it does not already start with the value:

1use Illuminate\Support\Str;
2 
3$adjusted=Str::of('this/string')->start('/');
4 
5// /this/string
6 
7$adjusted=Str::of('/this/string')->start('/');
8 
9// /this/string
use Illuminate\Support\Str;$adjusted = Str::of('this/string')->start('/');// /this/string$adjusted = Str::of('/this/string')->start('/');// /this/string

`startsWith`

ThestartsWith method determines if the given string begins with the given value:

1use Illuminate\Support\Str;
2 
3$result=Str::of('This is my name')->startsWith('This');
4 
5// true
use Illuminate\Support\Str;$result = Str::of('This is my name')->startsWith('This');// true

`studly`

Thestudly method converts the given string toStudlyCase:

1use Illuminate\Support\Str;
2 
3$converted=Str::of('foo_bar')->studly();
4 
5// FooBar
use Illuminate\Support\Str;$converted = Str::of('foo_bar')->studly();// FooBar

`substr`

Thesubstr method returns the portion of the string specified by the given start and length parameters:

1use Illuminate\Support\Str;
2 
3$string=Str::of('Laravel Framework')->substr(8);
4 
5// Framework
6 
7$string=Str::of('Laravel Framework')->substr(8,5);
8 
9// Frame
use Illuminate\Support\Str;$string = Str::of('Laravel Framework')->substr(8);// Framework$string = Str::of('Laravel Framework')->substr(8, 5);// Frame

`title`

Thetitle method converts the given string toTitle Case:

1use Illuminate\Support\Str;
2 
3$converted=Str::of('a nice title uses the correct case')->title();
4 
5// A Nice Title Uses The Correct Case
use Illuminate\Support\Str;$converted = Str::of('a nice title uses the correct case')->title();// A Nice Title Uses The Correct Case

`trim`

Thetrim method trims the given string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('  Laravel')->trim();
4 
5// 'Laravel'
6 
7$string=Str::of('/Laravel/')->trim('/');
8 
9// 'Laravel'
use Illuminate\Support\Str;$string = Str::of('  Laravel  ')->trim();// 'Laravel'$string = Str::of('/Laravel/')->trim('/');// 'Laravel'

`ucfirst`

Theucfirst method returns the given string with the first character capitalized:

1use Illuminate\Support\Str;
2 
3$string=Str::of('foo bar')->ucfirst();
4 
5// Foo bar
use Illuminate\Support\Str;$string = Str::of('foo bar')->ucfirst();// Foo bar

`upper`

Theupper method converts the given string to uppercase:

1use Illuminate\Support\Str;
2 
3$adjusted=Str::of('laravel')->upper();
4 
5// LARAVEL
use Illuminate\Support\Str;$adjusted = Str::of('laravel')->upper();// LARAVEL

`when`

Thewhen method invokes the given Closure if a given condition is true. The Closure will receive the fluent string instance:

1use Illuminate\Support\Str;
2 
3$string=Str::of('Taylor')
4->when(true,function($string) {
5return$string->append(' Otwell');
6                });
7 
8// 'Taylor Otwell'
use Illuminate\Support\Str;$string = Str::of('Taylor')                ->when(true, function ($string) {                    return $string->append(' Otwell');                });// 'Taylor Otwell'

If necessary, you may pass another Closure as the third parameter to thewhen method. This Closure will execute if the condition parameter evaluates tofalse.

`whenEmpty`

ThewhenEmpty method invokes the given Closure if the string is empty. If the Closure returns a value, that value will also be returned by thewhenEmpty method. If the Closure does not return a value, the fluent string instance will be returned:

1use Illuminate\Support\Str;
2 
3$string=Str::of('')->whenEmpty(function($string) {
4return$string->trim()->prepend('Laravel');
5});
6 
7// 'Laravel'
use Illuminate\Support\Str;$string = Str::of('  ')->whenEmpty(function ($string) {    return $string->trim()->prepend('Laravel');});// 'Laravel'

`words`

Thewords method limits the number of words in a string:

1use Illuminate\Support\Str;
2 
3$string=Str::of('Perfectly balanced, as all things should be.')->words(3,' >>>');
4 
5// Perfectly balanced, as >>>
use Illuminate\Support\Str;$string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>');// Perfectly balanced, as >>>

URLs

`action()`

Theaction function generates a URL for the given controller action. You do not need to pass the full namespace of the controller. Instead, pass the controller class name relative to theApp\Http\Controllers namespace:

1$url=action('HomeController@index');
2 
3$url=action([HomeController::class,'index']);
$url = action('HomeController@index');$url = action([HomeController::class, 'index']);

If the method accepts route parameters, you may pass them as the second argument to the method:

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

`asset()`

Theasset function generates a URL for an asset using the current scheme of the request (HTTP or HTTPS):

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

You can configure the asset URL host by setting theASSET_URL variable in your.env file. This can be useful if you host your assets on an external service like Amazon S3:

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

`route()`

Theroute function generates a URL for the given named route:

1$url=route('routeName');
$url = route('routeName');

If the route accepts parameters, you may pass them as the second argument to the method:

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

By default, theroute function generates an absolute URL. If you wish to generate a relative URL, you may passfalse as the third argument:

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

`secure_asset()`

Thesecure_asset function generates a URL for an asset using HTTPS:

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

`secure_url()`

Thesecure_url function generates a fully qualified HTTPS URL to the given path:

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

`url()`

Theurl function generates a fully qualified URL to the given path:

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

If no path is provided, aIlluminate\Routing\UrlGenerator instance is returned:

1$current=url()->current();
2 
3$full=url()->full();
4 
5$previous=url()->previous();
$current = url()->current();$full = url()->full();$previous = url()->previous();

Miscellaneous

`abort()`

Theabort function throwsan HTTP exception which will be rendered by theexception handler:

1abort(403);
abort(403);

You may also provide the exception's response text and custom response headers:

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

`abort_if()`

Theabort_if function throws an HTTP exception if a given boolean expression evaluates totrue:

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

Like theabort method, you may also provide the exception's response text as the third argument and an array of custom response headers as the fourth argument.

`abort_unless()`

Theabort_unless function throws an HTTP exception if a given boolean expression evaluates tofalse:

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

Like theabort method, you may also provide the exception's response text as the third argument and an array of custom response headers as the fourth argument.

`app()`

Theapp function returns theservice container instance:

1$container=app();
$container = app();

You may pass a class or interface name to resolve it from the container:

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

`auth()`

Theauth function returns anauthenticator instance. You may use it instead of theAuth facade for convenience:

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

If needed, you may specify which guard instance you would like to access:

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

`back()`

Theback function generates aredirect HTTP response to the user's previous location:

1returnback($status=302,$headers=[],$fallback= false);
2 
3returnback();
return back($status = 302, $headers = [], $fallback = false);return back();

`bcrypt()`

Thebcrypt functionhashes the given value using Bcrypt. You may use it as an alternative to theHash facade:

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

`blank()`

Theblank function returns whether the given value is "blank":

 1blank('');
 2blank('');
 3blank(null);
 4blank(collect());
 5 
 6// true
 7 
 8blank(0);
 9blank(true);
10blank(false);
11 
12// false
blank('');blank('   ');blank(null);blank(collect());// trueblank(0);blank(true);blank(false);// false

For the inverse ofblank, see thefilled method.

`broadcast()`

Thebroadcast functionbroadcasts the givenevent to its listeners:

1broadcast(newUserRegistered($user));
broadcast(new UserRegistered($user));

`cache()`

Thecache function may be used to get values from thecache. If the given key does not exist in the cache, an optional default value will be returned:

1$value=cache('key');
2 
3$value=cache('key','default');
$value = cache('key');$value = cache('key', 'default');

You may add items to the cache by passing an array of key / value pairs to the function. You should also pass the number of seconds or duration the cached value should be considered valid:

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

`class_uses_recursive()`

Theclass_uses_recursive function returns all traits used by a class, including traits used by all of its parent classes:

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

`collect()`

Thecollect function creates acollection instance from the given value:

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

`config()`

Theconfig function gets the value of aconfiguration variable. The configuration values may be accessed using "dot" syntax, which includes the name of the file and the option you wish to access. A default value may be specified and is returned if the configuration option does not exist:

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

You may set configuration variables at runtime by passing an array of key / value pairs:

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

`cookie()`

Thecookie function creates a newcookie instance:

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

`csrf_field()`

Thecsrf_field function generates an HTMLhidden input field containing the value of the CSRF token. For example, usingBlade syntax:

1{{csrf_field() }}
{{ csrf_field() }}

`csrf_token()`

Thecsrf_token function retrieves the value of the current CSRF token:

1$token=csrf_token();
$token = csrf_token();

`dd()`

Thedd function dumps the given variables and ends execution of the script:

1dd($value);
2 
3dd($value1,$value2,$value3,...);
dd($value);dd($value1, $value2, $value3, ...);

If you do not want to halt the execution of your script, use thedump function instead.

`dispatch()`

Thedispatch function pushes the givenjob onto the Laraveljob queue:

1dispatch(new App\Jobs\SendEmails);
dispatch(new App\Jobs\SendEmails);

`dispatch_now()`

Thedispatch_now function runs the givenjob immediately and returns the value from itshandle method:

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

`dump()`

Thedump function dumps the given variables:

1dump($value);
2 
3dump($value1,$value2,$value3,...);
dump($value);dump($value1, $value2, $value3, ...);

If you want to stop executing the script after dumping the variables, use thedd function instead.

`env()`

Theenv function retrieves the value of anenvironment variable or returns a default value:

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

If you execute theconfig:cache command during your deployment process, you should be sure that you are only calling theenv function from within your configuration files. Once the configuration has been cached, the.env file will not be loaded and all calls to theenv function will returnnull.

`event()`

Theevent function dispatches the givenevent to its listeners:

1event(newUserRegistered($user));
event(new UserRegistered($user));

`factory()`

Thefactory function creates a model factory builder for a given class, name, and amount. It can be used whiletesting orseeding:

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

`filled()`

Thefilled function returns whether the given value is not "blank":

 1filled(0);
 2filled(true);
 3filled(false);
 4 
 5// true
 6 
 7filled('');
 8filled('');
 9filled(null);
10filled(collect());
11 
12// false
filled(0);filled(true);filled(false);// truefilled('');filled('   ');filled(null);filled(collect());// false

For the inverse offilled, see theblank method.

`info()`

Theinfo function will write information to thelog:

1info('Some helpful information!');
info('Some helpful information!');

An array of contextual data may also be passed to the function:

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

`logger()`

Thelogger function can be used to write adebug level message to thelog:

1logger('Debug message');
logger('Debug message');

An array of contextual data may also be passed to the function:

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

Alogger instance will be returned if no value is passed to the function:

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

`method_field()`

Themethod_field function generates an HTMLhidden input field containing the spoofed value of the form's HTTP verb. For example, usingBlade syntax:

1<formmethod="POST">
2    {{method_field('DELETE') }}
3</form>
<form method="POST">    {{ method_field('DELETE') }}</form>

`now()`

Thenow function creates a newIlluminate\Support\Carbon instance for the current time:

1$now=now();
$now = now();

`old()`

Theold functionretrieves anold input value flashed into the session:

1$value=old('value');
2 
3$value=old('value','default');
$value = old('value');$value = old('value', 'default');

`optional()`

Theoptional function accepts any argument and allows you to access properties or call methods on that object. If the given object isnull, properties and methods will returnnull instead of causing an error:

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

Theoptional function also accepts a Closure as its second argument. The Closure will be invoked if the value provided as the first argument is not null:

1returnoptional(User::find($id),function($user){
2returnnewDummyUser;
3});
return optional(User::find($id), function ($user) {    return new DummyUser;});

`policy()`

Thepolicy method retrieves apolicy instance for a given class:

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

`redirect()`

Theredirect function returns aredirect HTTP response, or returns the redirector instance if called with no arguments:

1returnredirect($to= null,$status=302,$headers=[],$secure= null);
2 
3returnredirect('/home');
4 
5returnredirect()->route('route.name');
return redirect($to = null, $status = 302, $headers = [], $secure = null);return redirect('/home');return redirect()->route('route.name');

`report()`

Thereport function will report an exception using yourexception handler'sreport method:

1report($e);
report($e);

`request()`

Therequest function returns the currentrequest instance or obtains an input item:

1$request=request();
2 
3$value=request('key',$default);
$request = request();$value = request('key', $default);

`rescue()`

Therescue function executes the given Closure and catches any exceptions that occur during its execution. All exceptions that are caught will be sent to yourexception handler'sreport method; however, the request will continue processing:

1returnrescue(function(){
2return$this->method();
3});
return rescue(function () {    return $this->method();});

You may also pass a second argument to therescue function. This argument will be the "default" value that should be returned if an exception occurs while executing the Closure:

1returnrescue(function(){
2return$this->method();
3}, false);
4 
5returnrescue(function(){
6return$this->method();
7},function(){
8return$this->failure();
9});
return rescue(function () {    return $this->method();}, false);return rescue(function () {    return $this->method();}, function () {    return $this->failure();});

`resolve()`

Theresolve function resolves a given class or interface name to its instance using theservice container:

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

`response()`

Theresponse function creates aresponse instance or obtains an instance of the response factory:

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

`retry()`

Theretry function attempts to execute the given callback until the given maximum attempt threshold is met. If the callback does not throw an exception, its return value will be returned. If the callback throws an exception, it will automatically be retried. If the maximum attempt count is exceeded, the exception will be thrown:

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

`session()`

Thesession function may be used to get or setsession values:

1$value=session('key');
$value = session('key');

You may set values by passing an array of key / value pairs to the function:

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

The session store will be returned if no value is passed to the function:

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

`tap()`

Thetap function accepts two arguments: an arbitrary$value and a Closure. The$value will be passed to the Closure and then be returned by thetap function. The return value of the Closure is irrelevant:

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

If no Closure is passed to thetap function, you may call any method on the given$value. The return value of the method you call will always be$value, regardless of what the method actually returns in its definition. For example, the Eloquentupdate method typically returns an integer. However, we can force the method to return the model itself by chaining theupdate method call through thetap function:

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

To add atap method to a class, you may add theIlluminate\Support\Traits\Tappable trait to the class. Thetap method of this trait accepts a Closure as its only argument. The object instance itself will be passed to the Closure and then be returned by thetap method:

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

`throw_if()`

Thethrow_if function throws the given exception if a given boolean expression evaluates totrue:

1throw_if(!Auth::user()->isAdmin(),AuthorizationException::class);
2 
3throw_if(
4!Auth::user()->isAdmin(),
5AuthorizationException::class,
6'You are not allowed to access this page'
7);
throw_if(! Auth::user()->isAdmin(), AuthorizationException::class);throw_if(    ! Auth::user()->isAdmin(),    AuthorizationException::class,    'You are not allowed to access this page');

`throw_unless()`

Thethrow_unless function throws the given exception if a given boolean expression evaluates tofalse:

1throw_unless(Auth::user()->isAdmin(),AuthorizationException::class);
2 
3throw_unless(
4Auth::user()->isAdmin(),
5AuthorizationException::class,
6'You are not allowed to access this page'
7);
throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);throw_unless(    Auth::user()->isAdmin(),    AuthorizationException::class,    'You are not allowed to access this page');

`today()`

Thetoday function creates a newIlluminate\Support\Carbon instance for the current date:

1$today=today();
$today = today();

`trait_uses_recursive()`

Thetrait_uses_recursive function returns all traits used by a trait:

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

`transform()`

Thetransform function executes aClosure on a given value if the value is notblank and returns the result of theClosure:

1$callback=function($value) {
2return$value*2;
3};
4 
5$result=transform(5,$callback);
6 
7// 10
$callback = function ($value) {    return $value * 2;};$result = transform(5, $callback);// 10

A default value orClosure may also be passed as the third parameter to the method. This value will be returned if the given value is blank:

1$result=transform(null,$callback,'The value is blank');
2 
3// The value is blank
$result = transform(null, $callback, 'The value is blank');// The value is blank

`validator()`

Thevalidator function creates a newvalidator instance with the given arguments. You may use it instead of theValidator facade for convenience:

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

`value()`

Thevalue function returns the value it is given. However, if you pass aClosure to the function, theClosure will be executed then its result will be returned:

1$result=value(true);
2 
3// true
4 
5$result=value(function(){
6return false;
7});
8 
9// false
$result = value(true);// true$result = value(function () {    return false;});// false

`view()`

Theview function retrieves aview instance:

1returnview('auth.login');
return view('auth.login');

`with()`

Thewith function returns the value it is given. If aClosure is passed as the second argument to the function, theClosure will be executed and its result will be returned:

 1$callback=function($value) {
 2return (is_numeric($value))?$value*2:0;
 3};
 4 
 5$result=with(5,$callback);
 6 
 7// 10
 8 
 9$result=with(null,$callback);
10 
11// 0
12 
13$result=with(5, null);
14 
15// 5
$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

Movatterモバイル変換

Prologue

Getting Started

Architecture Concepts

The Basics

Frontend

Security

Digging Deeper

Database

Eloquent ORM