行业资讯

Laravel 6.11新增功能有哪些

发布时间：2021-12-28 16:51:24 作者：小新
来源：亿速云 阅读：143

Laravel 6.11 新增功能有哪些

Laravel 6.11 是 Laravel 6.x 系列的一个小版本更新，虽然它没有引入重大的新功能，但仍然带来了一些有用的改进和修复。本文将详细介绍 Laravel 6.11 中新增的功能和改进。

1. 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);

2. 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;

3. 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());

4. 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);

5. 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';
});

6. 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';
});

7. Collection::hasAny 方法

Collection::hasAny 方法允许你检查集合中是否存在任意一个指定的键。这在需要检查集合中是否存在某些键时非常有用。

use Illuminate\Support\Collection;

$collection = collect(['name' => 'John', 'age' => 25]);

$hasAny = $collection->hasAny(['name', 'email']);

// 输出: true
echo $hasAny ? 'true' : 'false';

8. Collection::sole 方法

Collection::sole 方法允许你获取集合中唯一的一个元素。如果集合中有多个元素或没有元素，则会抛出异常。

use Illuminate\Support\Collection;

$collection = collect(['John']);

$sole = $collection->sole();

// 输出: 'John'
echo $sole;

9. Collection::firstOrFail 方法

Collection::firstOrFail 方法允许你获取集合中的第一个元素。如果集合为空，则会抛出异常。

use Illuminate\Support\Collection;

$collection = collect(['John', 'Jane', 'Doe']);

$first = $collection->firstOrFail();

// 输出: 'John'
echo $first;

10. 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());

11. 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());

12. 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());

13. 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());

14. Collection::lazy 方法

Collection::lazy 方法允许你将集合转换为一个惰性集合。这在处理大量数据时非常有用，因为它可以节省内存。

use Illuminate\Support\Collection;

$collection = collect([1, 2, 3, 4, 5]);

$lazy = $collection->lazy();

// 输出: LazyCollection {#1}
print_r($lazy);

15. Collection::lazyById 方法

Collection::lazyById 方法允许你根据 ID 将集合转换为一个惰性集合。这在处理大量数据时非常有用，因为它可以节省内存。

use Illuminate\Support\Collection;

$collection = collect([1, 2, 3, 4, 5]);

$lazyById = $collection->lazyById();

// 输出: LazyCollection {#1}
print_r($lazyById);

16. Collection::lazyByIdDesc 方法

Collection::lazyByIdDesc 方法允许你根据 ID 将集合转换为一个惰性集合，并按降序排列。这在处理大量数据时非常有用，因为它可以节省内存。

use Illuminate\Support\Collection;

$collection = collect([1, 2, 3, 4, 5]);

$lazyByIdDesc = $collection->lazyByIdDesc();

// 输出: LazyCollection {#1}
print_r($lazyByIdDesc);

17. 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);

18. 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);

19. 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);

20. 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);

21. 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);

22. 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);

23. 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);

24. 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);

25. 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);

26. 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);

27. 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);

28. Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValueDesc 方法

Collection::lazyByIdChunkWithOffsetAndLimitAndOrderAndKeyAndValueDesc 方法允许你根据 ID 将集合转换为一个惰性集合，并按块处理，并带有偏移量和限制，并按指定的顺序排列，并按指定的键和值排列，并按降序排列。这在处理大量数据时非常有用，因为它可以节省内存。

”`php use Illuminate\Support\Collection;

$collection = collect([1, 2, 3, 4, 5]);

$lazyByIdChunkWithOffsetAndLimit

推荐阅读：
  1. Laravel 7新功能有哪些
  2. Laravel实用小功能有哪些

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

laravel

上一篇：分析工具SPSS怎么用

下一篇：如何进行Driver中AppClient源码分析

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号