Laravel - Collections

Вступление

Класс обеспечивает свободно, удобную оболочку для работы с массивами данных. Например, проверьте следующий код. Мы будем использовать помощник, чтобы создать новый экземпляр коллекции из массива, запустить функцию для каждого элемента, а затем удалить все пустые элементы:Illuminate\Support\Collectioncollectstrtoupper

$collection = collect(['taylor', 'abigail', null])->map(function ($name) {
    return strtoupper($name);
})
->reject(function ($name) {
    return empty($name);
});

Как вы можете видеть, Collectionкласс позволяет вам связывать свои методы для быстрого отображения и уменьшения базового массива. В общем, коллекции являются неизменяемыми, то есть каждый Collectionметод возвращает совершенно новый Collectionэкземпляр.

 

Создание коллекций

Как упоминалось выше, collectпомощник возвращает новый экземпляр для данного массива. Итак, создать коллекцию так же просто, как:Illuminate\Support\Collection

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

Результаты Eloquent запросов всегда возвращаются в качестве Collectionэкземпляров.

 

Расширение коллекций

Коллекции являются «макрореализуемыми», что позволяет добавлять дополнительные методы в Collectionкласс во время выполнения. Например, следующий код добавляет toUpperметод в Collectionкласс:

use Illuminate\Support\Str;

Collection::macro('toUpper', function () {
    return $this->map(function ($value) {
        return Str::upper($value);
    });
});

$collection = collect(['first', 'second']);

$upper = $collection->toUpper();

// ['FIRST', 'SECOND']

Как правило, вы должны объявить макросы коллекции у поставщика услуг .

 

Доступные методы

В оставшейся части этой документации мы обсудим каждый метод, доступный в Collectionклассе. Помните, что все эти методы могут быть объединены в цепочку, чтобы свободно управлять базовым массивом. Кроме того, почти каждый метод возвращает новый Collectionэкземпляр, что позволяет вам сохранять исходную копию коллекции при необходимости:

• all
• average
• avg
• chunk
• collapse
• combine
• concat
• contains
• containsStrict
• count
• countBy
• crossJoin
• dd
• diff
• diffAssoc
• diffKeys
• dump
• duplicates
• each
• eachSpread
• every
• except
• filter
• first
• firstWhere
• flatMap
• flatten
• flip
• forget
• forPage
• get
• groupBy
• has
• implode
• intersect
• intersectByKeys
• isEmpty
• isNotEmpty
• join
• keyBy
• keys
• last
• macro
• make
• map
• mapInto
• mapSpread
• mapToGroups
• mapWithKeys
• max
• median
• merge
• min
• mode
• nth
• only
• pad
• partition
• pipe
• pluck
• pop
• prepend
• pull
• push
• put
• random
• reduce
• reject
• reverse
• search
• shift
• shuffle
• slice
• some
• sort
• sortBy
• sortByDesc
• sortKeys
• sortKeysDesc
• splice
• split
• sum
• take
• tap
• times
• toArray
• toJson
• transform
• union
• unique
• uniqueStrict
• unless
• unlessEmpty
• unlessNotEmpty
• unwrap
• values
• when
• whenEmpty
• whenNotEmpty
• where
• whereStrict
• whereBetween
• whereIn
• whereInStrict
• whereInstanceOf
• whereNotBetween
• whereNotIn
• whereNotInStrict
• wrap
• zip

 

Список методов

all()

allМетод возвращает базовый массив , представленные коллекции:

collect([1, 2, 3])->all();

// [1, 2, 3]

 

average()

Псевдоним для avgметода.

 

avg()

avgМетод возвращает среднее значение данного ключа:

$average = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->avg('foo');

// 20

$average = collect([1, 1, 2, 4])->avg();

// 2

 

chunk()

chunkМетод разбивает коллекцию в нескольких меньших коллекции определенного размера:

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

$chunks = $collection->chunk(4);

$chunks->toArray();

// [[1, 2, 3, 4], [5, 6, 7]]

Этот метод особенно полезен в представлениях при работе с сеткой, такой как Bootstrap . Представьте, что у вас есть коллекция моделей Eloquent, которую вы хотите отобразить в сетке:

@foreach ($products->chunk(3) as $chunk)
    <div class="row">
        @foreach ($chunk as $product)
            <div class="col-xs-4">{{ $product->name }}</div>
        @endforeach
    </div>
@endforeach

 

collapse()

collapseМетод разрушается коллекцию массивов в единую плоскую коллекцию:

$collection = collect([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);

$collapsed = $collection->collapse();

$collapsed->all();

// [1, 2, 3, 4, 5, 6, 7, 8, 9]

 

combine()

combineМетод сочетает значения коллекции, в качестве ключей, со значениями другого массива или коллекции:

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

$combined = $collection->combine(['George', 29]);

$combined->all();

// ['name' => 'George', 'age' => 29]

 

concat()

concatМетод добавляет данные arrayили сбор значений на конец коллекции:

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

$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);

$concatenated->all();

// ['John Doe', 'Jane Doe', 'Johnny Doe']

 

contains()

containsМетод определяет , содержит ли коллекция данный пункт:

$collection = collect(['name' => 'Desk', 'price' => 100]);

$collection->contains('Desk');

// true

$collection->contains('New York');

// false

Вы также можете передать пару ключ / значение containsметоду, который определит, существует ли данная пара в коллекции:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
]);

$collection->contains('product', 'Bookcase');

// false

Наконец, вы можете также передать обратный вызов containsметоду, чтобы выполнить свой собственный тест на истинность:

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

$collection->contains(function ($value, $key) {
    return $value > 5;
});

// false

containsМетод использует «свободное» сравнение значений при проверке записи, то есть строка с целочисленным значением будет считаться равными целым числом одного и тем же значением. Используйте containsStrictметод для фильтрации с использованием «строгих» сравнений.

containsStrict()

Этот метод имеет ту же сигнатуру, что и containsметод; однако все значения сравниваются с использованием «строгих» сравнений.

count()

countМетод возвращает общее количество элементов в коллекции:

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

$collection->count();

// 4

 

countBy()

countByМетод подсчитывает число вхождений значений в коллекции. По умолчанию метод подсчитывает вхождения каждого элемента:

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

$counted = $collection->countBy();

$counted->all();

// [1 => 1, 2 => 3, 3 => 1]

Однако вы передаете countByметод обратного вызова для подсчета всех элементов по пользовательскому значению:

$collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);

$counted = $collection->countBy(function ($email) {
    return substr(strrchr($email, "@"), 1);
});

$counted->all();

// ['gmail.com' => 2, 'yahoo.com' => 1]

 

crossJoin()

crossJoinКрест метода соединяет ценность коллекции среди указанных массивов или коллекций, возвращая декартово произведение всех возможных перестановок:

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

$matrix = $collection->crossJoin(['a', 'b']);

$matrix->all();

/*
    [
        [1, 'a'],
        [1, 'b'],
        [2, 'a'],
        [2, 'b'],
    ]
*/

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

$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);

$matrix->all();

/*
    [
        [1, 'a', 'I'],
        [1, 'a', 'II'],
        [1, 'b', 'I'],
        [1, 'b', 'II'],
        [2, 'a', 'I'],
        [2, 'a', 'II'],
        [2, 'b', 'I'],
        [2, 'b', 'II'],
    ]
*/

 

dd()

ddМетод свалки предметов в коллекции и заканчивается выполнение сценария:

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

$collection->dd();

/*
    Collection {
        #items: array:2 [
            0 => "John Doe"
            1 => "Jane Doe"
        ]
    }
*/

Если вы не хотите останавливать выполнение скрипта, используйте dumpвместо этого метод.

 

diff()

diffМетод сравнивает коллекцию с другой коллекцией или простого PHP arrayна основе его значения. Этот метод возвращает значения в исходной коллекции, которых нет в данной коллекции:

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

$diff = $collection->diff([2, 4, 6, 8]);

$diff->all();

// [1, 3, 5]

 

diffAssoc()

diffAssocМетод сравнивает коллекцию с другой коллекции или простой PHP arrayна основе его ключей и значений. Этот метод вернет пары ключ / значение в исходной коллекции, которых нет в данной коллекции:

$collection = collect([
    'color' => 'orange',
    'type' => 'fruit',
    'remain' => 6
]);

$diff = $collection->diffAssoc([
    'color' => 'yellow',
    'type' => 'fruit',
    'remain' => 3,
    'used' => 6
]);

$diff->all();

// ['color' => 'orange', 'remain' => 6]

 

diffKeys()

diffKeysМетод сравнивает коллекцию с другой коллекцией или простого PHP arrayна основе его ключи. Этот метод вернет пары ключ / значение в исходной коллекции, которых нет в данной коллекции:

$collection = collect([
    'one' => 10,
    'two' => 20,
    'three' => 30,
    'four' => 40,
    'five' => 50,
]);

$diff = $collection->diffKeys([
    'two' => 2,
    'four' => 4,
    'six' => 6,
    'eight' => 8,
]);

$diff->all();

// ['one' => 10, 'three' => 30, 'five' => 50]

 

dump()

dumpМетод свалки предметов в коллекции:

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

$collection->dump();

/*
    Collection {
        #items: array:2 [
            0 => "John Doe"
            1 => "Jane Doe"
        ]
    }
*/

Если вы хотите прекратить выполнение сценария после сброса коллекции, используйте ddвместо этого метод.

 

duplicates()

duplicatesметод извлекает и возвращает дублируют значения из коллекции:

$collection = collect(['a', 'b', 'a', 'c', 'b']);

$collection->duplicates();

// [ 2 => 'a', 4 => 'b' ]

 

each()

В eachметоде перебирает элементы в коллекции и передает каждый элемент для обратного вызова:

$collection->each(function ($item, $key) {
    //
});

Если вы хотите прекратить перебирать элементы, вы можете вернуться falseсо своего обратного вызова:

$collection->each(function ($item, $key) {
    if (/* some condition */) {
        return false;
    }
});

 

eachSpread()

В eachSpreadметоде перебирает элементы в коллекции, передавая каждое вложенное значение элемента в данной функции обратного вызова:

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

$collection->eachSpread(function ($name, $age) {
    //
});

Вы можете прекратить перебирать элементы, возвращаясь falseиз обратного вызова:

$collection->eachSpread(function ($name, $age) {
    return false;
});

 

every()

Этот everyметод может использоваться для проверки того, что все элементы коллекции проходят заданный тест на истинность:

collect([1, 2, 3, 4])->every(function ($value, $key) {
    return $value > 2;
});

// false

Если коллекция пуста, everyвернет true:

$collection = collect([]);

$collection->every(function($value, $key) {
    return $value > 2;
});

// true

 

except()

exceptМетод возвращает все элементы коллекции для тех , кто с указанными ключами , за исключением:

$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);

$filtered = $collection->except(['price', 'discount']);

$filtered->all();

// ['product_id' => 1]

Обратное значение exceptсм. Единственный метод.

 

filter()

filterМетод фильтрует коллекцию , используя данную функцию обратного вызова, сохраняя только те элементы , которые проходят тест данной истины:

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

$filtered = $collection->filter(function ($value, $key) {
    return $value > 2;
});

$filtered->all();

// [3, 4]

Если обратный вызов не предоставлен, все записи коллекции, которые эквивалентны, falseбудут удалены:

$collection = collect([1, 2, 3, null, false, '', 0, []]);

$collection->filter()->all();

// [1, 2, 3]

Обратное filterсм. В методе отклонения .

 

first()

firstМетод возвращает первый элемент в сборе , который проходит тест на данную истину:

collect([1, 2, 3, 4])->first(function ($value, $key) {
    return $value > 2;
});

// 3

Вы также можете вызвать firstметод без аргументов, чтобы получить первый элемент в коллекции. Если коллекция пуста, nullвозвращается:

collect([1, 2, 3, 4])->first();

// 1

 

firstWhere()

firstWhereМетод возвращает первый элемент в сборе с парой заданной ключ / значение:

$collection = collect([
    ['name' => 'Regena', 'age' => null],
    ['name' => 'Linda', 'age' => 14],
    ['name' => 'Diego', 'age' => 23],
    ['name' => 'Linda', 'age' => 84],
]);

$collection->firstWhere('name', 'Linda');

// ['name' => 'Linda', 'age' => 14]

Вы также можете вызвать firstWhereметод с оператором:

$collection->firstWhere('age', '>=', 18);

// ['name' => 'Diego', 'age' => 23]

Как и метод where , вы можете передать один аргумент firstWhereметоду. В этом сценарии firstWhereметод вернет первый элемент, в котором значение ключа элемента является «правдивым»:

$collection->firstWhere('age');

// ['name' => 'Linda', 'age' => 14]

 

flatMap()

В flatMapметоде перебирает сбор и передает каждое значение данной функции обратного вызова. Функция обратного вызова может свободно изменять элемент и возвращать его, образуя новую коллекцию измененных элементов. Затем массив выравнивается по уровню:

$collection = collect([
    ['name' => 'Sally'],
    ['school' => 'Arkansas'],
    ['age' => 28]
]);

$flattened = $collection->flatMap(function ($values) {
    return array_map('strtoupper', $values);
});

$flattened->all();

// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];

 

flatten()

flattenМетод сглаживает многомерный коллекцию в одном измерении:

$collection = collect(['name' => 'taylor', 'languages' => ['php', 'javascript']]);

$flattened = $collection->flatten();

$flattened->all();

// ['taylor', 'php', 'javascript'];

При желании вы можете передать функции аргумент «глубина»:

$collection = collect([
    'Apple' => [
        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
    ],
    'Samsung' => [
        ['name' => 'Galaxy S7', 'brand' => 'Samsung']
    ],
]);

$products = $collection->flatten(1);

$products->values()->all();

/*
    [
        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
        ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
    ]
*/

В этом примере вызов flattenбез указания глубины также сгладил бы вложенные массивы, что привело бы к . Предоставление глубины позволяет ограничивать уровни вложенных массивов, которые будут сглаживаться.['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']

 

flip()

flipМетод обменивает ключи в коллекции с соответствующими значениями:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$flipped = $collection->flip();

$flipped->all();

// ['taylor' => 'name', 'laravel' => 'framework']

 

forget()

forgetМетод удаляет элемент из коллекции по ключу:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$collection->forget('name');

$collection->all();

// ['framework' => 'laravel']

В отличие от большинства других методов сбора, forgetне возвращает новую измененную коллекцию; он изменяет коллекцию, к которой он вызывается.

 

forPage()

forPageМетод возвращает новую коллекцию , содержащие элементы , которые будут присутствовать на данный номере страницы. Метод принимает номер страницы в качестве первого аргумента и количество элементов, отображаемых на странице, в качестве второго аргумента:

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);

$chunk = $collection->forPage(2, 3);

$chunk->all();

// [4, 5, 6]

 

get()

getМетод возвращает элемент данного ключа. Если ключ не существует, nullвозвращается:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$value = $collection->get('name');

// taylor

Вы можете при желании передать значение по умолчанию в качестве второго аргумента:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$value = $collection->get('foo', 'default-value');

// default-value

Вы можете даже передать обратный вызов в качестве значения по умолчанию. Результат обратного вызова будет возвращен, если указанный ключ не существует:

$collection->get('email', function () {
    return 'default-value';
});

// default-value

 

groupBy()

В groupByметоде группа предметов в коллекции от данного ключа:

$collection = collect([
    ['account_id' => 'account-x10', 'product' => 'Chair'],
    ['account_id' => 'account-x10', 'product' => 'Bookcase'],
    ['account_id' => 'account-x11', 'product' => 'Desk'],
]);

$grouped = $collection->groupBy('account_id');

$grouped->toArray();

/*
    [
        'account-x10' => [
            ['account_id' => 'account-x10', 'product' => 'Chair'],
            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
        ],
        'account-x11' => [
            ['account_id' => 'account-x11', 'product' => 'Desk'],
        ],
    ]
*/

Вместо передачи строки keyвы можете передать обратный вызов. Обратный вызов должен вернуть значение, которое вы хотите ввести в группу:

$grouped = $collection->groupBy(function ($item, $key) {
    return substr($item['account_id'], -3);
});

$grouped->toArray();

/*
    [
        'x10' => [
            ['account_id' => 'account-x10', 'product' => 'Chair'],
            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
        ],
        'x11' => [
            ['account_id' => 'account-x11', 'product' => 'Desk'],
        ],
    ]
*/

Несколько критериев группировки могут быть переданы в виде массива. Каждый элемент массива будет применен к соответствующему уровню в многомерном массиве:

$data = new Collection([
    10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
    20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
    30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
    40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
]);

$result = $data->groupBy([
    'skill',
    function ($item) {
        return $item['roles'];
    },
], $preserveKeys = true);

/*
[
    1 => [
        'Role_1' => [
            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
        ],
        'Role_2' => [
            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
        ],
        'Role_3' => [
            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
        ],
    ],
    2 => [
        'Role_1' => [
            30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
        ],
        'Role_2' => [
            40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
        ],
    ],
];
*/

 

has()

hasМетод определяет , является ли данный ключ присутствует в коллекции:

$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);

$collection->has('product');

// true

$collection->has(['product', 'amount']);

// true

$collection->has(['amount', 'price']);

// false

 

implode()

implodeМетод объединяет элементы в коллекции. Его аргументы зависят от типа элементов в коллекции. Если коллекция содержит массивы или объекты, вы должны передать ключ атрибутов, которые вы хотите объединить, и строку «склеивания», которую вы хотите поместить между значениями:

$collection = collect([
    ['account_id' => 1, 'product' => 'Desk'],
    ['account_id' => 2, 'product' => 'Chair'],
]);

$collection->implode('product', ', ');

// Desk, Chair

Если коллекция содержит простые строки или числовые значения, передайте методу «клей» в качестве единственного аргумента:

collect([1, 2, 3, 4, 5])->implode('-');

// '1-2-3-4-5'

 

intersect()

intersectМетод удаляет любые значения из исходной коллекции, которые не присутствуют в данной arrayили коллекции. Полученная коллекция сохранит ключи исходной коллекции:

$collection = collect(['Desk', 'Sofa', 'Chair']);

$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);

$intersect->all();

// [0 => 'Desk', 2 => 'Chair']

 

intersectByKeys()

intersectByKeysМетод удаляет любые ключи из оригинальной коллекции, которые не присутствуют в данной arrayили коллекции:

$collection = collect([
    'serial' => 'UX301', 'type' => 'screen', 'year' => 2009
]);

$intersect = $collection->intersectByKeys([
    'reference' => 'UX404', 'type' => 'tab', 'year' => 2011
]);

$intersect->all();

// ['type' => 'screen', 'year' => 2009]

 

isEmpty()

isEmptyМетод возвращает , trueесли коллекция пуста; в противном случае falseвозвращается:

collect([])->isEmpty();

// true

 

isNotEmpty()

isNotEmptyМетод возвращает , trueесли коллекция не пуста; в противном случае falseвозвращается:

collect([])->isNotEmpty();

// false

 

join()

joinМетод соединяет ценность коллекции со строкой:

collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'
collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'
collect(['a', 'b'])->join(', ', ' and '); // 'a and b'
collect(['a'])->join(', ', ' and '); // 'a'
collect([])->join(', ', ' and '); // ''

 

keyBy()

В keyByметоде ключи сборника по данному ключу. Если несколько элементов имеют одинаковый ключ, в новой коллекции появится только последний:

$collection = collect([
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
]);

$keyed = $collection->keyBy('product_id');

$keyed->all();

/*
    [
        'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

Вы также можете передать обратный вызов методу. Обратный вызов должен возвращать значение для ключа коллекции:

$keyed = $collection->keyBy(function ($item) {
    return strtoupper($item['product_id']);
});

$keyed->all();

/*
    [
        'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

 

keys()

keysМетод возвращает все ключи в коллекции:

$collection = collect([
    'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
    'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
]);

$keys = $collection->keys();

$keys->all();

// ['prod-100', 'prod-200']

 

last()

lastМетод возвращает последний элемент в коллекции , которая проходит тест данной истины:

collect([1, 2, 3, 4])->last(function ($value, $key) {
    return $value < 3;
});

// 2

Вы также можете вызвать lastметод без аргументов, чтобы получить последний элемент в коллекции. Если коллекция пуста, nullвозвращается:

collect([1, 2, 3, 4])->last();

// 4

 

macro()

Статический macroметод позволяет добавлять методы в Collectionкласс во время выполнения. Обратитесь к документации по расширению коллекций для получения дополнительной информации.

make()

Статический makeметод создает новый экземпляр коллекции. Смотрите раздел Создание коллекций.

map()

В mapметоде перебирает сбор и передает каждое значение данной функции обратного вызова. Функция обратного вызова может свободно изменять элемент и возвращать его, формируя новую коллекцию измененных элементов:

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

$multiplied = $collection->map(function ($item, $key) {
    return $item * 2;
});

$multiplied->all();

// [2, 4, 6, 8, 10]

Как и большинство других методов коллекции, mapвозвращает новый экземпляр коллекции; он не изменяет коллекцию, к которой он вызывается. Если вы хотите преобразовать оригинальную коллекцию, используйте transformметод.

 

mapInto()

В методе перебирает коллекцию, создавая новый экземпляр данного класса, передавая значение в конструктор:mapInto()

class Currency
{
    /**
     * Create a new currency instance.
     *
     * @param  string  $code
     * @return void
     */
    function __construct(string $code)
    {
        $this->code = $code;
    }
}

$collection = collect(['USD', 'EUR', 'GBP']);

$currencies = $collection->mapInto(Currency::class);

$currencies->all();

// [Currency('USD'), Currency('EUR'), Currency('GBP')]

 

mapSpread()

В mapSpreadметоде перебирает элементы в коллекции, передавая каждое вложенное значение элемента в данной функции обратного вызова. Функция обратного вызова может свободно изменять элемент и возвращать его, формируя новую коллекцию измененных элементов:

$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

$chunks = $collection->chunk(2);

$sequence = $chunks->mapSpread(function ($even, $odd) {
    return $even + $odd;
});

$sequence->all();

// [1, 5, 9, 13, 17]

 

mapToGroups()

В mapToGroupsгруппах метода элементов в коллекции от данной функции обратного вызова. Обратный вызов должен возвращать ассоциативный массив, содержащий одну пару ключ / значение, таким образом формируя новую коллекцию сгруппированных значений:

$collection = collect([
    [
        'name' => 'John Doe',
        'department' => 'Sales',
    ],
    [
        'name' => 'Jane Doe',
        'department' => 'Sales',
    ],
    [
        'name' => 'Johnny Doe',
        'department' => 'Marketing',
    ]
]);

$grouped = $collection->mapToGroups(function ($item, $key) {
    return [$item['department'] => $item['name']];
});

$grouped->toArray();

/*
    [
        'Sales' => ['John Doe', 'Jane Doe'],
        'Marketing' => ['Johnny Doe'],
    ]
*/

$grouped->get('Sales')->all();

// ['John Doe', 'Jane Doe']

 

mapWithKeys()

В mapWithKeysметоде перебирает сбор и передает каждое значение данной функции обратного вызова. Обратный вызов должен возвращать ассоциативный массив, содержащий одну пару ключ / значение:

$collection = collect([
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => 'john@example.com'
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => 'jane@example.com'
    ]
]);

$keyed = $collection->mapWithKeys(function ($item) {
    return [$item['email'] => $item['name']];
});

$keyed->all();

/*
    [
        'john@example.com' => 'John',
        'jane@example.com' => 'Jane',
    ]
*/

 

max()

maxМетод возвращает максимальное значение данного ключа:

$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');

// 20

$max = collect([1, 2, 3, 4, 5])->max();

// 5

 

median()

medianМетод возвращает среднее значение данного ключа:

$median = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->median('foo');

// 15

$median = collect([1, 1, 2, 4])->median();

// 1.5

 

merge()

mergeМетод объединяет данный массив или коллекцию оригинальной коллекции. Если строковый ключ в заданных элементах совпадает со строковым ключом в исходной коллекции, значение заданных элементов перезапишет значение в исходной коллекции:

$collection = collect(['product_id' => 1, 'price' => 100]);

$merged = $collection->merge(['price' => 200, 'discount' => false]);

$merged->all();

// ['product_id' => 1, 'price' => 200, 'discount' => false]

Если ключи заданных элементов являются числовыми, значения будут добавлены в конец коллекции:

$collection = collect(['Desk', 'Chair']);

$merged = $collection->merge(['Bookcase', 'Door']);

$merged->all();

// ['Desk', 'Chair', 'Bookcase', 'Door']

 

min()

minМетод возвращает минимальное значение данного ключа:

$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');

// 10

$min = collect([1, 2, 3, 4, 5])->min();

// 1

 

mode()

modeМетод возвращает значение режима данного ключа:

$mode = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->mode('foo');

// [10]

$mode = collect([1, 1, 2, 4])->mode();

// [1]

 

nth()

nthМетод создает новую коллекцию , состоящую из каждого п-го элемента:

$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);

$collection->nth(4);

// ['a', 'e']

Вы можете при желании передать смещение в качестве второго аргумента:

$collection->nth(4, 1);

// ['b', 'f']

 

only()

onlyМетод возвращает элементы коллекции с заданными ключами:

$collection = collect(['product_id' => 1, 'name' => 'Desk', 'price' => 100, 'discount' => false]);

$filtered = $collection->only(['product_id', 'name']);

$filtered->all();

// ['product_id' => 1, 'name' => 'Desk']

Обратное значение onlyсм. В методе " исключение" .

pad()

padМетод заполняет массив с заданным значением до тех пор , пока массив не достигнет заданного размера. Этот метод ведет себя как PHP-функция array_pad .

Чтобы отступить налево, вы должны указать отрицательный размер. Заполнение не будет происходить, если абсолютное значение заданного размера меньше или равно длине массива:

$collection = collect(['A', 'B', 'C']);

$filtered = $collection->pad(5, 0);

$filtered->all();

// ['A', 'B', 'C', 0, 0]

$filtered = $collection->pad(-5, 0);

$filtered->all();

// [0, 0, 'A', 'B', 'C']

partition()

partitionМетод может быть объединен с listфункцией PHP для отдельных элементов , которые проходят тест на данную истину от тех , которые не:

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

list($underThree, $equalOrAboveThree) = $collection->partition(function ($i) {
    return $i < 3;
});

$underThree->all();

// [1, 2]

$equalOrAboveThree->all();

// [3, 4, 5, 6]

 

pipe()

pipeМетод проходит сбор к данной функции обратного вызова и возвращает результат:

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

$piped = $collection->pipe(function ($collection) {
    return $collection->sum();
});

// 6

 

pluck()

pluckМетод извлекает все значения для данного ключа:

$collection = collect([
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
]);

$plucked = $collection->pluck('name');

$plucked->all();

// ['Desk', 'Chair']

Вы также можете указать, как вы хотите, чтобы полученная коллекция была снабжена ключами:

$plucked = $collection->pluck('name', 'product_id');

$plucked->all();

// ['prod-100' => 'Desk', 'prod-200' => 'Chair']

Если дубликаты ключей существуют, последний соответствующий элемент будет вставлен в собранную коллекцию:

$collection = collect([
    ['brand' => 'Tesla',  'color' => 'red'],
    ['brand' => 'Pagani', 'color' => 'white'],
    ['brand' => 'Tesla',  'color' => 'black'],
    ['brand' => 'Pagani', 'color' => 'orange'],
]);

$plucked = $collection->pluck('color', 'brand');

$plucked->all();

// ['Tesla' => 'black', 'Pagani' => 'orange']

 

pop()

popМетод удаляет и возвращает последний элемент из коллекции:

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

$collection->pop();

// 5

$collection->all();

// [1, 2, 3, 4]

 

prepend()

prependМетод добавляет элемент в начало коллекции:

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

$collection->prepend(0);

$collection->all();

// [0, 1, 2, 3, 4, 5]

Вы также можете передать второй аргумент, чтобы установить ключ предварительно добавленного элемента:

$collection = collect(['one' => 1, 'two' => 2]);

$collection->prepend(0, 'zero');

$collection->all();

// ['zero' => 0, 'one' => 1, 'two' => 2]

 

pull()

pullМетод удаляет и возвращает элемент из коллекции по ключу:

$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);

$collection->pull('name');

// 'Desk'

$collection->all();

// ['product_id' => 'prod-100']

 

push()

pushМетод добавляет элемент в конец коллекции:

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

$collection->push(5);

$collection->all();

// [1, 2, 3, 4, 5]

 

put()

putМетод устанавливает заданный ключ и значение в коллекции:

$collection = collect(['product_id' => 1, 'name' => 'Desk']);

$collection->put('price', 100);

$collection->all();

// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]

 

random()

randomМетод возвращает случайный элемент из коллекции:

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

$collection->random();

// 4 - (retrieved randomly)

При желании вы можете передать целое число, чтобы randomуказать, сколько элементов вы хотите получить случайным образом. Коллекция предметов всегда возвращается, когда явно передается количество предметов, которые вы хотите получить:

$random = $collection->random(3);

$random->all();

// [2, 4, 5] - (retrieved randomly)

Если в коллекции меньше элементов, чем запрошено, метод выдаст InvalidArgumentException.

reduce()

reduceМетод уменьшает коллекцию к одному значению, передавая результат каждой итерации в последующей итерации:

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

$total = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
});

// 6

Значение для $carryпервой итерации равно null; однако вы можете указать его начальное значение, передав второй аргумент reduce:

$collection->reduce(function ($carry, $item) {
    return $carry + $item;
}, 4);

// 10

 

reject()

rejectМетод фильтрует коллекцию , используя данную функцию обратного вызова. Обратный вызов должен вернуться, trueесли элемент должен быть удален из результирующей коллекции:

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

$filtered = $collection->reject(function ($value, $key) {
    return $value > 2;
});

$filtered->all();

// [1, 2]

Обратный rejectметод см. В filter методе.

reverse()

reverseМетод меняет порядок элементов в коллекции, сохраняя оригинальные ключи:

$collection = collect(['a', 'b', 'c', 'd', 'e']);

$reversed = $collection->reverse();

$reversed->all();

/*
    [
        4 => 'e',
        3 => 'd',
        2 => 'c',
        1 => 'b',
        0 => 'a',
    ]
*/

 

search()

searchМетод ищет коллекцию для заданного значения и возвращает ключ , если найдено. Если товар не найден, falseвозвращается.

$collection = collect([2, 4, 6, 8]);

$collection->search(4);

// 1

Поиск выполняется с использованием «свободного» сравнения, то есть строка с целочисленным значением будет считаться равной целому числу того же значения. Чтобы использовать «строгое» сравнение, передайте trueметоду второй аргумент:

$collection->search('4', true);

// false

В качестве альтернативы, вы можете передать свой собственный обратный вызов для поиска первого элемента, прошедшего проверку на истинность:

$collection->search(function ($item, $key) {
    return $item > 5;
});

// 2

 

shift()

shiftМетод удаляет и возвращает первый элемент из коллекции:

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

$collection->shift();

// 1

$collection->all();

// [2, 3, 4, 5]

 

shuffle()

shuffleМетод случайным образом перемешивает элементы в коллекции:

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

$shuffled = $collection->shuffle();

$shuffled->all();

// [3, 2, 5, 1, 4] - (generated randomly)

 

slice()

sliceМетод возвращает кусочек коллекции , начиная с заданным индексом:

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

$slice = $collection->slice(4);

$slice->all();

// [5, 6, 7, 8, 9, 10]

Если вы хотите ограничить размер возвращаемого фрагмента, передайте метод в качестве второго аргумента:

$slice = $collection->slice(4, 2);

$slice->all();

// [5, 6]

Возвращенный фрагмент сохранит ключи по умолчанию. Если вы не хотите сохранять исходные ключи, вы можете использовать valuesметод для их переиндексации.

some()

Псевдоним для containsметода.

sort()

sortМетод сортирует коллекцию. В отсортированной коллекции сохраняются исходные ключи массива, поэтому в этом примере мы будем использовать valuesметод для сброса ключей в последовательно пронумерованные индексы:

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

$sorted = $collection->sort();

$sorted->values()->all();

// [1, 2, 3, 4, 5]

Если ваши потребности в сортировке более продвинуты, вы можете передать обратный вызов в sortсвой собственный алгоритм. Обратитесь к документации по PHP uasort, что и sortвызывает метод коллекции изнутри.

Если вам нужно отсортировать коллекцию вложенных массивов или объектов, см sortByи sortByDescметоды.

 

sortBy()

sortByМетод сортирует коллекцию с помощью данного ключа. В отсортированной коллекции сохраняются исходные ключи массива, поэтому в этом примере мы будем использовать valuesметод для сброса ключей в последовательно пронумерованные индексы:

$collection = collect([
    ['name' => 'Desk', 'price' => 200],
    ['name' => 'Chair', 'price' => 100],
    ['name' => 'Bookcase', 'price' => 150],
]);

$sorted = $collection->sortBy('price');

$sorted->values()->all();

/*
    [
        ['name' => 'Chair', 'price' => 100],
        ['name' => 'Bookcase', 'price' => 150],
        ['name' => 'Desk', 'price' => 200],
    ]
*/

Вы также можете передать свой собственный обратный вызов, чтобы определить, как сортировать значения коллекции:

$collection = collect([
    ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
    ['name' => 'Chair', 'colors' => ['Black']],
    ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);

$sorted = $collection->sortBy(function ($product, $key) {
    return count($product['colors']);
});

$sorted->values()->all();

/*
    [
        ['name' => 'Chair', 'colors' => ['Black']],
        ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
        ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
    ]
*/

sortByDesc()

Этот метод имеет ту же сигнатуру, что и sortByметод, но сортирует коллекцию в обратном порядке.

sortKeys()

sortKeysМетод сортирует коллекцию с помощью ключей нижележащего ассоциативного массива:

$collection = collect([
    'id' => 22345,
    'first' => 'John',
    'last' => 'Doe',
]);

$sorted = $collection->sortKeys();

$sorted->all();

/*
    [
        'first' => 'John',
        'id' => 22345,
        'last' => 'Doe',
    ]
*/

sortKeysDesc()

Этот метод имеет ту же сигнатуру, что и sortKeysметод, но сортирует коллекцию в обратном порядке.

splice()

spliceМетод удаляет и возвращает срез элементов , начиная с указанным индексом:

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

$chunk = $collection->splice(2);

$chunk->all();

// [3, 4, 5]

$collection->all();

// [1, 2]

Вы можете передать второй аргумент, чтобы ограничить размер получаемого фрагмента:

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

$chunk = $collection->splice(2, 1);

$chunk->all();

// [3]

$collection->all();

// [1, 2, 4, 5]

Кроме того, вы можете передать третий аргумент, содержащий новые элементы, чтобы заменить элементы, удаленные из коллекции:

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

$chunk = $collection->splice(2, 1, [10, 11]);

$chunk->all();

// [3]

$collection->all();

// [1, 2, 10, 11, 4, 5]

 

split()

splitМетод разбивает коллекцию в заданное число групп:

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

$groups = $collection->split(3);

$groups->toArray();

// [[1, 2], [3, 4], [5]]

 

sum()

sumМетод возвращает сумму всех элементов в коллекции:

collect([1, 2, 3, 4, 5])->sum();

// 15

Если коллекция содержит вложенные массивы или объекты, вы должны передать ключ, который будет использоваться для определения суммируемых значений:

$collection = collect([
    ['name' => 'JavaScript: The Good Parts', 'pages' => 176],
    ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
]);

$collection->sum('pages');

// 1272

Кроме того, вы можете передать свой собственный обратный вызов, чтобы определить, какие значения коллекции суммировать:

$collection = collect([
    ['name' => 'Chair', 'colors' => ['Black']],
    ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
    ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);

$collection->sum(function ($product) {
    return count($product['colors']);
});

// 6

 

take()

takeМетод возвращает новую коллекцию с заданным числом элементов:

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

$chunk = $collection->take(3);

$chunk->all();

// [0, 1, 2]

Вы также можете передать отрицательное целое число, чтобы взять указанное количество предметов из конца коллекции:

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

$chunk = $collection->take(-2);

$chunk->all();

// [4, 5]

 

tap()

tapМетод передает коллекцию данной функции обратного вызова, что позволяет «нажать» в коллекции в определенном месте и сделать что - то с деталями, не затрагивая саму коллекцию:

collect([2, 4, 3, 1, 5])
    ->sort()
    ->tap(function ($collection) {
        Log::debug('Values after sorting', $collection->values()->toArray());
    })
    ->shift();

// 1

 

times()

Статический timesметод создает новую коллекцию, вызывая обратный вызов заданное количество раз:

$collection = Collection::times(10, function ($number) {
    return $number * 9;
});

$collection->all();

// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]

Этот метод может быть полезен в сочетании с фабриками для создания моделей Eloquent :

$categories = Collection::times(3, function ($number) {
    return factory(Category::class)->create(['name' => "Category No. $number"]);
});

$categories->all();

/*
    [
        ['id' => 1, 'name' => 'Category #1'],
        ['id' => 2, 'name' => 'Category #2'],
        ['id' => 3, 'name' => 'Category #3'],
    ]
*/

 

toArray()

toArrayМетод преобразует коллекцию в обычный PHP array. Если значения коллекции являются моделями Eloquent , модели также будут преобразованы в массивы:

$collection = collect(['name' => 'Desk', 'price' => 200]);

$collection->toArray();

/*
    [
        ['name' => 'Desk', 'price' => 200],
    ]
*/

toArrayтакже преобразует все вложенные объекты коллекции, которые являются экземплярами, Arrayableв массив. Если вы хотите получить необработанный базовый массив, используйте allвместо этого метод.

toJson()

toJsonМетод преобразует коллекцию в последовательную строку JSON:

$collection = collect(['name' => 'Desk', 'price' => 200]);

$collection->toJson();

// '{"name":"Desk", "price":200}'

 

transform()

В transformметоде перебирает сбор и вызывает данную функцию обратного вызова с каждым элементом коллекции. Элементы в коллекции будут заменены значениями, возвращаемыми обратным вызовом:

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

$collection->transform(function ($item, $key) {
    return $item * 2;
});

$collection->all();

// [2, 4, 6, 8, 10]

В отличие от большинства других методов сбора, transformизменяет саму коллекцию. Если вы хотите создать новую коллекцию, используйте mapметод.

union()

unionМетод добавляет указанный массив в коллекцию. Если данный массив содержит ключи, которые уже находятся в исходной коллекции, предпочтительными будут значения исходной коллекции:

$collection = collect([1 => ['a'], 2 => ['b']]);

$union = $collection->union([3 => ['c'], 1 => ['b']]);

$union->all();

// [1 => ['a'], 2 => ['b'], 3 => ['c']]

unique()

uniqueМетод возвращает все уникальные предметы в коллекции. В возвращенной коллекции хранятся исходные ключи массива, поэтому в этом примере мы будем использовать valuesметод для сброса ключей в последовательно пронумерованные индексы:

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

$unique = $collection->unique();

$unique->values()->all();

// [1, 2, 3, 4]

При работе с вложенными массивами или объектами вы можете указать ключ, используемый для определения уникальности:

$collection = collect([
    ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
    ['name' => 'iPhone 5', 'brand' => 'Apple', 'type' => 'phone'],
    ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
    ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
    ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
]);

$unique = $collection->unique('brand');

$unique->values()->all();

/*
    [
        ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
        ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
    ]
*/

Вы также можете передать свой собственный обратный вызов, чтобы определить уникальность предмета:

$unique = $collection->unique(function ($item) {
    return $item['brand'].$item['type'];
});

$unique->values()->all();

/*
    [
        ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
        ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
        ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
        ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
    ]
*/

uniqueМетод использует «свободное» сравнение значений при проверке записи, то есть строка с целочисленным значением будет считаться равными целым числом одного и тем же значением. Используйте uniqueStrictметод для фильтрации с использованием «строгих» сравнений.

uniqueStrict()

Этот метод имеет ту же сигнатуру, что и uniqueметод; однако все значения сравниваются с использованием «строгих» сравнений.

unless()

unlessМетод будет выполнять данную функцию обратного вызова , если первый аргумент , который передается методу не имеет значение true:

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

$collection->unless(true, function ($collection) {
    return $collection->push(4);
});

$collection->unless(false, function ($collection) {
    return $collection->push(5);
});

$collection->all();

// [1, 2, 3, 5]

Обратное unlessсм. В whenметоде.

unlessEmpty()

Псевдоним для whenNotEmptyметода.

unlessNotEmpty()

Псевдоним для whenEmptyметода.

unwrap()

Статический unwrapметод возвращает базовые элементы коллекции из заданного значения, когда это применимо:

Collection::unwrap(collect('John Doe'));

// ['John Doe']

Collection::unwrap(['John Doe']);

// ['John Doe']

Collection::unwrap('John Doe');

// 'John Doe'

 

values()

valuesМетод возвращает новая коллекция с ключами , чтобы сбросить последовательные целые числа:

$collection = collect([
    10 => ['product' => 'Desk', 'price' => 200],
    11 => ['product' => 'Desk', 'price' => 200]
]);

$values = $collection->values();

$values->all();

/*
    [
        0 => ['product' => 'Desk', 'price' => 200],
        1 => ['product' => 'Desk', 'price' => 200],
    ]
*/

 

when()

whenМетод будет выполнять данную функцию обратного вызова , когда первый аргумент , который передается методу оценивается как true:

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

$collection->when(true, function ($collection) {
    return $collection->push(4);
});

$collection->when(false, function ($collection) {
    return $collection->push(5);
});

$collection->all();

// [1, 2, 3, 4]

Обратное whenсм. В unlessметоде.

whenEmpty()

whenEmptyМетод будет выполнять данную функцию обратного вызова , когда коллекция пуста:

$collection = collect(['michael', 'tom']);

$collection->whenEmpty(function ($collection) {
    return $collection->push('adam');
});

$collection->all();

// ['michael', 'tom']

$collection = collect();

$collection->whenEmpty(function ($collection) {
    return $collection->push('adam');
});

$collection->all();

// ['adam']

$collection = collect(['michael', 'tom']);

$collection->whenEmpty(function($collection) {
    return $collection->push('adam');
}, function($collection) {
    return $collection->push('taylor');
});

$collection->all();

// ['michael', 'tom', 'taylor']

Обратное whenEmptyсм. В whenNotEmptyметоде.

whenNotEmpty()

whenNotEmptyМетод будет выполнять данную функцию обратного вызова , когда коллекция не пуста:

$collection = collect(['michael', 'tom']);

$collection->whenNotEmpty(function ($collection) {
    return $collection->push('adam');
});

$collection->all();

// ['michael', 'tom', 'adam']

$collection = collect();

$collection->whenNotEmpty(function ($collection) {
    return $collection->push('adam');
});

$collection->all();

// []

$collection = collect();

$collection->whenNotEmpty(function($collection) {
    return $collection->push('adam');
}, function($collection) {
    return $collection->push('taylor');
});

$collection->all();

// ['taylor']

Обратное whenNotEmptyсм. В whenEmptyметоде.

where()

whereМетод фильтрует коллекцию с помощью пары заданного ключа / значения:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
    ['product' => 'Bookcase', 'price' => 150],
    ['product' => 'Door', 'price' => 100],
]);

$filtered = $collection->where('price', 100);

$filtered->all();

/*
    [
        ['product' => 'Chair', 'price' => 100],
        ['product' => 'Door', 'price' => 100],
    ]
*/

whereМетод использует «свободное» сравнение значений при проверке записи, то есть строка с целочисленным значением будет считаться равными целым числом одного и тем же значением. Используйте whereStrictметод для фильтрации с использованием «строгих» сравнений.

whereStrict()

Этот метод имеет ту же сигнатуру, что и whereметод; однако все значения сравниваются с использованием «строгих» сравнений.

 

whereBetween()

whereBetweenМетод фильтры сбора в пределах заданного диапазона:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 80],
    ['product' => 'Bookcase', 'price' => 150],
    ['product' => 'Pencil', 'price' => 30],
    ['product' => 'Door', 'price' => 100],
]);

$filtered = $collection->whereBetween('price', [100, 200]);

$filtered->all();

/*
    [
        ['product' => 'Desk', 'price' => 200],
        ['product' => 'Bookcase', 'price' => 150],
        ['product' => 'Door', 'price' => 100],
    ]
*/

 

whereIn()

whereInМетод фильтрует коллекцию с помощью заданного ключа / значения , содержащегося в данном массиве:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
    ['product' => 'Bookcase', 'price' => 150],
    ['product' => 'Door', 'price' => 100],
]);

$filtered = $collection->whereIn('price', [150, 200]);

$filtered->all();

/*
    [
        ['product' => 'Bookcase', 'price' => 150],
        ['product' => 'Desk', 'price' => 200],
    ]
*/

whereInМетод использует «свободное» сравнение значений при проверке записи, то есть строка с целочисленным значением будет считаться равными целым числом одного и тем же значением. Используйте whereInStrictметод для фильтрации с использованием «строгих» сравнений.

whereInStrict()

Этот метод имеет ту же сигнатуру, что и whereInметод; однако все значения сравниваются с использованием «строгих» сравнений.

whereInstanceOf()

whereInstanceOfМетод фильтрует коллекцию с помощью данного типа класса:

$collection = collect([
    new User,
    new User,
    new Post,
]);

return $collection->whereInstanceOf(User::class);

whereNotBetween()

whereNotBetweenМетод фильтры сбора в пределах заданного диапазона:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 80],
    ['product' => 'Bookcase', 'price' => 150],
    ['product' => 'Pencil', 'price' => 30],
    ['product' => 'Door', 'price' => 100],
]);

$filtered = $collection->whereNotBetween('price', [100, 200]);

$filtered->all();

/*
    [
        ['product' => 'Chair', 'price' => 80],
        ['product' => 'Pencil', 'price' => 30],
    ]
*/

whereNotIn()

whereNotInМетод фильтрует коллекцию с помощью заданного ключа / значения не содержится в пределах данного массива:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
    ['product' => 'Bookcase', 'price' => 150],
    ['product' => 'Door', 'price' => 100],
]);

$filtered = $collection->whereNotIn('price', [150, 200]);

$filtered->all();

/*
    [
        ['product' => 'Chair', 'price' => 100],
        ['product' => 'Door', 'price' => 100],
    ]
*/

whereNotInМетод использует «свободное» сравнение значений при проверке записи, то есть строка с целочисленным значением будет считаться равными целым числом одного и тем же значением. Используйте whereNotInStrictметод для фильтрации с использованием «строгих» сравнений.

whereNotInStrict()

Этот метод имеет ту же сигнатуру, что и whereNotInметод; однако все значения сравниваются с использованием «строгих» сравнений.

wrap()

Статический wrapметод упаковывает данное значение в коллекцию, когда это применимо:

$collection = Collection::wrap('John Doe');

$collection->all();

// ['John Doe']

$collection = Collection::wrap(['John Doe']);

$collection->all();

// ['John Doe']

$collection = Collection::wrap(collect('John Doe'));

$collection->all();

// ['John Doe']

zip()

zipМетод сливается воедино значение данного массива со значениями исходной коллекции на соответствующем индексе:

$collection = collect(['Chair', 'Desk']);

$zipped = $collection->zip([100, 200]);

$zipped->all();

// [['Chair', 100], ['Desk', 200]]

 

Сообщения высшего порядка

Коллекции также обеспечивают поддержку «сообщений более высокого порядка», которые являются ярлыками для выполнения общих действий над коллекциями. Методы сбора , которые обеспечивают сообщения высшего порядка являются: 

average, avg, contains, each, every, filter, first, flatMap, groupBy, keyBy, map, max, min, 

partition, reject, some, sortBy, sortByDesc, sum, и unique.

Каждое сообщение более высокого порядка может быть доступно как динамическое свойство в экземпляре коллекции. Например, давайте использовать eachсообщение более высокого порядка для вызова метода для каждого объекта в коллекции:

$users = User::where('votes', '>', 500)->get();

$users->each->markAsVip();

Аналогично, мы можем использовать sumсообщение более высокого порядка, чтобы собрать общее количество «голосов» для группы пользователей:

$users = User::where('group', 'Development')->get();

return $users->sum->votes;