Коллекции в Laravel 7

1
2
3
4
5
6
7
8
9
10
11
12
13
$users = collect([
    collect(['id' => 1, 'name' => 'Роман']),
    collect(['id' => 2, 'name' => 'Сергей']),
]);
 
$users->toArray();
 
/*
[
    ['id' => 1, 'name' => 'Роман'],
    ['id' => 2, 'name' => 'Сергей'],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
collect([1,3,8])->avg();
// 4 (потому что (1 + 3 + 8) / 3 = 4
 
/*
 * Еще один пример.
 */
$daysInMonthsCount = collect([
    'Январь' => 31,
    'Февраль' => collect([28,29])->average(), // average() - то же, что и avg()
    'Март' => 31,
    'Апрель' => 30,
    'Май' => 31,
    'Июнь' => 30,
    'Июль' => 31,
    'Август' => 31,
    'Сентябрь' => 30,
    'Октябрь' => 31,
    'Ноябрь' => 30,
    'Декабрь' => 31,
]);
 
$daysInMonthsCount->avg();
 
// Среднее количество дней в месяце - 30.458333333333

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$collection = collect([
    ['name' => 'Роман', 'contact_info' => '+7 (999) 888-33-44'],
    ['name' => 'Алексей', 'contact_info' => '+7 (495) 123-12-21'],
    ['name' => 'Сергей', 'contact_info' => 'some.email@sarvarov.dev'],
    ['name' => 'Роман', 'contact_info' => 'one.more@email.com'],
    ['name' => 'Андрей', 'contact_info' => '+7 (925) 454-89-17'],
]);
 
// Посчитаем, сколько пользователей оставили свой Email в качестве контактной информации
$countBy = $collection->countBy(
    fn($contactInfo) => strpos($contactInfo['contact_info'] ?? '', '@') !== false ? 'email' : 'phone'
);
 
$countBy->all();
 
/*
[
    'phone' => 3,
    'email' => 2,
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
$workers = collect(['Роман', 'Сергей', 'Алексей']);
 
$workersLife = $workers->crossJoin([
    'Встал с утра', 
    'Пошел на работу', 
    'Пришел с работы', 
    'Лёг спать'
]);
 
$workersLife->all();
/*
[
    ['Роман', 'Встал с утра'],
    ['Роман', 'Пошел на работу'],
    ['Роман', 'Пришел с работы'],
    ['Роман', 'Лёг спать'],
 
    ['Сергей', 'Встал с утра'],
    ['Сергей', 'Пошел на работу'],
    ['Сергей', 'Пришел с работы'],
    ['Сергей', 'Лёг спать'],
 
    ['Алексей', 'Встал с утра'],
    ['Алексей', 'Пошел на работу'],
    ['Алексей', 'Пришел с работы'],
    ['Алексей', 'Лёг спать'],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$users = collect([
    ['id' => 1, 'name' => 'Роман'],
    ['id' => 2, 'name' => 'Евгений'],
    ['id' => 3, 'name' => 'Максим'],
    ['id' => 4, 'name' => 'Роман'],
]);
 
$dublicateNames = $users->duplicates(fn($val) => $val['name']); 
 
// Тоже самое, но проще: 
$dublicateNames = $users->duplicates('name');
 
$dublicateNames->all();
 
// ['Роман']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$users = collect([
    ['id' => 1, 'name' => 'Роман', 'is_admin' => true],
    ['id' => 2, 'name' => 'Анна', 'is_admin' => true],
    ['id' => 3, 'name' => 'Борис', 'is_admin' => false],
]);
 
/* Проверим, являются ли все пользователи в коллекции администраторами */
/* Эти 3 строки являются идентичными: */
 
// $users->every(fn($value, $key) => $value['is_admin'] ?? false);
// $users->every('is_admin', '=', true);
$users->every('is_admin', true);
 
// false (Борис не администратор)

1
2
3
4
5
6
7
8
9
10
11
$users = collect([
    'id' => 1,
    'name' => 'Роман',
    'password' => '$2y$10$nsipFleZ3hQkrmhW3N40aOFMqT.swZyyb/TgZ1JUu3H1QRMhxZ3Wq',
    'email' => 'roman@sarvarov.dev',
]);
 
$safeUsersDataCollection = $users->only('id', 'name');
 
$safeUsersDataCollection->all();
// ['id' => 1, 'name' => 'Роман']

1
2
3
4
5
6
7
8
9
10
11
$users = collect([
    'id' => 1,
    'name' => 'Роман',
    'password' => '$2y$10$nsipFleZ3hQkrmhW3N40aOFMqT.swZyyb/TgZ1JUu3H1QRMhxZ3Wq',
    'email' => 'roman@sarvarov.dev',
]);
 
$safeUsersDataCollection = $users->except('password', 'email');
 
$safeUsersDataCollection->all();
// ['id' => 1, 'name' => 'Роман']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
$gadgets = collect([
    ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'телефон'],
    ['name' => 'iPhone 5', 'brand' => 'Apple', 'type' => 'телефон'],
    ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'часы'],
    ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'телефон'],
    ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'часы'],
]);
 
$gadgets->unique('brand')->values()->all();
/*
[
    ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'телефон'],
    ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'телефон'],
]
*/
 
$gadgets->unique(
    fn($item, $key) => "{$item['brand']}_{$item['type']}"
)->values()->all();
/*
[
    ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'телефон'],
    ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'часы'],
    ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'телефон'],
    ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'часы'],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$collection = collect([0, null, 1, 2, 3, 4, '', 5, 6, 7, 8, false, []]);
 
// Оставим только цифры, которые делятся на 2. Так же оставим все нечисловые значения для будущего теста.
$filtered = $collection->filter(
    fn($value, $key) => (is_numeric($value) && $value % 2 === 0) || !is_numeric($value)
);
 
$filtered->all();
// 0, null, 2, 4, '', 6, 8, false, []
 
$filtered = $filtered->filter();
 
$filtered->all();
// [2, 4, 6, 8]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
$collection = collect([2, 6, 4, 4, '6', 8]);
 
$collection->search(4);
// 2 (находит только первое значение и прекращает поиск)
 
$collection->search('6', true);
// 4 (строгое сравнение типов)
 
$collection->search(9999);
// false
 
$users = collect([
    ['id' => 1, 'name' => 'Илья', 'age' => 35],
    ['id' => 2, 'name' => 'Роман', 'age' => 23],
    ['id' => 3, 'name' => 'Глеб', 'age' => 84],
    ['id' => 4, 'name' => 'Максим', 'age' => 14],
]);
 
/* Найдем Романа */
$users->search(fn($value, $key) => Str::startsWith(
    Str::lower($value['name']), 'рома')
);
// 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
$users = collect([
    ['id' => 1, 'name' => 'Илья', 'age' => 28],
    ['id' => 2, 'name' => 'Роман', 'age' => 23, 'is_admin' => true],
    ['id' => 3, 'name' => 'Максим', 'age' => 44],
    ['id' => 4, 'name' => 'Семён', 'age' => 29],
    ['id' => 5, 'name' => 'Василий', 'age' => 32, 'is_admin' => true],
    ['id' => 6, 'name' => 'Владимир', 'age' => 16],
    ['id' => 7, 'name' => 'Роман', 'age' => 58],
    ['id' => 8, 'name' => 'Максим', 'age' => 23],
]);
 
/* Простой поиск */
$admins = $users->where('is_admin', true);
// Тоже самое что и $users->where('is_admin', 1);
// Тоже самое что и $users->where('is_admin', '=', true);
 
$admins->all();
/*
[
    ['id' => 2, 'name' => 'Роман', 'age' => 23, 'is_admin' => true],
    ['id' => 5, 'name' => 'Василий', 'age' => 32, 'is_admin' => true],
]
*/
 
/* Строгое сравнение данных */
$admins = $users->whereStrict('is_admin', 1);
 
$admins->all();
// [] - ничего не нашло, так как (int)1 !== (bool)true
 
/* Поиск с оператором */
$oldGuys = $users->where('age', '>', 30);
 
$oldGuys->all();
/*
[
    ['id' => 3, 'name' => 'Максим', 'age' => 44],
    ['id' => 5, 'name' => 'Василий', 'age' => 32, 'is_admin' => true],
    ['id' => 7, 'name' => 'Роман', 'age' => 58],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
$articles = collect([
    ['id' => 1, 'title' => 'Первая статья', 'category' => 117],
    ['id' => 2, 'title' => 'Вторая статья', 'category' => 56],
    ['id' => 3, 'title' => 'Третья статья', 'category' => 98],
    ['id' => 4, 'title' => 'Четвертая статья', 'category' => '117'],
    ['id' => 5, 'title' => 'Пятая статья', 'category' => 1],
]);
 
/* Нестрогое сравнение */
$articles->whereIn('category', [98, 117])->all();
/*
[
    ['id' => 1, 'title' => 'Первая статья', 'category' => 117],
    ['id' => 3, 'title' => 'Третья статья', 'category' => 98],
    ['id' => 4, 'title' => 'Четвертая статья', 'category' => '117'],
]
*/
 
/* Строгое сравнение */
$articles->whereInStrict('category', [98, 117])->all();
/*
[
    ['id' => 1, 'title' => 'Первая статья', 'category' => 117],
    ['id' => 3, 'title' => 'Третья статья', 'category' => 98],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
$articles = collect([
    ['id' => 1, 'title' => 'Первая статья', 'category' => 117],
    ['id' => 2, 'title' => 'Вторая статья', 'category' => 56],
    ['id' => 3, 'title' => 'Третья статья', 'category' => 98],
    ['id' => 4, 'title' => 'Четвертая статья', 'category' => '117'],
    ['id' => 5, 'title' => 'Пятая статья', 'category' => 1],
]);
 
/* Нестрогое сравнение */
$articles->whereNotIn('category', [98, 117])->all();
/*
[
    ['id' => 2, 'title' => 'Вторая статья', 'category' => 56],
    ['id' => 5, 'title' => 'Пятая статья', 'category' => 1],
]
*/
 
/* Строгое сравнение */
$articles->whereNotInStrict('category', [98, 117])->all();
/*
[
    ['id' => 2, 'title' => 'Вторая статья', 'category' => 56],
    ['id' => 4, 'title' => 'Четвертая статья', 'category' => '117'],
    ['id' => 5, 'title' => 'Пятая статья', 'category' => 1],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$collection->first(); 
// 1
 
/* Вернем первое число, которое делится на 2 без остатка (но не самое 2) */
$collection->first(
    fn ($value, $key) => $value !== 2 && $value % 2 === 0
);
// 4
 
/* Попросим несуществующее значение. Должно вернуть значение по умолчанию */
$collection->first(
    fn ($value) => $value === 1111, 'default'
); 
// default

1
2
3
4
5
6
7
8
$table = collect(['id' => 512, 'name' => 'Стол', 'price' => 5000]);
 
$table
    ->put('price', 7500)
    ->put('description', 'Он стоит!');
 
$table->all();
// ['id' => 512, 'name' => 'Стол', 'price' => 7500, 'description' => 'Он стоит!']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
$collection = collect(['Ноль', 'Один', 'Два', 'Три', 'Четыре', 'Пять', 'Шесть']);
 
/*
 * Выведем на экран все цифры без, которые делятся на 2 и не больше 4
 */
$collection->each(function ($value, $key) {
    if ($key > 4) {
        return false; // Ключ элемента больше чем 4, завершим цикл
    }
 
    if ($key === 0 || $key % 2 !== 0) {
        return; // Не делится на 2 без остатка, перейдем к следующему элементу коллекции
    }
 
    echo $value . PHP_EOL;
});
 
/*
 * Два
 * Четыре
 */
 
/*
 * Это тоже самое, что:
 *
 * foreach ($collection->toArray() as $key => $value) {
 *     if ($key > 4) {
 *         break;
 *     }
 * 
 *     if ($key === 0 || $key % 2 !== 0) {
 *         continue;
 *     }
 * 
 *     echo $value . PHP_EOL;
 * }
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
$users = collect([
    ['Егор', 11, 'Тюмень'], // Можно использовать и массив
    ['Роман', 23, 'Москва'],
    collect(['Денис', 16, 'Берлин']), // ... и коллекции
]);
 
$users->eachSpread(function ($name, $age, $city) {
    if ($age >= 18) {
        return;
    }
 
    echo "Пользователю $name из г. $city менее 18-ти лет!\n";
});
 
/*
 * Пользователю Егор из г. Тюмень менее 18-ти лет!
 * Пользователю Денис из г. Берлин менее 18-ти лет!
 */
 
/*
 * Если делать с помощью обычного each() - будет менее читабельно:
 *    
 * $users->each(function ($value, $key) {
 *     if ($value[1] >= 18) {
 *         return;
 *     }
 * 
 *     echo "Пользователю {$value[0]} из г. {$value[2]} менее 18-ти лет!\n";
 * });
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$users = collect([
    ['id' => 1, 'name' => 'Роман', 'balance' => 350, 'is_admin' => true],
    ['id' => 2, 'name' => 'Елизавета', 'balance' => 1200],
    ['id' => 3, 'name' => 'Максим', 'balance' => 540],
    ['id' => 4, 'name' => 'Егор', 'balance' => 3720],
]);
 
/* Посчитаем баланс всех пользователей, исключая администраторов */
$totalUserBalance = $users->reduce(function ($carry, $value) {
    return $carry + (empty($value['is_admin']) ? $value['balance'] : 0);
});
 
echo $totalUserBalance;
// 5460

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class User
{
    /** @var string */
    private $name;
 
    /**
     * User constructor.
     *
     * @param  string  $name
     */
    public function __construct(string $name)
    {
        $this->name = $name;
    }
}
 
// Клиентский код
$userNames = collect(['Роман', 'Виталий', 'Егор']);
 
$users = $userNames->mapInto(User::class);
 
$users->all();
/*
[
    User {
        name: 'Роман'
    },
    User {
        name: 'Виталий'
    },
    User {
        name: 'Егор'
    },
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
$users = collect([
    [1, 'роман'],
    [2, 'егор'],
    [3, 'александр']
]);
 
// Сделаем так, чтобы имена были с заглавной буквы
$users = $users->mapSpread(fn($id, $name) => [$id, Str::ucfirst($name)]);
 
$users->all();
 
/*
 * [
 *     [1, 'Роман'],
 *     [2, 'Егор'],
 *     [3, 'Александр'],
 * ]
*/
 
/*
 * Можно было это сделать и с помощью map(), но выглядит это не очень красиво:
 * 
 * $users = $users->map(fn($values) => [$values[0], Str::ucfirst($values[1])]);
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$users = collect([
    ['id' => 1, 'name' => 'Роман', 'country' => 'Россия', 'city' => 'Москва'],
    ['id' => 2, 'name' => 'Том', 'country' => 'США', 'city' => 'Нью-Йорк'],
    ['id' => 3, 'name' => 'Глеб', 'country' => 'Россия', 'city' => 'Санкт-Петербург'],
    ['id' => 4, 'name' => 'Джордж', 'country' => 'США', 'city' => 'Вашингтон'],
    ['id' => 5, 'name' => 'Алексей', 'country' => 'Россия', 'city' => 'Уфа'],
    ['id' => 6, 'name' => 'Патрик', 'country' => 'Австралия', 'city' => 'Сидней'],
]);
 
$usersLocations = $users->mapToGroups(
    fn($value, $key) => [$value['country'] => $value['city']]
);
 
$usersLocations->toArray();
 
/*
[
    'Россия' => ['Москва', 'Санкт-Петербург', 'Уфа'],
    'США' => ['Нью-Йорк','Вашингтон'],
    'Австралия' => ['Сидней'],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$collection = collect([
    ['name' => 'Сергей', 'email' => 'sergey@test.com'],
    ['name' => 'Роман', 'email' => 'roma1991@mail.ru'],
    ['name' => 'Роман', 'email' => 'roman@sarvarov.dev'],
]);
 
$keyed = $collection->mapWithKeys(
    fn($item) => [$item['name'] => $item['email']]
);
 
$keyed->all();
/*
[
  'Сергей' => 'sergey@test.com',
  'Роман' => 'roman@sarvarov.dev',
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$roman = collect([
    'name' => 'Роман',
    'age' => 23,
    'city' => 'Москва',
    'password' => '$2y$10$nsipFleZ3hQkrmhW3N40aOFMqT.swZyyb/TgZ1JUu3H1QRMhxZ3Wq',
    'email' => 'roman@sarvarov.dev',
    'phone' => '+7 (999) 123-45-67',
]);
 
// Можно удалить единственный ключ
$roman->forget('password');
 
// Можно удалить несколько ключей сразу
$roman->forget(['phone', 'email']);
 
// Можно использовать PHP функцию unset()
unset($roman['city']);
 
$roman->all();
// ['name' => 'Роман', 'age' => 23]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$users = collect([
    ['name' => 'Роман', 'city' => 'Москва'],
    ['name' => 'Том', 'city' => 'Нью-Йорк'],
    ['name' => 'Глеб', 'city' => 'Москва'],
    ['name' => 'Патрик', 'city' => 'Сидней'],
]);
 
// Разделим коллекцию на группы по городам
$usersCities = $users->groupBy('city');
 
$usersCities->toArray();
/*
[
    'Москва' => [
        ['name' => 'Роман', 'city' => 'Москва'],
        ['name' => 'Глеб', 'city' => 'Москва']
    ],
    'Нью-Йорк' => [
        ['name' => 'Том', 'city' => 'Нью-Йорк'],
    ],
    'Сидней' => [
        ['name' => 'Патрик', 'city' => 'Сидней'],
    ],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
$users = collect([
    ['name' => 'Роман', 'country' => 'Россия', 'city' => 'Москва'],
    ['name' => 'Олег', 'country' => 'Украина', 'city' => 'Одесса'],
    ['name' => 'Евгений', 'country' => 'Россия', 'city' => 'Липецк'],
    ['name' => 'Антонина', 'country' => 'Беларусь', 'city' => 'Гомель'],
    ['name' => 'Герман', 'country' => 'Украина', 'city' => 'Одесса'],
    ['name' => 'Анатолий', 'country' => 'Казахстан', 'city' => 'Караганда'],
]);
 
$usersByLocations = $users->groupBy(['country', 'city']);
 
$usersByLocations->toArray();
/*
[
    'Россия' => [
        'Москва' => [
            ['name' => 'Роман', 'country' => 'Россия', 'city' => 'Москва'],
        ],
        'Липецк' => [
            ['name' => 'Евгений', 'country' => 'Россия', 'city' => 'Липецк'],
        ],
    ],
    'Украина' => [
        'Одесса' => [
            ['name' => 'Олег', 'country' => 'Украина', 'city' => 'Одесса'],
            ['name' => 'Герман', 'country' => 'Украина', 'city' => 'Одесса'],
        ],
    ]
    'Беларусь' => [
        'Гомель' => [
            ['name' => 'Антонина', 'country' => 'Беларусь', 'city' => 'Гомель'],
        ],
    ],
    'Казахстан' => [
        'Караганда' => [
            ['name' => 'Анатолий', 'country' => 'Казахстан', 'city' => 'Караганда'],
        ],
    ],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Допустим, есть работники, с которыми можно связаться по одному номеру телефона
$workers = collect([
    ['name' => 'Роман', 'phone_number' => '+7 495 123-33-44'],
    ['name' => 'Ольга', 'phone_number' => '84951233344'],
    ['name' => 'Петр', 'phone_number' => '8 (499) 987-65-43'],
    ['name' => 'Анна', 'phone_number' => '+7 499 987-65-43'],
]);
 
// Как мы видим, они в разном формате. Давайте сгруппируем их, используя callback-функцию
$phoneNumbers = $workers->groupBy(function ($value, $key) {
    $phoneNumber = Str::of(preg_replace('/\D/', '', $value['phone_number']));
 
    // Если номер телефона начинается на 7, заменим на 8
    if ($phoneNumber->startsWith('7')) {
        $phoneNumber = $phoneNumber->replaceFirst('7', '8');
    }
 
    return (string) $phoneNumber;
});
 
$phoneNumbers->toArray();
/*
[
    '84951233344' => [
        ['name' => 'Роман', 'phone_number' => '+7 495 123-33-44'],
        ['name' => 'Ольга', 'phone_number' => '84951233344'],
    ],
    '84999876543' => [
        ['name' => 'Петр', 'phone_number' => '8 (499) 987-65-43'],
        ['name' => 'Анна''phone_number' => '+7 499 987-65-43'],
    ],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
$users = collect([
    'user_564' => ['name' => 'Роман', 'city' => 'Москва'],
    'user_110' => ['name' => 'Вацлав', 'city' => 'Варшава'],
    'user_1097' => ['name' => 'Петр', 'city' => 'Минск'],
    'user_849' => ['name' => 'Вениамин', 'city' => 'Москва'],
]);
 
$usersByLocations = $users->groupBy('city', true);
 
$usersByLocations->toArray();
/*
[
    'Москва' => [
        'user_564' => ['name' => 'Роман', 'city' => 'Москва'],
        'user_849' => ['name' => 'Вениамин', 'city' => 'Москва'],
    ],
    'Варшава' => [
        'user_110' => ['name' => 'Вацлав', 'city' => 'Варшава'],
    ],
    'Минск' => [
        'user_1097' => ['name' => 'Петр', 'city' => 'Минск'],
    ],
]
*/
 
/*
 * Если не установить в preserveKeys true, то вернулось бы так:
 
 * [
 *     'Москва' => [
 *         ['name' => 'Роман', 'city' => 'Москва'],
 *         ['name' => 'Вениамин', 'city' => 'Москва'],
 *     ],
 *     'Варшава' => [
 *         ['name' => 'Вацлав', 'city' => 'Варшава'],
 *     ],
 *     'Минск' => [
 *         ['name' => 'Петр', 'city' => 'Минск'],
 *     ],
 * ]
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
$collection = collect(['account_id' => 1, 'product' => 'Стол', 'amount' => 5]);
 
$collection->has('product');
// true
 
$collection->has(['product', 'amount']);
// true
 
$collection->has(['amount', 'price']);
// false
 
/*
 * Будет тот же результат, если использовать стандартные средства PHP:
 *
 * isset($collection['product']) // true
 * isset($collection['product'], $collection['amount']) // true
 * isset($collection['amount'], $collection['price']) // false
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
$collection = collect([1, 2, 3, 4, 5, 4, 3, 2, 1]);
 
/* Сумма все элементов */
$collection->sum();
// 25
 
/* Сумма элементов в многомерной коллекции (баланс пользователей) */
$users = collect([
    ['id' => 1, 'name' => 'Роман', 'balance' => 95000, 'is_admin' => true],
    ['id' => 2, 'name' => 'Петр', 'balance' => 500],
    ['id' => 3, 'name' => 'Евгений', 'balance' => 1100],
    ['id' => 4, 'name' => 'Елизавета', 'balance' => 200],
    ['id' => 5, 'name' => 'Рената', 'balance' => 450],
]);
 
$users->sum('balance');
// 97250
 
/* Найдем баланс пользователей, которые не являются администраторами */
$users->sum(
    fn($item) => ($item['is_admin'] ?? false) === false ? $item['balance'] : 0
);
// 2250

1
2
3
4
5
6
$collection = collect(['id' => 1, 'price' => 100]);
 
$merged = $collection->mergeRecursive(['id' => 2, 'price' => 200, 'discount' => false]);
 
$merged->all();
// ['id' => [1, 2], 'price' => [100, 200], 'discount' => false]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$collection = collect([1, 2, 3, 4]);
 
$replaced = $collection->replace([5, 6, 7, 8]);
$replaced->all();
// [1, 2, 3, 4, 5, 6, 7, 8]
 
$replaced = $collection->replace([1, 2, 3, 4]);
$replaced->all();
// [1, 2, 3, 4]
 
$collection = collect(['id' => 1, 'price' => 100]);
$replaced = $collection->replace(['price' => 200, 'discount' => false]);
$replaced->all();
// ['id' => 1, 'price' => 200, 'discount' => false]

1
2
3
4
5
6
$collection = collect(['id' => 1, 'price' => 100, 'categories' => [1, 2, 3]]);
 
$replaced = $collection->replaceRecursive(['price' => 200, 'discount' => false, 'categories' => [3 => 4]]);
 
$replaced->all();
// ['id' => 1, 'price' => 200, 'discount' => false, 'categories' => [1, 2, 3, 4]]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
$users = collect([
    ['id' => 1, 'name' => 'Роман', 'is_admin' => true],
    ['id' => 2, 'name' => 'Борис', 'is_admin' => false],
    ['id' => 3, 'name' => 'Евгений', 'is_admin' => false],
    ['id' => 4, 'name' => 'Ксения', 'is_admin' => true],
    ['id' => 5, 'name' => 'Александр', 'is_admin' => false],
]);
 
/** @var Collection $admins */
/** @var Collection $users */
[$admins, $users] = $users->partition(
    /* ^ можно использовать list() */
    fn($value) => ($value['is_admin'] ?? false) === true
);
 
$admins->all();
/*
[
    ['id' => 1, 'name' => 'Роман', 'is_admin' => true],
    ['id' => 4, 'name' => 'Ксения', 'is_admin' => true],
]
*/
 
$users->all();
/*
[
    ['id' => 2, 'name' => 'Борис', 'is_admin' => false],
    ['id' => 3, 'name' => 'Евгений', 'is_admin' => false],
    ['id' => 5, 'name' => 'Александр', 'is_admin' => false],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$collection = collect([1, 2, 3, 4, 5]);
 
/** @var Collection $piped */
$piped = $collection->pipe(function (Collection $collection) {
    if ($collection->sum() < 10) {
        Log::debug('Сумма коллекции меньше 10, возвращаем исходную коллекцию.');
 
        return $collection;
    }
 
    Log::debug('Сумма коллекции больше или равно 10, возвращаем перевернутую коллекцию.');
 
    return $collection->reverse();
});
 
$piped->all();
// [5, 4, 3, 2, 1]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
$products = collect([
    ['name' => 'Стул', 'colors' => ['Чёрный', 'Коричневый']],
    ['name' => 'Стол', 'colors' => ['Чёрный']],
    ['name' => 'Шкаф', 'colors' => ['Белый', 'Чёрный', 'Коричневый']],
]);
 
/* Отсортируем по количеству доступных цветов */
 
// Запишем анонимную функцию в переменную (для удобства демонстрации примера)
$sortByColorsCallback = fn($product, $key) => count($product['colors']);
 
$products->sortBy($sortByColorsCallback)->values()->all();
/*
[
    ['name' => 'Стол', 'colors' => ['Чёрный']],
    ['name' => 'Стул', 'colors' => ['Чёрный', 'Коричневый']],
    ['name' => 'Шкаф', 'colors' => ['Белый', 'Чёрный', 'Коричневый']],
]
*/
 
/* Тоже самое, только в обратном порядке */
$products->sortByDesc($sortByColorsCallback)->values()->all();
/*
[
    ['name' => 'Шкаф', 'colors' => ['Белый', 'Чёрный', 'Коричневый']],
    ['name' => 'Стул', 'colors' => ['Чёрный', 'Коричневый']],
    ['name' => 'Стол', 'colors' => ['Чёрный']],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
$users = collect([
    ['id' => 1, 'name' => 'Вениамин', 'born_at' => 1987],
    ['id' => 2, 'name' => 'Петр', 'born_at' => 1993],
    ['id' => 3, 'name' => 'Елена', 'born_at' => 1995],
    ['id' => 4, 'name' => 'Игорь', 'born_at' => 1996],
    ['id' => 5, 'name' => 'Ксения', 'born_at' => 1999],
    ['id' => 6, 'name' => 'Ирина', 'born_at' => 2003],
    ['id' => 7, 'name' => 'Екатерина', 'born_at' => 2003],
    ['id' => 8, 'name' => 'Алексей', 'born_at' => 2006],
]);
 
/* Оставим только тех, кто родился в 20 веке */
$adultUsers = $users->takeUntil(
    fn($value) => $value['born_at'] >= 2000
);
 
$adultUsers->all();
/*
[
    ['id' => 1, 'name' => 'Вениамин', 'born_at' => 1987],
    ['id' => 2, 'name' => 'Петр', 'born_at' => 1993],
    ['id' => 3, 'name' => 'Елена', 'born_at' => 1995],
    ['id' => 4, 'name' => 'Игорь', 'born_at' => 1996],
    ['id' => 5, 'name' => 'Ксения', 'born_at' => 1999],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
$users = collect([
    ['id' => 1, 'name' => 'Вениамин', 'born_at' => 1987],
    ['id' => 2, 'name' => 'Петр', 'born_at' => 1993],
    ['id' => 3, 'name' => 'Елена', 'born_at' => 1995],
    ['id' => 4, 'name' => 'Игорь', 'born_at' => 1996],
    ['id' => 5, 'name' => 'Ксения', 'born_at' => 1999],
    ['id' => 6, 'name' => 'Ирина', 'born_at' => 2003],
    ['id' => 7, 'name' => 'Екатерина', 'born_at' => 2003],
    ['id' => 8, 'name' => 'Алексей', 'born_at' => 2006],
]);
 
/* Оставим только тех, кто родился в 20 веке */
$minorUsers = $users->takeWhile(
    fn($value) => $value['born_at'] < 2000
);
 
$minorUsers->all();
/*
[
    ['id' => 1, 'name' => 'Вениамин', 'born_at' => 1987],
    ['id' => 2, 'name' => 'Петр', 'born_at' => 1993],
    ['id' => 3, 'name' => 'Елена', 'born_at' => 1995],
    ['id' => 4, 'name' => 'Игорь', 'born_at' => 1996],
    ['id' => 5, 'name' => 'Ксения', 'born_at' => 1999],
]
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
$users = collect([
    ['id' => 1, 'name' => 'Вениамин', 'born_at' => 1987],
    ['id' => 2, 'name' => 'Петр', 'born_at' => 1993],
    ['id' => 3, 'name' => 'Елена', 'born_at' => 1995],
    ['id' => 4, 'name' => 'Игорь', 'born_at' => 1996],
    ['id' => 5, 'name' => 'Ксения', 'born_at' => 1999],
    ['id' => 6, 'name' => 'Ирина', 'born_at' => 2003],
    ['id' => 7, 'name' => 'Екатерина', 'born_at' => 2003],
    ['id' => 8, 'name' => 'Алексей', 'born_at' => 2006],
]);
 
/* Оставим только тех, кто родился в 21 веке */
$minorUsers = $users->skipUntil(
    fn($value) => $value['born_at'] >= 2000
);
 
$minorUsers->all();
/*
[
    ['id' => 6, 'name' => 'Ирина', 'born_at' => 2003],
    ['id' => 7, 'name' => 'Екатерина', 'born_at' => 2003],
    ['id' => 8, 'name' => 'Алексей', 'born_at' => 2006],
]
*/