辅助函数
简介
Laravel 内置了多种全局「辅助」PHP 函数。框架自身在很多地方用到了这些函数，你也可以在自己的应用里随时调用。
可用方法
数组与对象
数字
路径
| app_path() | base_path() | config_path() |
| database_path() | lang_path() | public_path() |
| resource_path() | storage_path() |
URL
| action() | asset() | route() |
| secure_asset() | secure_url() | to_action() |
| to_route() | uri() | url() |
杂项
数组与对象
Arr::accessible()
Arr::accessible 方法判断给定值是否可数组访问：
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()
Arr::add 方法在给定的键不存在或为 null 时，向数组添加一个键值对：
use Illuminate\Support\Arr;
$array = Arr::add(['name' => 'Desk'], 'price', 100);
// ['name' => 'Desk', 'price' => 100]
$array = Arr::add(['name' => 'Desk', 'price' => null], 'price', 100);
// ['name' => 'Desk', 'price' => 100]
Arr::array()
Arr::array 方法用「点」记法从深层嵌套数组中取值（和 Arr::get() 一样），但如果取到的值不是 array，会抛出 InvalidArgumentException 异常：
use Illuminate\Support\Arr;
$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];
$value = Arr::array($array, 'languages');
// ['PHP', 'Ruby']
$value = Arr::array($array, 'name');
// 抛出 InvalidArgumentException
Arr::boolean()
Arr::boolean 方法用「点」记法从深层嵌套数组中取值（和 Arr::get() 一样），但如果取到的值不是 boolean，会抛出 InvalidArgumentException 异常：
use Illuminate\Support\Arr;
$array = ['name' => 'Joe', 'available' => true];
$value = Arr::boolean($array, 'available');
// true
$value = Arr::boolean($array, 'name');
// 抛出 InvalidArgumentException
Arr::collapse()
Arr::collapse 方法将多个数组合并成一个数组：
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()
Arr::crossJoin 方法对给定数组做交叉连接，返回所有可能排列的笛卡尔积：
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()
Arr::divide 方法返回两个数组：一个包含原数组的键，另一个包含原数组的值：
use Illuminate\Support\Arr;
[$keys, $values] = Arr::divide(['name' => 'Desk']);
// $keys: ['name']
// $values: ['Desk']
Arr::dot()
Arr::dot 方法将多维数组拍平为单层数组，用「点」记法表示层级深度：
use Illuminate\Support\Arr;
$array = ['products' => ['desk' => ['price' => 100]]];
$flattened = Arr::dot($array);
// ['products.desk.price' => 100]
Arr::every()
Arr::every 方法判断数组中所有值是否都通过了给定的真值检测：
use Illuminate\Support\Arr;
$array = [1, 2, 3];
Arr::every($array, fn ($i) => $i > 0);
// true
Arr::every($array, fn ($i) => $i > 2);
// false
Arr::except()
Arr::except 方法从数组中移除指定的键值对：
use Illuminate\Support\Arr;
$array = ['name' => 'Desk', 'price' => 100];
$filtered = Arr::except($array, ['price']);
// ['name' => 'Desk']
Arr::exceptValues()
Arr::exceptValues 方法从数组中移除指定的值：
use Illuminate\Support\Arr;
$array = ['foo', 'bar', 'baz', 'qux'];
$filtered = Arr::exceptValues($array, ['foo', 'baz']);
// ['bar', 'qux']
你也可以给 strict 参数传 true，在过滤时使用严格类型比较：
use Illuminate\Support\Arr;
$array = [1, '1', 2, '2'];
$filtered = Arr::exceptValues($array, [1, 2], strict: true);
// ['1', '2']
Arr::exists()
Arr::exists 方法检查给定键是否存在于数组中：
use Illuminate\Support\Arr;
$array = ['name' => 'John Doe', 'age' => 17];
$exists = Arr::exists($array, 'name');
// true
$exists = Arr::exists($array, 'salary');
// false
Arr::first()
Arr::first 方法返回数组中第一个通过给定真值检测的元素：
use Illuminate\Support\Arr;
$array = [100, 200, 300];
$first = Arr::first($array, function (int $value, int $key) {
return $value >= 150;
});
// 200
也可以传第三个参数作为默认值，当没有元素通过检测时返回该默认值：
use Illuminate\Support\Arr;
$first = Arr::first($array, $callback, $default);
Arr::flatten()
Arr::flatten 方法将多维数组拍平为单层数组：
use Illuminate\Support\Arr;
$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];
$flattened = Arr::flatten($array);
// ['Joe', 'PHP', 'Ruby']
Arr::float()
Arr::float 方法用「点」记法从深层嵌套数组中取值（和 Arr::get() 一样），但如果取到的值不是 float，会抛出 InvalidArgumentException 异常：
use Illuminate\Support\Arr;
$array = ['name' => 'Joe', 'balance' => 123.45];
$value = Arr::float($array, 'balance');
// 123.45
$value = Arr::float($array, 'name');
// 抛出 InvalidArgumentException
Arr::forget()
Arr::forget 方法用「点」记法从深层嵌套数组中移除指定键值对：
use Illuminate\Support\Arr;
$array = ['products' => ['desk' => ['price' => 100]]];
Arr::forget($array, 'products.desk');
// ['products' => []]
Arr::from()
Arr::from 方法将各种输入类型转换为普通 PHP 数组。支持的类型包括数组、对象，以及多种 Laravel 常用接口，比如 Arrayable、Enumerable、Jsonable 和 JsonSerializable。此外还能处理 Traversable 和 WeakMap 实例：
use Illuminate\Support\Arr;
Arr::from((object) ['foo' => 'bar']); // ['foo' => 'bar']
class TestJsonableObject implements Jsonable
{
public function toJson($options = 0)
{
return json_encode(['foo' => 'bar']);
}
}
Arr::from(new TestJsonableObject); // ['foo' => 'bar']
Arr::get()
Arr::get 方法用「点」记法从深层嵌套数组中取值：
use Illuminate\Support\Arr;
$array = ['products' => ['desk' => ['price' => 100]]];
$price = Arr::get($array, 'products.desk.price');
// 100
Arr::get 还接受一个默认值，当指定键不存在时返回该默认值：
use Illuminate\Support\Arr;
$discount = Arr::get($array, 'products.desk.discount', 0);
// 0
Arr::has()
Arr::has 方法用「点」记法检查数组中是否存在给定的一个或多个键：
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::hasAll()
Arr::hasAll 方法用「点」记法判断给定数组中是否包含所有指定键：
use Illuminate\Support\Arr;
$array = ['name' => 'Taylor', 'language' => 'PHP'];
Arr::hasAll($array, ['name']); // true
Arr::hasAll($array, ['name', 'language']); // true
Arr::hasAll($array, ['name', 'IDE']); // false
Arr::hasAny()
Arr::hasAny 方法用「点」记法检查给定集合中是否有任意一个键存在于数组中：
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::integer()
Arr::integer 方法用「点」记法从深层嵌套数组中取值（和 Arr::get() 一样），但如果取到的值不是 int，会抛出 InvalidArgumentException 异常：
use Illuminate\Support\Arr;
$array = ['name' => 'Joe', 'age' => 42];
$value = Arr::integer($array, 'age');
// 42
$value = Arr::integer($array, 'name');
// 抛出 InvalidArgumentException
Arr::isAssoc()
Arr::isAssoc 方法在给定数组是关联数组时返回 true。如果数组的键不是从零开始的连续整数，就视为「关联数组」：
use Illuminate\Support\Arr;
$isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]);
// true
$isAssoc = Arr::isAssoc([1, 2, 3]);
// false
Arr::isList()
Arr::isList 方法在给定数组的键是从零开始的连续整数时返回 true：
use Illuminate\Support\Arr;
$isList = Arr::isList(['foo', 'bar', 'baz']);
// true
$isList = Arr::isList(['product' => ['name' => 'Desk', 'price' => 100]]);
// false
Arr::join()
Arr::join 方法用字符串连接数组元素。通过第三个参数，你可以指定最后一个元素的连接符：
use Illuminate\Support\Arr;
$array = ['Tailwind', 'Alpine', 'Laravel', 'Livewire'];
$joined = Arr::join($array, ', ');
// Tailwind, Alpine, Laravel, Livewire
$joined = Arr::join($array, ', ', ', and ');
// Tailwind, Alpine, Laravel, and Livewire
Arr::keyBy()
Arr::keyBy 方法按给定键给数组重新索引。如果多个元素有相同的键，只有最后一个会出现在新数组中：
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()
Arr::last 方法返回数组中最后一个通过给定真值检测的元素：
use Illuminate\Support\Arr;
$array = [100, 200, 300, 110];
$last = Arr::last($array, function (int $value, int $key) {
return $value >= 150;
});
// 300
也可以传第三个参数作为默认值，当没有元素通过检测时返回该默认值：
use Illuminate\Support\Arr;
$last = Arr::last($array, $callback, $default);
Arr::map()
Arr::map 方法遍历数组，将每个值和键传给回调函数。数组的值会被回调的返回值替换：
use Illuminate\Support\Arr;
$array = ['first' => 'james', 'last' => 'kirk'];
$mapped = Arr::map($array, function (string $value, string $key) {
return ucfirst($value);
});
// ['first' => 'James', 'last' => 'Kirk']
Arr::mapSpread()
Arr::mapSpread 方法遍历数组，将每个嵌套元素的值传给回调函数。回调可以修改元素并返回，从而组成新数组：
use Illuminate\Support\Arr;
$array = [
[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9],
];
$mapped = Arr::mapSpread($array, function (int $even, int $odd) {
return $even + $odd;
});
/*
[1, 5, 9, 13, 17]
*/
Arr::mapWithKeys()
Arr::mapWithKeys 方法遍历数组，将每个值传给回调函数。回调应返回一个只包含一个键值对的关联数组：
use Illuminate\Support\Arr;
$array = [
[
'name' => 'John',
'department' => 'Sales',
'email' => 'john@example.com',
],
[
'name' => 'Jane',
'department' => 'Marketing',
'email' => 'jane@example.com',
]
];
$mapped = Arr::mapWithKeys($array, function (array $item, int $key) {
return [$item['email'] => $item['name']];
});
/*
[
'john@example.com' => 'John',
'jane@example.com' => 'Jane',
]
*/
Arr::only()
Arr::only 方法只返回数组中指定的键值对：
use Illuminate\Support\Arr;
$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
$slice = Arr::only($array, ['name', 'price']);
// ['name' => 'Desk', 'price' => 100]
Arr::onlyValues()
Arr::onlyValues 方法只返回数组中指定的值：
use Illuminate\Support\Arr;
$array = ['foo', 'bar', 'baz', 'qux'];
$filtered = Arr::onlyValues($array, ['foo', 'baz']);
// ['foo', 'baz']
你也可以给 strict 参数传 true，在过滤时使用严格类型比较：
use Illuminate\Support\Arr;
$array = [1, '1', 2, '2'];
$filtered = Arr::onlyValues($array, [1, 2], strict: true);
// [1, 2]
Arr::partition()
Arr::partition 方法可以配合 PHP 数组解构，将通过真值检测和未通过的元素分成两组：
<?php
use Illuminate\Support\Arr;
$numbers = [1, 2, 3, 4, 5, 6];
[$underThree, $equalOrAboveThree] = Arr::partition($numbers, function (int $i) {
return $i < 3;
});
dump($underThree);
// [1, 2]
dump($equalOrAboveThree);
// [3, 4, 5, 6]
Arr::pluck()
Arr::pluck 方法从数组中检索所有给定键的值：
use Illuminate\Support\Arr;
$array = [
['developer' => ['id' => 1, 'name' => 'Taylor']],
['developer' => ['id' => 2, 'name' => 'Abigail']],
];
$names = Arr::pluck($array, 'developer.name');
// ['Taylor', 'Abigail']
你也可以指定结果列表的键：
use Illuminate\Support\Arr;
$names = Arr::pluck($array, 'developer.name', 'developer.id');
// [1 => 'Taylor', 2 => 'Abigail']
Arr::prepend()
Arr::prepend 方法将一个元素添加到数组开头：
use Illuminate\Support\Arr;
$array = ['one', 'two', 'three', 'four'];
$array = Arr::prepend($array, 'zero');
// ['zero', 'one', 'two', 'three', 'four']
需要的话，你可以指定该值的键：
use Illuminate\Support\Arr;
$array = ['price' => 100];
$array = Arr::prepend($array, 'Desk', 'name');
// ['name' => 'Desk', 'price' => 100]
Arr::prependKeysWith()
Arr::prependKeysWith 方法给关联数组的所有键名添加前缀：
use Illuminate\Support\Arr;
$array = [
'name' => 'Desk',
'price' => 100,
];
$keyed = Arr::prependKeysWith($array, 'product.');
/*
[
'product.name' => 'Desk',
'product.price' => 100,
]
*/
Arr::pull()
Arr::pull 方法从数组中取出并移除指定键值对：
use Illuminate\Support\Arr;
$array = ['name' => 'Desk', 'price' => 100];
$name = Arr::pull($array, 'name');
// $name: Desk
// $array: ['price' => 100]
也可以传第三个参数作为默认值，当键不存在时返回该默认值：
use Illuminate\Support\Arr;
$value = Arr::pull($array, $key, $default);
Arr::push()
Arr::push 方法用「点」记法向数组中添加元素。如果指定键位置不存在数组，会自动创建：
use Illuminate\Support\Arr;
$array = [];
Arr::push($array, 'office.furniture', 'Desk');
// $array: ['office' => ['furniture' => ['Desk']]]
Arr::query()
Arr::query 方法将数组转换为查询字符串：
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()
Arr::random 方法从数组中返回一个随机值：
use Illuminate\Support\Arr;
$array = [1, 2, 3, 4, 5];
$random = Arr::random($array);
// 4 -（随机获取）
你也可以用第二个参数指定要返回的元素数量。注意，即使只要一个元素，传了该参数也会返回数组：
use Illuminate\Support\Arr;
$items = Arr::random($array, 2);
// [2, 5] -（随机获取）
Arr::reject()
Arr::reject 方法用回调函数从数组中移除元素：
use Illuminate\Support\Arr;
$array = [100, '200', 300, '400', 500];
$filtered = Arr::reject($array, function (string|int $value, int $key) {
return is_string($value);
});
// [0 => 100, 2 => 300, 4 => 500]
Arr::select()
Arr::select 方法从数组中选取指定键的值：
use Illuminate\Support\Arr;
$array = [
['id' => 1, 'name' => 'Desk', 'price' => 200],
['id' => 2, 'name' => 'Table', 'price' => 150],
['id' => 3, 'name' => 'Chair', 'price' => 300],
];
Arr::select($array, ['name', 'price']);
// [['name' => 'Desk', 'price' => 200], ['name' => 'Table', 'price' => 150], ['name' => 'Chair', 'price' => 300]]
Arr::set()
Arr::set 方法用「点」记法在深层嵌套数组中设置值：
use Illuminate\Support\Arr;
$array = ['products' => ['desk' => ['price' => 100]]];
Arr::set($array, 'products.desk.price', 200);
// ['products' => ['desk' => ['price' => 200]]]
Arr::shuffle()
Arr::shuffle 方法随机打乱数组中的元素：
use Illuminate\Support\Arr;
$array = Arr::shuffle([1, 2, 3, 4, 5]);
// [3, 2, 5, 1, 4] -（随机生成）
Arr::sole()
Arr::sole 方法用回调函数从数组中取出唯一匹配的值。如果数组中有多个值匹配，会抛出 Illuminate\Support\MultipleItemsFoundException 异常。如果没有值匹配，会抛出 Illuminate\Support\ItemNotFoundException 异常：
use Illuminate\Support\Arr;
$array = ['Desk', 'Table', 'Chair'];
$value = Arr::sole($array, fn (string $value) => $value === 'Desk');
// 'Desk'
Arr::some()
Arr::some 方法判断数组中是否至少有一个值通过了给定的真值检测：
use Illuminate\Support\Arr;
$array = [1, 2, 3];
Arr::some($array, fn ($i) => $i > 2);
// true
Arr::sort()
Arr::sort 方法按值对数组排序：
use Illuminate\Support\Arr;
$array = ['Desk', 'Table', 'Chair'];
$sorted = Arr::sort($array);
// ['Chair', 'Desk', 'Table']
也可以按回调的返回值排序：
use Illuminate\Support\Arr;
$array = [
['name' => 'Desk'],
['name' => 'Table'],
['name' => 'Chair'],
];
$sorted = array_values(Arr::sort($array, function (array $value) {
return $value['name'];
}));
/*
[
['name' => 'Chair'],
['name' => 'Desk'],
['name' => 'Table'],
]
*/
Arr::sortDesc()
Arr::sortDesc 方法按值对数组降序排序：
use Illuminate\Support\Arr;
$array = ['Desk', 'Table', 'Chair'];
$sorted = Arr::sortDesc($array);
// ['Table', 'Desk', 'Chair']
也可以按回调的返回值降序排序：
use Illuminate\Support\Arr;
$array = [
['name' => 'Desk'],
['name' => 'Table'],
['name' => 'Chair'],
];
$sorted = array_values(Arr::sortDesc($array, function (array $value) {
return $value['name'];
}));
/*
[
['name' => 'Table'],
['name' => 'Desk'],
['name' => 'Chair'],
]
*/
Arr::sortRecursive()
Arr::sortRecursive 方法递归排序数组：数字索引子数组用 sort 排序，关联子数组用 ksort 排序：
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::sortRecursiveDesc 方法：
$sorted = Arr::sortRecursiveDesc($array);
Arr::string()
Arr::string 方法用「点」记法从深层嵌套数组中取值（和 Arr::get() 一样），但如果取到的值不是 string，会抛出 InvalidArgumentException 异常：
use Illuminate\Support\Arr;
$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];
$value = Arr::string($array, 'name');
// Joe
$value = Arr::string($array, 'languages');
// 抛出 InvalidArgumentException
Arr::take()
Arr::take 方法返回指定数量的元素组成的新数组：
use Illuminate\Support\Arr;
$array = [0, 1, 2, 3, 4, 5];
$chunk = Arr::take($array, 3);
// [0, 1, 2]
传负数则从数组末尾取指定数量的元素：
$array = [0, 1, 2, 3, 4, 5];
$chunk = Arr::take($array, -2);
// [4, 5]
Arr::toCssClasses()
Arr::toCssClasses 方法按条件编译 CSS class 字符串。方法接受一个数组，键是 class 名，值是布尔表达式。如果数组元素的键是数字，该 class 始终包含在结果中：
use Illuminate\Support\Arr;
$isActive = false;
$hasError = true;
$array = ['p-4', 'font-bold' => $isActive, 'bg-red' => $hasError];
$classes = Arr::toCssClasses($array);
/*
'p-4 bg-red'
*/
Arr::toCssStyles()
Arr::toCssStyles 方法按条件编译 CSS 样式字符串。方法接受一个数组，键是 CSS 声明，值是布尔表达式。如果数组元素的键是数字，该声明始终包含在结果中：
use Illuminate\Support\Arr;
$hasColor = true;
$array = ['background-color: blue', 'color: blue' => $hasColor];
$classes = Arr::toCssStyles($array);
/*
'background-color: blue; color: blue;'
*/
这个方法支撑了 Laravel 将 class 与 Blade 组件属性袋合并的功能，以及 @class Blade 指令。
Arr::undot()
Arr::undot 方法将使用「点」记法的单层数组还原为多维数组：
use Illuminate\Support\Arr;
$array = [
'user.name' => 'Kevin Malone',
'user.occupation' => 'Accountant',
];
$array = Arr::undot($array);
// ['user' => ['name' => 'Kevin Malone', 'occupation' => 'Accountant']]
Arr::where()
Arr::where 方法用回调函数过滤数组：
use Illuminate\Support\Arr;
$array = [100, '200', 300, '400', 500];
$filtered = Arr::where($array, function (string|int $value, int $key) {
return is_string($value);
});
// [1 => '200', 3 => '400']
Arr::whereNotNull()
Arr::whereNotNull 方法从数组中移除所有 null 值：
use Illuminate\Support\Arr;
$array = [0, null];
$filtered = Arr::whereNotNull($array);
// [0 => 0]
Arr::wrap()
Arr::wrap 方法将给定值包裹为数组。如果值已经是数组，直接返回不做修改：
use Illuminate\Support\Arr;
$string = 'Laravel';
$array = Arr::wrap($string);
// ['Laravel']
如果值是 null，返回空数组：
use Illuminate\Support\Arr;
$array = Arr::wrap(null);
// []
data_fill()
data_fill 函数用「点」记法在嵌套数组或对象中设置缺失的值：
$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]]]
该函数还支持星号通配符，会相应地填充目标：
$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()
data_get 函数用「点」记法从嵌套数组或对象中取值：
$data = ['products' => ['desk' => ['price' => 100]]];
$price = data_get($data, 'products.desk.price');
// 100
data_get 还接受一个默认值，当指定键不存在时返回该默认值：
$discount = data_get($data, 'products.desk.discount', 0);
// 0
该函数还支持星号通配符，可以匹配数组或对象的任意键：
$data = [
'product-one' => ['name' => 'Desk 1', 'price' => 100],
'product-two' => ['name' => 'Desk 2', 'price' => 150],
];
data_get($data, '*.name');
// ['Desk 1', 'Desk 2'];
可以用 {first} 和 {last} 占位符获取数组中的第一个或最后一个元素：
$flight = [
'segments' => [
['from' => 'LHR', 'departure' => '9:00', 'to' => 'IST', 'arrival' => '15:00'],
['from' => 'IST', 'departure' => '16:00', 'to' => 'PKX', 'arrival' => '20:00'],
],
];
data_get($flight, 'segments.{first}.arrival');
// 15:00
data_set()
data_set 函数用「点」记法在嵌套数组或对象中设置值：
$data = ['products' => ['desk' => ['price' => 100]]];
data_set($data, 'products.desk.price', 200);
// ['products' => ['desk' => ['price' => 200]]]
该函数还支持星号通配符，会相应地设置目标值：
$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],
],
]
*/
默认情况下会覆盖已有值。如果只想在值不存在时设置，可以给第四个参数传 false：
$data = ['products' => ['desk' => ['price' => 100]]];
data_set($data, 'products.desk.price', 200, overwrite: false);
// ['products' => ['desk' => ['price' => 100]]]
data_forget()
data_forget 函数用「点」记法从嵌套数组或对象中移除值：
$data = ['products' => ['desk' => ['price' => 100]]];
data_forget($data, 'products.desk.price');
// ['products' => ['desk' => []]]
该函数还支持星号通配符，会相应地移除目标值：
$data = [
'products' => [
['name' => 'Desk 1', 'price' => 100],
['name' => 'Desk 2', 'price' => 150],
],
];
data_forget($data, 'products.*.price');
/*
[
'products' => [
['name' => 'Desk 1'],
['name' => 'Desk 2'],
],
]
*/
head()
head 函数返回数组的第一个元素。如果数组为空，返回 false：
$array = [100, 200, 300];
$first = head($array);
// 100
last()
last 函数返回数组的最后一个元素。如果数组为空，返回 false：
$array = [100, 200, 300];
$last = last($array);
// 300
数字
Number::abbreviate()
Number::abbreviate 方法返回给定数值的人类可读格式，并带有单位缩写：
use Illuminate\Support\Number;
$number = Number::abbreviate(1000);
// 1K
$number = Number::abbreviate(489939);
// 490K
$number = Number::abbreviate(1230000, precision: 2);
// 1.23M
Number::clamp()
Number::clamp 方法确保给定数字在指定范围内。如果数字小于最小值，返回最小值；如果大于最大值，返回最大值：
use Illuminate\Support\Number;
$number = Number::clamp(105, min: 10, max: 100);
// 100
$number = Number::clamp(5, min: 10, max: 100);
// 10
$number = Number::clamp(10, min: 10, max: 100);
// 10
$number = Number::clamp(20, min: 10, max: 100);
// 20
Number::currency()
Number::currency 方法将给定值格式化为货币字符串：
use Illuminate\Support\Number;
$currency = Number::currency(1000);
// $1,000.00
$currency = Number::currency(1000, in: 'EUR');
// €1,000.00
$currency = Number::currency(1000, in: 'EUR', locale: 'de');
// 1.000,00 €
$currency = Number::currency(1000, in: 'EUR', locale: 'de', precision: 0);
// 1.000 €
Number::defaultCurrency()
Number::defaultCurrency 方法返回 Number 类当前使用的默认货币：
use Illuminate\Support\Number;
$currency = Number::defaultCurrency();
// USD
Number::defaultLocale()
Number::defaultLocale 方法返回 Number 类当前使用的默认区域设置：
use Illuminate\Support\Number;
$locale = Number::defaultLocale();
// en
Number::fileSize()
Number::fileSize 方法将给定字节数格式化为文件大小字符串：
use Illuminate\Support\Number;
$size = Number::fileSize(1024);
// 1 KB
$size = Number::fileSize(1024 * 1024);
// 1 MB
$size = Number::fileSize(1024, precision: 2);
// 1.00 KB
Number::forHumans()
Number::forHumans 方法返回给定数值的人类可读格式：
use Illuminate\Support\Number;
$number = Number::forHumans(1000);
// 1 thousand
$number = Number::forHumans(489939);
// 490 thousand
$number = Number::forHumans(1230000, precision: 2);
// 1.23 million
Number::format()
Number::format 方法将给定数字格式化为区域相关的字符串：
use Illuminate\Support\Number;
$number = Number::format(100000);
// 100,000
$number = Number::format(100000, precision: 2);
// 100,000.00
$number = Number::format(100000.123, maxPrecision: 2);
// 100,000.12
$number = Number::format(100000, locale: 'de');
// 100.000
Number::ordinal()
Number::ordinal 方法返回数字的序数表示：
use Illuminate\Support\Number;
$number = Number::ordinal(1);
// 1st
$number = Number::ordinal(2);
// 2nd
$number = Number::ordinal(21);
// 21st
Number::pairs()
Number::pairs 方法根据指定范围和步长生成一组数字对（子区间）。在分页或批处理任务中将大范围数字拆分为小子区间时很有用。该方法返回一个数组的数组，每个内层数组代表一个数字对（子区间）：
use Illuminate\Support\Number;
$result = Number::pairs(25, 10);
// [[0, 9], [10, 19], [20, 25]]
$result = Number::pairs(25, 10, offset: 0);
// [[0, 10], [10, 20], [20, 25]]
Number::parse()
Number::parse 方法用 PHP 的 NumberFormatter 解析区域化的数字字符串：
use Illuminate\Support\Number;
$result = Number::parse('10,123', locale: 'en');
// 10123.0
$result = Number::parse('10,123', locale: 'fr');
// 10.123
Number::parseInt()
Number::parseInt 方法按指定区域设置将字符串解析为整数：
use Illuminate\Support\Number;
$result = Number::parseInt('10.123');
// (int) 10
$result = Number::parseInt('10,123', locale: 'fr');
// (int) 10
Number::parseFloat()
Number::parseFloat 方法按指定区域设置将字符串解析为浮点数：
use Illuminate\Support\Number;
$result = Number::parseFloat('10');
// (float) 10.0
$result = Number::parseFloat('10', locale: 'fr');
// (float) 10.0
Number::percentage()
Number::percentage 方法将给定值格式化为百分比字符串：
use Illuminate\Support\Number;
$percentage = Number::percentage(10);
// 10%
$percentage = Number::percentage(10, precision: 2);
// 10.00%
$percentage = Number::percentage(10.123, maxPrecision: 2);
// 10.12%
$percentage = Number::percentage(10, precision: 2, locale: 'de');
// 10,00%
Number::spell()
Number::spell 方法将给定数字转换为英文单词：
use Illuminate\Support\Number;
$number = Number::spell(102);
// one hundred and two
$number = Number::spell(88, locale: 'fr');
// quatre-vingt-huit
after 参数可以指定一个阈值，超过该阈值后所有数字都拼写为单词：
$number = Number::spell(10, after: 10);
// 10
$number = Number::spell(11, after: 10);
// eleven
until 参数可以指定一个阈值，在该阈值之前所有数字都拼写为单词：
$number = Number::spell(5, until: 10);
// five
$number = Number::spell(10, until: 10);
// 10
Number::spellOrdinal()
Number::spellOrdinal 方法返回数字的序数单词表示：
use Illuminate\Support\Number;
$number = Number::spellOrdinal(1);
// first
$number = Number::spellOrdinal(2);
// second
$number = Number::spellOrdinal(21);
// twenty-first
Number::trim()
Number::trim 方法移除给定数字小数点后末尾的零：
use Illuminate\Support\Number;
$number = Number::trim(12.0);
// 12
$number = Number::trim(12.30);
// 12.3
Number::useLocale()
Number::useLocale 方法全局设置默认数字区域，影响后续所有 Number 类方法的数字和货币格式化：
use Illuminate\Support\Number;
/**
* 引导应用服务。
*/
public function boot(): void
{
Number::useLocale('de');
}
Number::withLocale()
Number::withLocale 方法在指定区域下执行给定闭包，执行完后恢复原来的区域设置：
use Illuminate\Support\Number;
$number = Number::withLocale('de', function () {
return Number::format(1500);
});
Number::useCurrency()
Number::useCurrency 方法全局设置默认货币，影响后续所有 Number 类方法的货币格式化：
use Illuminate\Support\Number;
/**
* 引导应用服务。
*/
public function boot(): void
{
Number::useCurrency('GBP');
}
Number::withCurrency()
Number::withCurrency 方法在指定货币下执行给定闭包，执行完后恢复原来的货币设置：
use Illuminate\Support\Number;
$number = Number::withCurrency('GBP', function () {
// ...
});
路径
app_path()
app_path() 函数返回应用 app 目录的完整路径。也可以用它生成 app 目录下某个文件的完整路径：
$path = app_path();
$path = app_path('Http/Controllers/Controller.php');
base_path()
base_path() 函数返回应用根目录的完整路径。也可以用它生成项目根目录下某个文件的完整路径：
$path = base_path();
$path = base_path('vendor/bin');
config_path()
config_path() 函数返回应用 config 目录的完整路径。也可以用它生成配置目录下某个文件的完整路径：
$path = config_path();
$path = config_path('app.php');
database_path()
database_path() 函数返回应用 database 目录的完整路径。也可以用它生成数据库目录下某个文件的完整路径：
$path = database_path();
$path = database_path('factories/UserFactory.php');
lang_path()
lang_path() 函数返回应用 lang 目录的完整路径。也可以用它生成该目录下某个文件的完整路径：
$path = lang_path();
$path = lang_path('en/messages.php');
信息
默认情况下，Laravel 应用骨架不包含 lang 目录。如果你想自定义 Laravel 的语言文件，可以通过 lang:publish Artisan 命令发布。
public_path()
public_path() 函数返回应用 public 目录的完整路径。也可以用它生成 public 目录下某个文件的完整路径：
$path = public_path();
$path = public_path('css/app.css');
resource_path()
resource_path() 函数返回应用 resources 目录的完整路径。也可以用它生成 resources 目录下某个文件的完整路径：
$path = resource_path();
$path = resource_path('sass/app.scss');
storage_path()
storage_path() 函数返回应用 storage 目录的完整路径。也可以用它生成 storage 目录下某个文件的完整路径：
$path = storage_path();
$path = storage_path('app/file.txt');
URL
action()
action() 函数为给定控制器方法生成 URL：
use App\Http\Controllers\HomeController;
$url = action([HomeController::class, 'index']);
如果方法接受路由参数，可以作为第二个参数传入：
$url = action([UserController::class, 'profile'], ['id' => 1]);
asset()
asset() 函数用当前请求的协议（HTTP 或 HTTPS）为资源生成 URL：
$url = asset('img/photo.jpg');
你可以在 .env 文件中设置 ASSET_URL 变量来配置资源 URL 的主机。如果你把资源托管在外部服务上（比如 Amazon S3 或其他 CDN），这会很有用：
// ASSET_URL=http://example.com/assets
$url = asset('img/photo.jpg'); // http://example.com/assets/img/photo.jpg
route()
route() 函数为给定的命名路由生成 URL：
$url = route('route.name');
如果路由接受参数，可以作为第二个参数传入：
$url = route('route.name', ['id' => 1]);
默认情况下，route() 函数生成绝对 URL。如果想生成相对 URL，可以给第三个参数传 false：
$url = route('route.name', ['id' => 1], false);
secure_asset()
secure_asset() 函数用 HTTPS 为资源生成 URL：
$url = secure_asset('img/photo.jpg');
secure_url()
secure_url() 函数为给定路径生成完整的 HTTPS URL。可以在第二个参数中传入额外的 URL 片段：
$url = secure_url('user/profile');
$url = secure_url('user/profile', [1]);
to_action()
to_action() 函数为给定控制器方法生成重定向 HTTP 响应：
use App\Http\Controllers\UserController;
return to_action([UserController::class, 'show'], ['user' => 1]);
需要的话，可以给第三个和第四个参数传入重定向的 HTTP 状态码和额外的响应头：
return to_action(
[UserController::class, 'show'],
['user' => 1],
302,
['X-Framework' => 'Laravel']
);
to_route()
to_route() 函数为给定的命名路由生成重定向 HTTP 响应：
return to_route('users.show', ['user' => 1]);
需要的话，可以给第三个和第四个参数传入重定向的 HTTP 状态码和额外的响应头：
return to_route('users.show', ['user' => 1], 302, ['X-Framework' => 'Laravel']);
uri()
uri() 函数为给定 URI 生成流畅的 URI 实例：
$uri = uri('https://example.com')
->withPath('/users')
->withQuery(['page' => 1]);
如果给 uri() 函数传入一个包含可调用控制器和方法对的数组，会为该控制器方法的路由路径创建 Uri 实例：
use App\Http\Controllers\UserController;
$uri = uri([UserController::class, 'show'], ['user' => $user]);
如果控制器是可调用的（invokable），直接传类名即可：
use App\Http\Controllers\UserIndexController;
$uri = uri(UserIndexController::class);
如果给 uri() 函数的值匹配某个命名路由的名称，会为该路由路径生成 Uri 实例：
$uri = uri('users.show', ['user' => $user]);
url()
url() 函数为给定路径生成完整的 URL：
$url = url('user/profile');
$url = url('user/profile', [1]);
如果不传路径，返回 Illuminate\Routing\UrlGenerator 实例：
$current = url()->current();
$full = url()->full();
$previous = url()->previous();
更多关于 url() 函数的用法，请查阅 URL 生成文档。
杂项
abort()
abort() 函数抛出 HTTP 异常，由异常处理器渲染：
abort(403);
也可以提供异常消息和自定义 HTTP 响应头：
abort(403, 'Unauthorized.', $headers);
abort_if()
abort_if() 函数在给定布尔表达式为 true 时抛出 HTTP 异常：
abort_if(! Auth::user()->isAdmin(), 403);
和 abort() 一样，也可以用第三个参数传入响应文本，第四个参数传入自定义响应头。
abort_unless()
abort_unless() 函数在给定布尔表达式为 false 时抛出 HTTP 异常：
abort_unless(Auth::user()->isAdmin(), 403);
和 abort() 一样，也可以用第三个参数传入响应文本，第四个参数传入自定义响应头。
app()
app() 函数返回服务容器实例：
$container = app();
也可以传入类或接口名从容器中解析：
$api = app('HelpSpot\API');
auth()
auth() 函数返回认证器实例。可以用它代替 Auth 门面：
$user = auth()->user();
需要的话，可以指定要访问的 guard：
$user = auth('admin')->user();
back()
back() 函数生成一个重定向 HTTP 响应到用户上一个位置：
return back($status = 302, $headers = [], $fallback = '/');
return back();
bcrypt()
bcrypt() 函数用 Bcrypt 哈希给定值。可以用它代替 Hash 门面：
$password = bcrypt('my-secret-password');
blank()
blank() 函数判断给定值是否为「空白」：
blank('');
blank(' ');
blank(null);
blank(collect());
// true
blank(0);
blank(true);
blank(false);
// false
blank() 的反义函数是 filled()。
broadcast()
broadcast(new UserRegistered($user));
broadcast(new UserRegistered($user))->toOthers();
broadcast_if()
broadcast_if() 函数在给定布尔表达式为 true 时，将给定的事件广播给监听器：
broadcast_if($user->isActive(), new UserRegistered($user));
broadcast_if($user->isActive(), new UserRegistered($user))->toOthers();
broadcast_unless()
broadcast_unless() 函数在给定布尔表达式为 false 时，将给定的事件广播给监听器：
broadcast_unless($user->isBanned(), new UserRegistered($user));
broadcast_unless($user->isBanned(), new UserRegistered($user))->toOthers();
cache()
cache() 函数可用于从缓存中取值。如果指定键不存在，返回可选的默认值：
$value = cache('key');
$value = cache('key', 'default');
可以通过传入键值对数组来添加缓存项，同时指定缓存有效时间（秒数或持续时间）：
cache(['key' => 'value'], 300);
cache(['key' => 'value'], now()->plus(seconds: 10));
class_uses_recursive()
class_uses_recursive() 函数返回一个类使用的所有 trait，包括其父类使用的 trait：
$traits = class_uses_recursive(App\Models\User::class);
collect()
collect() 函数用给定值创建一个集合实例：
$collection = collect(['Taylor', 'Abigail']);
config()
config() 函数获取配置变量的值。配置值用「点」记法访问，包含文件名和要访问的选项。也可以提供默认值，当配置项不存在时返回：
$value = config('app.timezone');
$value = config('app.timezone', $default);
可以通过传入键值对数组在运行时设置配置变量。但注意，该函数只影响当前请求的配置值，不会更新实际配置文件：
config(['app.debug' => true]);
context()
context() 函数从当前上下文中取值。也可以提供默认值，当上下文键不存在时返回：
$value = context('trace_id');
$value = context('trace_id', $default);
可以通过传入键值对数组来设置上下文值：
use Illuminate\Support\Str;
context(['trace_id' => Str::uuid()->toString()]);
cookie()
cookie() 函数创建一个新的 cookie 实例：
$cookie = cookie('name', 'value', $minutes);
csrf_field()
csrf_field() 函数生成一个包含 CSRF token 值的 HTML hidden 输入字段。例如，用 Blade 语法：
{{ csrf_field() }}
csrf_token()
csrf_token() 函数获取当前 CSRF token 的值：
$token = csrf_token();
decrypt()
decrypt() 函数解密给定值。可以用它代替 Crypt 门面：
$password = decrypt($value);
decrypt() 的反义函数是 encrypt()。
dd()
dd() 函数输出给定变量并终止脚本执行：
dd($value);
dd($value1, $value2, $value3, ...);
如果不想终止脚本执行，改用 dump() 函数。
dispatch()
dispatch() 函数将给定的任务推送到 Laravel 任务队列：
dispatch(new App\Jobs\SendEmails);
dispatch_sync()
dispatch_sync() 函数将给定任务推送到 sync 队列，使其立即执行：
dispatch_sync(new App\Jobs\SendEmails);
dump()
dump() 函数输出给定变量：
dump($value);
dump($value1, $value2, $value3, ...);
如果想在输出变量后终止脚本执行，改用 dd() 函数。
encrypt()
encrypt() 函数加密给定值。可以用它代替 Crypt 门面：
$secret = encrypt('my-secret-value');
encrypt() 的反义函数是 decrypt()。
env()
env() 函数获取环境变量的值或返回默认值：
$env = env('APP_ENV');
$env = env('APP_ENV', 'production');
注意
如果在部署流程中执行了 config:cache 命令，请确保只在配置文件中调用 env() 函数。配置缓存后，.env 文件不会被加载，所有 env() 调用都将返回外部环境变量（如服务器级或系统级环境变量）或 null。
event()
event() 函数将给定的事件派发给监听器：
event(new UserRegistered($user));
fake()
fake() 函数从容器中解析 Faker 单例，在模型工厂、数据库填充、测试和视图原型中创建假数据时很有用：
@for ($i = 0; $i < 10; $i++)
<dl>
<dt>Name</dt>
<dd>{{ fake()->name() }}</dd>
<dt>Email</dt>
<dd>{{ fake()->unique()->safeEmail() }}</dd>
</dl>
@endfor
默认情况下，fake() 函数使用 config/app.php 中的 app.faker_locale 配置项。通常该配置通过 APP_FAKER_LOCALE 环境变量设置。也可以直接给 fake() 传入区域设置。每个区域会解析为独立的单例：
fake('nl_NL')->name()
filled()
filled() 函数判断给定值是否不为「空白」：
filled(0);
filled(true);
filled(false);
// true
filled('');
filled(' ');
filled(null);
filled(collect());
// false
filled() 的反义函数是 blank()。
info()
info() 函数向应用的日志写入信息：
info('Some helpful information!');
也可以传入上下文数据数组：
info('User login attempt failed.', ['id' => $user->id]);
literal()
literal() 函数用给定的命名参数作为属性创建一个新的 stdClass 实例：
$obj = literal(
name: 'Joe',
languages: ['PHP', 'Ruby'],
);
$obj->name; // 'Joe'
$obj->languages; // ['PHP', 'Ruby']
logger()
logger() 函数可用于向日志写入 debug 级别消息：
logger('Debug message');
也可以传入上下文数据数组：
logger('User has logged in.', ['id' => $user->id]);
如果不传值，返回 logger 实例：
logger()->error('You are not allowed here.');
method_field()
method_field() 函数生成一个包含表单 HTTP 动词伪造值的 HTML hidden 输入字段。例如，用 Blade 语法：
<form method="POST">
{{ method_field('DELETE') }}
</form>
now()
now() 函数为当前时间创建一个 Illuminate\Support\Carbon 实例：
$now = now();
old()
$value = old('value');
$value = old('value', 'default');
由于 old() 函数第二个参数的「默认值」通常是 Eloquent 模型的属性，Laravel 允许直接将整个 Eloquent 模型作为第二个参数传入。此时，Laravel 会假设第一个参数是要用作「默认值」的 Eloquent 属性名：
{{ old('name', $user->name) }}
// 等价于...
{{ old('name', $user) }}
once()
once() 函数执行给定回调并在请求期间将结果缓存在内存中。后续用相同回调调用 once() 会返回之前缓存的结果：
function random(): int
{
return once(function () {
return random_int(1, 1000);
});
}
random(); // 123
random(); // 123（缓存结果）
random(); // 123（缓存结果）
在对象实例中调用 once() 时，缓存结果对该对象实例是唯一的：
<?php
class NumberService
{
public function all(): array
{
return once(fn () => [1, 2, 3]);
}
}
$service = new NumberService;
$service->all();
$service->all(); //（缓存结果）
$secondService = new NumberService;
$secondService->all();
$secondService->all(); //（缓存结果）
optional()
optional() 函数接受任意参数，允许你访问该对象的属性或调用方法。如果给定对象是 null，访问属性和方法会返回 null 而不是报错：
return optional($user->address)->street;
{!! old('name', optional($user)->name) !!}
optional() 函数还接受闭包作为第二个参数。当第一个参数不为 null 时，闭包会被调用：
return optional(User::find($id), function (User $user) {
return $user->name;
});
policy()
policy() 函数为给定类获取策略实例：
$policy = policy(App\Models\User::class);
redirect()
redirect() 函数返回重定向 HTTP 响应，如果不传参数则返回重定向器实例：
return redirect($to = null, $status = 302, $headers = [], $secure = null);
return redirect('/home');
return redirect()->route('route.name');
report()
report() 函数使用异常处理器报告异常：
report($e);
report() 函数也接受字符串参数。传入字符串时，会以该字符串为消息创建一个异常：
report('Something went wrong.');
report_if()
report_if() 函数在给定布尔表达式为 true 时，使用异常处理器报告异常：
report_if($shouldReport, $e);
report_if($shouldReport, 'Something went wrong.');
report_unless()
report_unless() 函数在给定布尔表达式为 false 时，使用异常处理器报告异常：
report_unless($reportingDisabled, $e);
report_unless($reportingDisabled, 'Something went wrong.');
request()
request() 函数返回当前请求实例，或获取当前请求中某个输入字段的值：
$request = request();
$value = request('key', $default);
rescue()
rescue() 函数执行给定闭包并捕获执行过程中的所有异常。捕获的异常会发送给异常处理器，但请求会继续处理：
return rescue(function () {
return $this->method();
});
也可以给 rescue() 传第二个参数作为「默认值」，在闭包执行出错时返回：
return rescue(function () {
return $this->method();
}, false);
return rescue(function () {
return $this->method();
}, function () {
return $this->failure();
});
可以通过 report 参数决定是否通过 report() 函数报告异常：
return rescue(function () {
return $this->method();
}, report: function (Throwable $throwable) {
return $throwable instanceof InvalidArgumentException;
});
resolve()
resolve() 函数用服务容器将给定类或接口名解析为实例：
$api = resolve('HelpSpot\API');
response()
response() 函数创建响应实例或获取响应工厂实例：
return response('Hello World', 200, $headers);
return response()->json(['foo' => 'bar'], 200, $headers);
retry()
retry() 函数尝试执行给定回调，直到达到最大尝试次数。如果回调没有抛出异常，返回其返回值。如果回调抛出异常，会自动重试。超过最大尝试次数后，抛出异常：
return retry(5, function () {
// 尝试 5 次，每次间隔 100 毫秒...
}, 100);
间隔时间也接受 CarbonInterval 实例：
use function Illuminate\Support\seconds;
return retry(5, function () {
// 尝试 5 次，每次间隔 5 秒...
}, seconds(5));
如果想手动计算每次重试间隔的毫秒数，可以给第三个参数传闭包：
use Exception;
return retry(5, function () {
// ...
}, function (int $attempt, Exception $exception) {
return $attempt * 100;
});
为方便起见，可以给第一个参数传数组，用于决定后续每次重试的间隔毫秒数：
return retry([100, 200], function () {
// 第一次重试间隔 100ms，第二次重试间隔 200ms...
});
如果只想在特定条件下重试，可以给第四个参数传闭包：
use App\Exceptions\TemporaryException;
use Exception;
return retry(5, function () {
// ...
}, 100, function (Exception $exception) {
return $exception instanceof TemporaryException;
});
session()
session() 函数可用于获取或设置 session 值：
$value = session('key');
可以通过传入键值对数组来设置值：
session(['chairs' => 7, 'instruments' => 3]);
如果不传值，返回 session 存储实例：
$value = session()->get('key');
session()->put('key', $value);
tap()
tap() 函数接受两个参数：任意 $value 和一个闭包。$value 会被传给闭包，然后由 tap() 函数返回。闭包的返回值会被忽略：
$user = tap(User::first(), function (User $user) {
$user->name = 'Taylor';
$user->save();
});
如果不传闭包，可以在给定 $value 上调用任意方法。无论方法实际返回什么，调用方法的返回值始终是 $value。例如，Eloquent 的 update 方法通常返回整数，但通过 tap() 链式调用 update 可以强制返回模型本身：
$user = tap($user)->update([
'name' => $name,
'email' => $email,
]);
要给类添加 tap 方法，可以在类中使用 Illuminate\Support\Traits\Tappable trait。该 trait 的 tap 方法接受一个闭包作为唯一参数。对象实例本身会被传给闭包，然后由 tap 方法返回：
return $user->tap(function (User $user) {
// ...
});
throw_if()
throw_if() 函数在给定布尔表达式为 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()
throw_unless() 函数在给定布尔表达式为 false 时抛出给定异常：
throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);
throw_unless(
Auth::user()->isAdmin(),
AuthorizationException::class,
'You are not allowed to access this page.'
);
today()
today() 函数为当前日期创建一个 Illuminate\Support\Carbon 实例：
$today = today();
trait_uses_recursive()
trait_uses_recursive() 函数返回一个 trait 使用的所有 trait：
$traits = trait_uses_recursive(\Illuminate\Notifications\Notifiable::class);
transform()
transform() 函数在给定值不为空白时对其执行闭包，然后返回闭包的返回值：
$callback = function (int $value) {
return $value * 2;
};
$result = transform(5, $callback);
// 10
可以传第三个参数作为默认值或闭包，当值为空白时返回：
$result = transform(null, $callback, 'The value is blank');
// The value is blank
validator()
validator() 函数用给定参数创建一个新的验证器实例。可以用它代替 Validator 门面：
$validator = validator($data, $rules, $messages);
value()
value() 函数返回给定值。但如果传入闭包，会执行闭包并返回其返回值：
$result = value(true);
// true
$result = value(function () {
return false;
});
// false
可以给 value() 传入额外参数。如果第一个参数是闭包，额外参数会作为闭包的参数传入，否则会被忽略：
$result = value(function (string $name) {
return $name;
}, 'Taylor');
// 'Taylor'
view()
view() 函数获取视图实例：
return view('auth.login');
with()
with() 函数返回给定值。如果第二个参数传闭包，会执行闭包并返回其返回值：
$callback = function (mixed $value) {
return is_numeric($value) ? $value * 2 : 0;
};
$result = with(5, $callback);
// 10
$result = with(null, $callback);
// 0
$result = with(5, null);
// 5
when()
when() 函数在给定条件为 true 时返回给定值，否则返回 null。如果第二个参数传闭包，会执行闭包并返回其返回值：
$value = when(true, 'Hello World');
$value = when(true, fn () => 'Hello World');
when() 函数主要用于条件渲染 HTML 属性：
<div {!! when($condition, 'wire:poll="calculate"') !!}>
...
</div>
其他工具
基准测试
有时你可能想快速测试应用某些部分的性能。这时可以用 Benchmark 支持类来测量给定回调执行所需的毫秒数：
<?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
]);
默认情况下，给定回调只执行一次（一次迭代），执行时间会显示在浏览器或终端中。
要多次执行回调，可以用第二个参数指定迭代次数。多次执行时，Benchmark 类会返回所有迭代的平均执行毫秒数：
Benchmark::dd(fn () => User::count(), iterations: 10); // 0.5 ms
有时你可能想在基准测试的同时获取回调的返回值。value 方法会返回一个元组，包含回调的返回值和执行毫秒数：
[$count, $duration] = Benchmark::value(fn () => User::count());
日期与时间
Laravel 内置了 Carbon，一个强大的日期时间操作库。要创建新的 Carbon 实例，可以调用 now() 函数。该函数在 Laravel 应用中全局可用：
$now = now();
也可以用 Illuminate\Support\Carbon 类创建新的 Carbon 实例：
use Illuminate\Support\Carbon;
$now = Carbon::now();
Laravel 还为 Carbon 实例增加了 plus 和 minus 方法，方便操作日期时间：
return now()->plus(minutes: 5);
return now()->plus(hours: 8);
return now()->plus(weeks: 4);
return now()->minus(minutes: 5);
return now()->minus(hours: 8);
return now()->minus(weeks: 4);
关于 Carbon 的完整功能介绍，请查阅 Carbon 官方文档。
区间函数
Laravel 还提供了 milliseconds、seconds、minutes、hours、days、weeks、months 和 years 函数，返回 CarbonInterval 实例（继承自 PHP 的 DateInterval 类）。这些函数可在任何接受 DateInterval 实例的地方使用：
use Illuminate\Support\Facades\Cache;
use function Illuminate\Support\{minutes};
Cache::put('metrics', $metrics, minutes(10));
延迟函数
虽然 Laravel 的队列任务允许你将任务排队进行后台处理，但有时你可能只是想延迟一些简单任务，不想配置和维护长期运行的队列 worker。
延迟函数允许你将闭包的执行推迟到 HTTP 响应发送给用户之后，让应用保持快速响应。要延迟闭包的执行，只需将闭包传给 Illuminate\Support\defer 函数：
use App\Services\Metrics;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use function Illuminate\Support\defer;
Route::post('/orders', function (Request $request) {
// 创建订单...
defer(fn () => Metrics::reportOrder($order));
return $order;
});
默认情况下，延迟函数只在调用 Illuminate\Support\defer 的 HTTP 响应、Artisan 命令或队列任务成功完成时才执行。也就是说，如果请求返回 4xx 或 5xx HTTP 响应，延迟函数不会执行。如果你希望延迟函数始终执行，可以链式调用 always 方法：
defer(fn () => Metrics::reportOrder($order))->always();
注意
如果安装了 Swoole PHP 扩展，Laravel 的 defer 函数可能与 Swoole 自身的全局 defer 函数冲突，导致 Web 服务器报错。请确保通过显式命名空间来调用 Laravel 的 defer 辅助函数：use function Illuminate\Support\defer;
取消延迟函数
如果需要在延迟函数执行前取消它，可以用 forget 方法按名称取消。要给延迟函数命名，给 Illuminate\Support\defer 函数传第二个参数：
defer(fn () => Metrics::report(), 'reportMetrics');
defer()->forget('reportMetrics');
在测试中禁用延迟函数
编写测试时，可能需要禁用延迟函数。你可以在测试中调用 withoutDefer 来指示 Laravel 立即执行所有延迟函数：
test('without defer', function () {
$this->withoutDefer();
// ...
});
use Tests\TestCase;
class ExampleTest extends TestCase
{
public function test_without_defer(): void
{
$this->withoutDefer();
// ...
}
}
如果想在整个测试类的所有测试中禁用延迟函数，可以在基础 TestCase 类的 setUp 方法中调用 withoutDefer：
<?php
namespace Tests;
use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
abstract class TestCase extends BaseTestCase
{
protected function setUp(): void
{
parent::setUp();
$this->withoutDefer();
}
}
抽奖
Laravel 的抽奖类可以按给定概率执行回调。当你只想对部分请求执行某些代码时，这特别有用：
use Illuminate\Support\Lottery;
Lottery::odds(1, 20)
->winner(fn () => $user->won())
->loser(fn () => $user->lost())
->choose();
你可以将抽奖类与 Laravel 的其他功能结合使用。例如，你可能只想报告小比例的慢查询。由于抽奖类是可调用的，可以将它的实例传给任何接受 callable 的方法：
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.')),
);
测试抽奖
Laravel 提供了一些简单方法来方便地测试应用中的抽奖调用：
// 抽奖始终中奖...
Lottery::alwaysWin();
// 抽奖始终不中奖...
Lottery::alwaysLose();
// 抽奖先中奖再不中奖，最后恢复正常行为...
Lottery::fix([true, false]);
// 抽奖恢复正常行为...
Lottery::determineResultsNormally();
管道
Laravel 的 Pipeline 门面提供了一种便捷方式，将给定输入「传送」穿过一系列可调用类、闭包或 callable，让每个类都有机会检查或修改输入，然后调用管道中的下一个 callable：
use Closure;
use App\Models\User;
use Illuminate\Support\Facades\Pipeline;
$user = Pipeline::send($user)
->through([
function (User $user, Closure $next) {
// ...
return $next($user);
},
function (User $user, Closure $next) {
// ...
return $next($user);
},
])
->then(fn (User $user) => $user);
如你所见，管道中的每个可调用类或闭包都接收输入和一个 $next 闭包。调用 $next 闭包会调用管道中的下一个 callable。你可能注意到了，这和中间件非常相似。
当管道中最后一个 callable 调用 $next 闭包时，传给 then 方法的 callable 会被调用。通常这个 callable 就是简单地返回给定输入。为方便起见，如果你只想在处理完成后返回输入，可以用 thenReturn 方法。
当然，如前所述，管道中不限于使用闭包。也可以使用可调用类。如果传入类名，类会通过 Laravel 的服务容器实例化，允许依赖注入到可调用类中：
$user = Pipeline::send($user)
->through([
GenerateProfilePhoto::class,
ActivateSubscription::class,
SendWelcomeEmail::class,
])
->thenReturn();
可以在管道上调用 withinTransaction 方法，自动将管道所有步骤包裹在单个数据库事务中：
$user = Pipeline::send($user)
->withinTransaction()
->through([
ProcessOrder::class,
TransferFunds::class,
UpdateInventory::class,
])
->thenReturn();
睡眠
Laravel 的 Sleep 类是 PHP 原生 sleep 和 usleep 函数的轻量封装，提供更好的可测试性，同时暴露了对开发者更友好的时间操作 API：
use Illuminate\Support\Sleep;
$waiting = true;
while ($waiting) {
Sleep::for(1)->second();
$waiting = /* ... */;
}
Sleep 类提供了多种方法来处理不同的时间单位：
// 睡眠后返回一个值...
$result = Sleep::for(1)->second()->then(fn () => 1 + 1);
// 当给定值为 true 时持续睡眠...
Sleep::for(1)->second()->while(fn () => shouldKeepSleeping());
// 暂停执行 90 秒...
Sleep::for(1.5)->minutes();
// 暂停执行 2 秒...
Sleep::for(2)->seconds();
// 暂停执行 500 毫秒...
Sleep::for(500)->milliseconds();
// 暂停执行 5000 微秒...
Sleep::for(5000)->microseconds();
// 暂停执行直到给定时间...
Sleep::until(now()->plus(minutes: 1));
// PHP 原生 sleep 函数的别名...
Sleep::sleep(2);
// PHP 原生 usleep 函数的别名...
Sleep::usleep(5000);
要组合不同的时间单位，可以用 and 方法：
Sleep::for(1)->second()->and(10)->milliseconds();
测试睡眠
测试使用 Sleep 类或 PHP 原生 sleep 函数的代码时，测试会暂停执行。这会让测试套件明显变慢。例如，假设你在测试以下代码：
$waiting = /* ... */;
$seconds = 1;
while ($waiting) {
Sleep::for($seconds++)->seconds();
$waiting = /* ... */;
}
通常，测试这段代码至少需要一秒钟。幸运的是，Sleep 类允许我们「伪造」睡眠，让测试套件保持快速：
it('waits until ready', function () {
Sleep::fake();
// ...
});
public function test_it_waits_until_ready()
{
Sleep::fake();
// ...
}
伪造 Sleep 类后，实际的执行暂停会被跳过，测试速度大幅提升。
伪造 Sleep 类后，可以对预期发生的「睡眠」进行断言。假设我们在测试暂停执行三次、每次递增一秒的代码。用 assertSequence 方法可以断言代码「睡」了正确的时间，同时保持测试快速：
it('checks if ready three times', function () {
Sleep::fake();
// ...
Sleep::assertSequence([
Sleep::for(1)->second(),
Sleep::for(2)->seconds(),
Sleep::for(3)->seconds(),
]);
});
public function test_it_checks_if_ready_three_times()
{
Sleep::fake();
// ...
Sleep::assertSequence([
Sleep::for(1)->second(),
Sleep::for(2)->seconds(),
Sleep::for(3)->seconds(),
]);
}
当然，Sleep 类还提供了多种其他断言方法：
use Carbon\CarbonInterval as Duration;
use Illuminate\Support\Sleep;
// 断言 sleep 被调用了 3 次...
Sleep::assertSleptTimes(3);
// 断言 sleep 的持续时间...
Sleep::assertSlept(function (Duration $duration): bool {
return /* ... */;
}, times: 1);
// 断言 Sleep 类从未被调用...
Sleep::assertNeverSlept();
// 断言即使调用了 Sleep，也没有实际暂停执行...
Sleep::assertInsomniac();
有时在伪造睡眠时执行某些操作会很有用。可以给 whenFakingSleep 方法传入回调。以下示例中，我们用 Laravel 的时间操作辅助函数来按每次睡眠的持续时间推进时间：
use Carbon\CarbonInterval as Duration;
$this->freezeTime();
Sleep::fake();
Sleep::whenFakingSleep(function (Duration $duration) {
// 伪造睡眠时推进时间...
$this->travel($duration->totalMilliseconds)->milliseconds();
});
由于推进时间是常见需求，fake 方法接受 syncWithCarbon 参数来在测试中睡眠时保持 Carbon 同步：
Sleep::fake(syncWithCarbon: true);
$start = now();
Sleep::for(1)->second();
$start->diffForHumans(); // 1 second ago
Laravel 在内部暂停执行时也会使用 Sleep 类。例如，retry() 辅助函数在睡眠时就用了 Sleep 类，使用该辅助函数时也能获得更好的可测试性。
时间盒
Laravel 的 Timebox 类确保给定闭包始终花费固定的时间执行，即使实际执行提前完成。这在加密操作和用户认证检查中特别有用，攻击者可能通过执行时间差异来推断敏感信息。
如果执行超过固定时间，Timebox 不起作用。开发者需要选择足够长的固定时间来应对最坏情况。
call 方法接受一个闭包和以微秒为单位的时间限制，然后执行闭包并等待直到时间限制到达：
use Illuminate\Support\Timebox;
(new Timebox)->call(function ($timebox) {
// ...
}, microseconds: 10000);
如果闭包内抛出异常，该类会遵守设定的延迟时间，在延迟结束后重新抛出异常。
URI
Laravel 的 Uri 类为创建和操作 URI 提供了便捷的流畅接口。该类封装了底层 League URI 包的功能，并与 Laravel 的路由系统无缝集成。
可以用静态方法轻松创建 Uri 实例：
use App\Http\Controllers\UserController;
use App\Http\Controllers\InvokableController;
use Illuminate\Support\Uri;
// 从给定字符串生成 URI 实例...
$uri = Uri::of('https://example.com/path');
// 生成路径、命名路由或控制器方法的 URI 实例...
$uri = Uri::to('/dashboard');
$uri = Uri::route('users.show', ['user' => 1]);
$uri = Uri::signedRoute('users.show', ['user' => 1]);
$uri = Uri::temporarySignedRoute('user.index', now()->plus(minutes: 5));
$uri = Uri::action([UserController::class, 'index']);
$uri = Uri::action(InvokableController::class);
// 从当前请求 URL 生成 URI 实例...
$uri = $request->uri();
创建 URI 实例后，可以流畅地修改它：
$uri = Uri::of('https://example.com')
->withScheme('http')
->withHost('test.com')
->withPort(8000)
->withPath('/users')
->withQuery(['page' => 2])
->withFragment('section-1');
检查 URI
Uri 类还可以轻松检查底层 URI 的各个组成部分：
$scheme = $uri->scheme();
$authority = $uri->authority();
$host = $uri->host();
$port = $uri->port();
$path = $uri->path();
$segments = $uri->pathSegments();
$query = $uri->query();
$fragment = $uri->fragment();
操作查询字符串
Uri 类提供了多种方法来操作 URI 的查询字符串。withQuery 方法可将额外参数合并到现有查询字符串中：
$uri = $uri->withQuery(['sort' => 'name']);
withQueryIfMissing 方法在给定键不存在于查询字符串中时，将额外参数合并进去：
$uri = $uri->withQueryIfMissing(['page' => 1]);
replaceQuery 方法用新查询字符串完全替换现有查询字符串：
$uri = $uri->replaceQuery(['page' => 1]);
pushOntoQuery 方法可将额外参数推送到查询字符串中值为数组的参数上：
$uri = $uri->pushOntoQuery('filter', ['active', 'pending']);
withoutQuery 方法可从查询字符串中移除参数：
$uri = $uri->withoutQuery(['page']);
从 URI 生成响应
redirect 方法可为给定 URI 生成 RedirectResponse 实例：
$uri = Uri::of('https://example.com');
return $uri->redirect();
也可以直接从路由或控制器方法返回 Uri 实例，会自动生成指向该 URI 的重定向响应：
use Illuminate\Support\Facades\Route;
use Illuminate\Support\Uri;
Route::get('/redirect', function () {
return Uri::to('/index')
->withQuery(['sort' => 'name']);
});