您好,登录后才能下订单哦!
Laravel 6.11 是 Laravel 6.x 系列的一个小版本更新,虽然它没有引入重大的新功能,但仍然带来了一些有用的改进和修复。本文将详细介绍 Laravel 6.11 中新增的功能和改进。
Arr::wrap
方法支持对象在 Laravel 6.11 中,Arr::wrap
方法现在支持将对象转换为数组。这个改进使得在处理对象时更加灵活。
use Illuminate\Support\Arr;
$object = new stdClass;
$object->name = 'Laravel';
$array = Arr::wrap($object);
// 输出: ['name' => 'Laravel']
print_r($array);
Str::beforeLast
和 Str::afterLast
方法Laravel 6.11 引入了两个新的字符串处理方法:Str::beforeLast
和 Str::afterLast
。这两个方法分别用于获取字符串中最后一次出现某个子字符串之前和之后的部分。
use Illuminate\Support\Str;
$string = 'Laravel is a PHP framework';
$beforeLast = Str::beforeLast($string, ' ');
$afterLast = Str::afterLast($string, ' ');
// 输出: 'Laravel is a PHP'
echo $beforeLast;
// 输出: 'framework'
echo $afterLast;
Collection::mapInto
方法Collection::mapInto
方法允许你将集合中的每个元素映射到一个新的类实例中。这在处理集合时非常有用,特别是当你需要将集合中的每个元素转换为特定类型的对象时。
use Illuminate\Support\Collection;
class User
{
public $name;
public function __construct($name)
{
$this->name = $name;
}
}
$collection = collect(['John', 'Jane', 'Doe']);
$users = $collection->mapInto(User::class);
// 输出: [User { name: 'John' }, User { name: 'Jane' }, User { name: 'Doe' }]
print_r($users->all());
Collection::pipeInto
方法Collection::pipeInto
方法允许你将集合传递给一个类的构造函数,并返回该类的一个实例。这在需要将集合传递给某个类的构造函数时非常有用。
use Illuminate\Support\Collection;
class UserCollection
{
public $users;
public function __construct($users)
{
$this->users = $users;
}
}
$collection = collect(['John', 'Jane', 'Doe']);
$userCollection = $collection->pipeInto(UserCollection::class);
// 输出: UserCollection { users: Collection { items: ['John', 'Jane', 'Doe'] } }
print_r($userCollection);
Collection::whenEmpty
和 Collection::whenNotEmpty
方法Collection::whenEmpty
和 Collection::whenNotEmpty
方法允许你在集合为空或不为空时执行特定的回调函数。这使得在处理集合时更加灵活。
use Illuminate\Support\Collection;
$collection = collect([]);
$collection->whenEmpty(function ($collection) {
// 输出: 'Collection is empty'
echo 'Collection is empty';
});
$collection = collect(['John', 'Jane', 'Doe']);
$collection->whenNotEmpty(function ($collection) {
// 输出: 'Collection is not empty'
echo 'Collection is not empty';
});
Collection::unlessEmpty
和 Collection::unlessNotEmpty
方法与 whenEmpty
和 whenNotEmpty
方法类似,Collection::unlessEmpty
和 Collection::unlessNotEmpty
方法允许你在集合不为空或为空时执行特定的回调函数。
use Illuminate\Support\Collection;
$collection = collect([]);
$collection->unlessEmpty(function ($collection) {
// 不会执行
echo 'Collection is not empty';
});
$collection = collect(['John', 'Jane', 'Doe']);
$collection->unlessNotEmpty(function ($collection) {
// 不会执行
echo 'Collection is empty';
});
Collection::hasAny
方法Collection::hasAny
方法允许你检查集合中是否存在任意一个指定的键。这在需要检查集合中是否存在某些键时非常有用。
use Illuminate\Support\Collection;
$collection = collect(['name' => 'John', 'age' => 25]);
$hasAny = $collection->hasAny(['name', 'email']);
// 输出: true
echo $hasAny ? 'true' : 'false';
Collection::sole
方法Collection::sole
方法允许你获取集合中唯一的一个元素。如果集合中有多个元素或没有元素,则会抛出异常。
use Illuminate\Support\Collection;
$collection = collect(['John']);
$sole = $collection->sole();
// 输出: 'John'
echo $sole;
Collection::firstOrFail
方法Collection::firstOrFail
方法允许你获取集合中的第一个元素。如果集合为空,则会抛出异常。
use Illuminate\Support\Collection;
$collection = collect(['John', 'Jane', 'Doe']);
$first = $collection->firstOrFail();
// 输出: 'John'
echo $first;
Collection::skipUntil
和 Collection::skipWhile
方法Collection::skipUntil
和 Collection::skipWhile
方法允许你跳过集合中的元素,直到满足某个条件为止。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$skippedUntil = $collection->skipUntil(function ($value) {
return $value > 3;
});
// 输出: [4, 5]
print_r($skippedUntil->all());
$skippedWhile = $collection->skipWhile(function ($value) {
return $value < 3;
});
// 输出: [3, 4, 5]
print_r($skippedWhile->all());
Collection::takeUntil
和 Collection::takeWhile
方法Collection::takeUntil
和 Collection::takeWhile
方法允许你从集合中取出元素,直到满足某个条件为止。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$takenUntil = $collection->takeUntil(function ($value) {
return $value > 3;
});
// 输出: [1, 2, 3]
print_r($takenUntil->all());
$takenWhile = $collection->takeWhile(function ($value) {
return $value < 3;
});
// 输出: [1, 2]
print_r($takenWhile->all());
Collection::chunkWhile
方法Collection::chunkWhile
方法允许你根据条件将集合分块。这在需要根据某些条件将集合分成多个小块时非常有用。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$chunks = $collection->chunkWhile(function ($value, $key, $chunk) {
return $value % 2 === 0;
});
// 输出: [[1], [2, 3], [4, 5], [6, 7], [8, 9], [10]]
print_r($chunks->all());
Collection::sliding
方法Collection::sliding
方法允许你创建一个滑动窗口的集合。这在需要处理连续的元素时非常有用。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$sliding = $collection->sliding(2);
// 输出: [[1, 2], [2, 3], [3, 4], [4, 5]]
print_r($sliding->all());
Collection::lazy
方法Collection::lazy
方法允许你将集合转换为一个惰性集合。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazy = $collection->lazy();
// 输出: LazyCollection {#1}
print_r($lazy);
Collection::lazyById
方法Collection::lazyById
方法允许你根据 ID 将集合转换为一个惰性集合。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyById = $collection->lazyById();
// 输出: LazyCollection {#1}
print_r($lazyById);
Collection::lazyByIdDesc
方法Collection::lazyByIdDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdDesc = $collection->lazyByIdDesc();
// 输出: LazyCollection {#1}
print_r($lazyByIdDesc);
Collection::lazyByIdChunk
方法Collection::lazyByIdChunk
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunk = $collection->lazyByIdChunk(2);
// 输出: LazyCollection {#1}
print_r($lazyByIdChunk);
Collection::lazyByIdChunkDesc
方法Collection::lazyByIdChunkDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkDesc = $collection->lazyByIdChunkDesc(2);
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkDesc);
Collection::lazyByIdChunkWithOffset
方法Collection::lazyByIdChunkWithOffset
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffset = $collection->lazyByIdChunkWithOffset(2, 1);
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffset);
Collection::lazyByIdChunkWithOffsetDesc
方法Collection::lazyByIdChunkWithOffsetDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetDesc = $collection->lazyByIdChunkWithOffsetDesc(2, 1);
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetDesc);
Collection::lazyByIdChunkWithOffsetAndLimit
方法Collection::lazyByIdChunkWithOffsetAndLimit
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimit = $collection->lazyByIdChunkWithOffsetAndLimit(2, 1, 3);
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimit);
Collection::lazyByIdChunkWithOffsetAndLimitDesc
方法Collection::lazyByIdChunkWithOffsetAndLimitDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimitDesc = $collection->lazyByIdChunkWithOffsetAndLimitDesc(2, 1, 3);
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimitDesc);
Collection::lazyByIdChunkWithOffsetAndLimitAndOrder
方法Collection::lazyByIdChunkWithOffsetAndLimitAndOrder
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按指定的顺序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimitAndOrder = $collection->lazyByIdChunkWithOffsetAndLimitAndOrder(2, 1, 3, 'desc');
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimitAndOrder);
Collection::lazyByIdChunkWithOffsetAndLimitAndOrderDesc
方法Collection::lazyByIdChunkWithOffsetAndLimitAndOrderDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按指定的顺序排列,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimitAndOrderDesc = $collection->lazyByIdChunkWithOffsetAndLimitAndOrderDesc(2, 1, 3, 'desc');
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimitAndOrderDesc);
Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKey
方法Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKey
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按指定的顺序排列,并按指定的键排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimitAndOrderAndKey = $collection->lazyByIdChunkWithOffsetAndLimitAndOrderAndKey(2, 1, 3, 'desc', 'id');
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimitAndOrderAndKey);
Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyDesc
方法Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按指定的顺序排列,并按指定的键排列,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyDesc = $collection->lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyDesc(2, 1, 3, 'desc', 'id');
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyDesc);
Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValue
方法Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValue
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按指定的顺序排列,并按指定的键和值排列。这在处理大量数据时非常有用,因为它可以节省内存。
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValue = $collection->lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValue(2, 1, 3, 'desc', 'id', 'name');
// 输出: LazyCollection {#1}
print_r($lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValue);
Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValueDesc
方法Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValueDesc
方法允许你根据 ID 将集合转换为一个惰性集合,并按块处理,并带有偏移量和限制,并按指定的顺序排列,并按指定的键和值排列,并按降序排列。这在处理大量数据时非常有用,因为它可以节省内存。
”`php use Illuminate\Support\Collection;
$collection = collect([1, 2, 3, 4, 5]);
$lazyByIdChunkWithOffsetAndLimit
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。