From 6a8a28547a2456118f5577aa8eb066474a8889db Mon Sep 17 00:00:00 2001 From: ReWiG Date: Tue, 8 Jul 2025 17:59:57 +0300 Subject: [PATCH] Update collections.md --- collections.md | 4176 +++++++++++++++++++++++++++--------------------- 1 file changed, 2348 insertions(+), 1828 deletions(-) diff --git a/collections.md b/collections.md index 6a03d66c..231077d8 100644 --- a/collections.md +++ b/collections.md @@ -1,5 +1,5 @@ --- -git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 +git: 013514ac88989dc577ee6bef4776849db35be151 --- # Коллекции @@ -9,11 +9,13 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Класс `Illuminate\Support\Collection` обеспечивает гибкую и удобную обертку для работы с массивами данных. Например, посмотрите на следующий код. Здесь мы будем использовать хелпер `collect`, чтобы создать новый экземпляр коллекции из массива, запустим функцию `strtoupper` для каждого элемента, а затем удалим все пустые элементы: - $collection = collect(['taylor', 'abigail', null])->map(function (?string $name) { - return strtoupper($name); - })->reject(function (string $name) { - return empty($name); - }); +```php +$collection = collect(['taylor', 'abigail', null])->map(function (?string $name) { + return strtoupper($name); +})->reject(function (string $name) { + return empty($name); +}); +``` Как видите, класс `Collection` позволяет объединять необходимые вам методы в цепочку для выполнения последовательного перебора и сокращения базового массива. В основном коллекции неизменяемы, то есть каждый метод коллекции возвращает совершенно новый экземпляр `Collection`. @@ -22,7 +24,11 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Как упоминалось выше, помощник `collect` возвращает новый экземпляр `Illuminate\Support\Collection` для переданного массива. Итак, создать коллекцию очень просто: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); +``` + +Вы также можете создать коллекцию, используя методы [make](#method-make) и [fromJson](#method-fromjson). > [!NOTE] > Результаты запросов [Eloquent](/docs/{{version}}/eloquent) всегда возвращаются как экземпляры `Collection`. @@ -32,20 +38,22 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Класс `Collection` являются «макропрограммируемым», что позволяет вам добавлять дополнительные методы к классу во время выполнения. Метод `macro` класса `Illuminate\Support\Collection` принимает функцию, которая будет выполнена при вызове вашего макроса. Эта функция может обращаться к другим методам коллекции через `$this`, как если бы это был реальный метод класса коллекции. Например, следующий код добавляет метод `toUpper` классу `Collection`: - use Illuminate\Support\Collection; - use Illuminate\Support\Str; +```php +use Illuminate\Support\Collection; +use Illuminate\Support\Str; - Collection::macro('toUpper', function () { - return $this->map(function (string $value) { - return Str::upper($value); - }); +Collection::macro('toUpper', function () { + return $this->map(function (string $value) { + return Str::upper($value); }); +}); - $collection = collect(['first', 'second']); +$collection = collect(['first', 'second']); - $upper = $collection->toUpper(); +$upper = $collection->toUpper(); - // ['FIRST', 'SECOND'] +// ['FIRST', 'SECOND'] +``` Обычно макросы коллекций объявляются в методе `boot` [сервис-провайдера](/docs/{{version}}/providers). @@ -54,18 +62,20 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 При необходимости вы можете определить макросы, которые принимают дополнительные аргументы: - use Illuminate\Support\Collection; - use Illuminate\Support\Facades\Lang; +```php +use Illuminate\Support\Collection; +use Illuminate\Support\Facades\Lang; - Collection::macro('toLocale', function (string $locale) { - return $this->map(function (string $value) use ($locale) { - return Lang::get($value, [], $locale); - }); +Collection::macro('toLocale', function (string $locale) { + return $this->map(function (string $value) use ($locale) { + return Lang::get($value, [], $locale); }); +}); - $collection = collect(['first', 'second']); +$collection = collect(['first', 'second']); - $translated = $collection->toLocale('es'); +$translated = $collection->toLocale('es'); +``` ## Доступные методы @@ -75,154 +85,158 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2
-- [`after`](#method-after) -- [`all()`](#method-all) -- [`average()`](#method-average) -- [`avg()`](#method-avg) -- [`before`](#method-before) -- [`chunk()`](#method-chunk) -- [`chunkWhile()`](#method-chunkwhile) -- [`collapse()`](#method-collapse) -- [`collect()`](#method-collect) -- [`combine()`](#method-combine) -- [`concat()`](#method-concat) -- [`contains()`](#method-contains) -- [`containsOneItem()`](#method-containsoneitem) -- [`containsStrict()`](#method-containsstrict) -- [`count()`](#method-count) -- [`countBy()`](#method-countBy) -- [`crossJoin()`](#method-crossjoin) -- [`dd()`](#method-dd) -- [`diff()`](#method-diff) -- [`diffAssoc()`](#method-diffassoc) -- [`diffAssocUsing()`](#method-diffassocusing) -- [`diffKeys()`](#method-diffkeys) -- [`doesntContain`](#method-doesntcontain) -- [`dot()`](#method-dot) -- [`dump()`](#method-dump) -- [`duplicates()`](#method-duplicates) -- [`duplicatesStrict()`](#method-duplicatesstrict) -- [`each()`](#method-each) -- [`eachSpread()`](#method-eachspread) -- [`ensure()`](#method-ensure) -- [`every()`](#method-every) -- [`except()`](#method-except) -- [`filter()`](#method-filter) -- [`first()`](#method-first) -- [`firstOrFail()`](#method-first-or-fail) -- [`firstWhere()`](#method-firstwhere) -- [`flatMap()`](#method-flatmap) -- [`flatten()`](#method-flatten) -- [`flip()`](#method-flip) -- [`forget()`](#method-forget) -- [`forPage()`](#method-forpage) -- [`get()`](#method-get) -- [`groupBy()`](#method-groupby) -- [`has()`](#method-has) -- [`hasAny()`](#method-hasany) -- [`implode()`](#method-implode) -- [`intersect()`](#method-intersect) -- [`intersectAssoc()`](#method-intersectAssoc) -- [`intersectByKeys()`](#method-intersectbykeys) -- [`isEmpty()`](#method-isempty) -- [`isNotEmpty()`](#method-isnotempty) -- [`join()`](#method-join) -- [`keyBy()`](#method-keyby) -- [`keys()`](#method-keys) -- [`last()`](#method-last) -- [`lazy()`](#method-lazy) -- [`macro()`](#method-macro) -- [`make()`](#method-make) -- [`map()`](#method-map) -- [`mapInto()`](#method-mapinto) -- [`mapSpread()`](#method-mapspread) -- [`mapToGroups()`](#method-maptogroups) -- [`mapWithKeys()`](#method-mapwithkeys) -- [`max()`](#method-max) -- [`median()`](#method-median) -- [`merge()`](#method-merge) -- [`mergeRecursive()`](#method-mergerecursive) -- [`min()`](#method-min) -- [`mode()`](#method-mode) -- [`multiply`](#method-multiply) -- [`nth()`](#method-nth) -- [`only()`](#method-only) -- [`pad()`](#method-pad) -- [`partition()`](#method-partition) -- [`percentage()`](#method-percentage) -- [`pipe()`](#method-pipe) -- [`pipeInto()`](#method-pipeinto) -- [`pipeThrough()`](#method-pipethrough) -- [`pluck()`](#method-pluck) -- [`pop()`](#method-pop) -- [`prepend()`](#method-prepend) -- [`pull()`](#method-pull) -- [`push()`](#method-push) -- [`put()`](#method-put) -- [`random()`](#method-random) -- [`range`](#method-range) -- [`reduce()`](#method-reduce) -- [`reduceSpread`](#method-reduce-spread) -- [`reject()`](#method-reject) -- [`replace()`](#method-replace) -- [`replaceRecursive()`](#method-replacerecursive) -- [`reverse()`](#method-reverse) -- [`search()`](#method-search) +- [after](#method-after) +- [all](#method-all) +- [average](#method-average) +- [avg](#method-avg) +- [before](#method-before) +- [chunk](#method-chunk) +- [chunkWhile](#method-chunkwhile) +- [collapse](#method-collapse) +- [collapseWithKeys](#method-collapsewithkeys) +- [collect](#method-collect) +- [combine](#method-combine) +- [concat](#method-concat) +- [contains](#method-contains) +- [containsOneItem](#method-containsoneitem) +- [containsStrict](#method-containsstrict) +- [count](#method-count) +- [countBy](#method-countBy) +- [crossJoin](#method-crossjoin) +- [dd](#method-dd) +- [diff](#method-diff) +- [diffAssoc](#method-diffassoc) +- [diffAssocUsing](#method-diffassocusing) +- [diffKeys](#method-diffkeys) +- [doesntContain](#method-doesntcontain) +- [dot](#method-dot) +- [dump](#method-dump) +- [duplicates](#method-duplicates) +- [duplicatesStrict](#method-duplicatesstrict) +- [each](#method-each) +- [eachSpread](#method-eachspread) +- [ensure](#method-ensure) +- [every](#method-every) +- [except](#method-except) +- [filter](#method-filter) +- [first](#method-first) +- [firstOrFail](#method-first-or-fail) +- [firstWhere](#method-firstwhere) +- [flatMap](#method-flatmap) +- [flatten](#method-flatten) +- [flip](#method-flip) +- [forget](#method-forget) +- [forPage](#method-forpage) +- [fromJson](#method-fromjson) +- [get](#method-get) +- [groupBy](#method-groupby) +- [has](#method-has) +- [hasAny](#method-hasany) +- [implode](#method-implode) +- [intersect](#method-intersect) +- [intersectUsing](#method-intersectusing) +- [intersectAssoc](#method-intersectAssoc) +- [intersectAssocUsing](#method-intersectassocusing) +- [intersectByKeys](#method-intersectbykeys) +- [isEmpty](#method-isempty) +- [isNotEmpty](#method-isnotempty) +- [join](#method-join) +- [keyBy](#method-keyby) +- [keys](#method-keys) +- [last](#method-last) +- [lazy](#method-lazy) +- [macro](#method-macro) +- [make](#method-make) +- [map](#method-map) +- [mapInto](#method-mapinto) +- [mapSpread](#method-mapspread) +- [mapToGroups](#method-maptogroups) +- [mapWithKeys](#method-mapwithkeys) +- [max](#method-max) +- [median](#method-median) +- [merge](#method-merge) +- [mergeRecursive](#method-mergerecursive) +- [min](#method-min) +- [mode](#method-mode) +- [multiply](#method-multiply) +- [nth](#method-nth) +- [only](#method-only) +- [pad](#method-pad) +- [partition](#method-partition) +- [percentage](#method-percentage) +- [pipe](#method-pipe) +- [pipeInto](#method-pipeinto) +- [pipeThrough](#method-pipethrough) +- [pluck](#method-pluck) +- [pop](#method-pop) +- [prepend](#method-prepend) +- [pull](#method-pull) +- [push](#method-push) +- [put](#method-put) +- [random](#method-random) +- [range](#method-range) +- [reduce](#method-reduce) +- [reduceSpread](#method-reduce-spread) +- [reject](#method-reject) +- [replace](#method-replace) +- [replaceRecursive](#method-replacerecursive) +- [reverse](#method-reverse) +- [search](#method-search) - [select](#method-select) -- [`shift()`](#method-shift) -- [`shuffle()`](#method-shuffle) -- [`skip()`](#method-skip) -- [`skipUntil()`](#method-skipuntil) -- [`skipWhile()`](#method-skipwhile) -- [`slice()`](#method-slice) -- [`sliding`](#method-sliding) -- [`sole`](#method-sole) -- [`some()`](#method-some) -- [`sort()`](#method-sort) -- [`sortBy()`](#method-sortby) -- [`sortByDesc()`](#method-sortbydesc) -- [`sortDesc()`](#method-sortdesc) -- [`sortKeys()`](#method-sortkeys) -- [`sortKeysDesc()`](#method-sortkeysdesc) -- [`sortKeysUsing()`](#method-sortkeysusing) -- [`splice()`](#method-splice) -- [`split()`](#method-split) -- [`splitIn()`](#method-splitin) -- [`sum()`](#method-sum) -- [`take()`](#method-take) -- [`takeUntil()`](#method-takeuntil) -- [`takeWhile()`](#method-takewhile) -- [`tap()`](#method-tap) -- [`times()`](#method-times) -- [`toArray()`](#method-toarray) -- [`toJson()`](#method-tojson) -- [`transform()`](#method-transform) -- [`undot()`](#method-undot) -- [`union()`](#method-union) -- [`unique()`](#method-unique) -- [`uniqueStrict()`](#method-uniquestrict) -- [`unless()`](#method-unless) -- [`unlessEmpty()`](#method-unlessempty) -- [`unlessNotEmpty()`](#method-unlessnotempty) -- [`unwrap()`](#method-unwrap) -- [`value()`](#method-value) -- [`values()`](#method-values) -- [`when()`](#method-when) -- [`whenEmpty()`](#method-whenempty) -- [`whenNotEmpty()`](#method-whennotempty) -- [`where()`](#method-where) -- [`whereStrict()`](#method-wherestrict) -- [`whereBetween()`](#method-wherebetween) -- [`whereIn()`](#method-wherein) -- [`whereInStrict()`](#method-whereinstrict) -- [`whereInstanceOf()`](#method-whereinstanceof) -- [`whereNotBetween()`](#method-wherenotbetween) -- [`whereNotIn()`](#method-wherenotin) -- [`whereNotInStrict()`](#method-wherenotinstrict) -- [`whereNotNull()`](#method-wherenotnull) -- [`whereNull()`](#method-wherenull) -- [`wrap()`](#method-wrap) -- [`zip()`](#method-zip) +- [shift](#method-shift) +- [shuffle](#method-shuffle) +- [skip](#method-skip) +- [skipUntil](#method-skipuntil) +- [skipWhile](#method-skipwhile) +- [slice](#method-slice) +- [sliding](#method-sliding) +- [sole](#method-sole) +- [some](#method-some) +- [sort](#method-sort) +- [sortBy](#method-sortby) +- [sortByDesc](#method-sortbydesc) +- [sortDesc](#method-sortdesc) +- [sortKeys](#method-sortkeys) +- [sortKeysDesc](#method-sortkeysdesc) +- [sortKeysUsing](#method-sortkeysusing) +- [splice](#method-splice) +- [split](#method-split) +- [splitIn](#method-splitin) +- [sum](#method-sum) +- [take](#method-take) +- [takeUntil](#method-takeuntil) +- [takeWhile](#method-takewhile) +- [tap](#method-tap) +- [times](#method-times) +- [toArray](#method-toarray) +- [toJson](#method-tojson) +- [transform](#method-transform) +- [undot](#method-undot) +- [union](#method-union) +- [unique](#method-unique) +- [uniqueStrict](#method-uniquestrict) +- [unless](#method-unless) +- [unlessEmpty](#method-unlessempty) +- [unlessNotEmpty](#method-unlessnotempty) +- [unwrap](#method-unwrap) +- [value](#method-value) +- [values](#method-values) +- [when](#method-when) +- [whenEmpty](#method-whenempty) +- [whenNotEmpty](#method-whennotempty) +- [where](#method-where) +- [whereStrict](#method-wherestrict) +- [whereBetween](#method-wherebetween) +- [whereIn](#method-wherein) +- [whereInStrict](#method-whereinstrict) +- [whereInstanceOf](#method-whereinstanceof) +- [whereNotBetween](#method-wherenotbetween) +- [whereNotIn](#method-wherenotin) +- [whereNotInStrict](#method-wherenotinstrict) +- [whereNotNull](#method-wherenotnull) +- [whereNull](#method-wherenull) +- [wrap](#method-wrap) +- [zip](#method-zip)
@@ -234,99 +248,113 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `after` возвращает элемент после данного элемента. `null` возвращается, если данный элемент не найден или является последним элементом: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->after(3); +$collection->after(3); - // 4 +// 4 - $collection->after(5); +$collection->after(5); - // null +// null +``` Этот метод ищет данный элемент, используя «свободное» сравнение, то есть строка, содержащая целочисленное значение, будет считаться равной целому числу того же значения. Чтобы использовать «строгое» сравнение, вы можете предоставить методу аргумент `strict`: - collect([2, 4, 6, 8])->after('4', strict: true); +```php +collect([2, 4, 6, 8])->after('4', strict: true); - // null +// null +``` В качестве альтернативы вы можете предоставить собственное замыкание для поиска первого элемента, который проходит заданный тест на истинность: - collect([2, 4, 6, 8])->after(function (int $item, int $key) { - return $item > 5; - }); +```php +collect([2, 4, 6, 8])->after(function (int $item, int $key) { + return $item > 5; +}); - // 8 +// 8 +``` #### `all()` Метод `all` возвращает базовый массив, представленный коллекцией: - collect([1, 2, 3])->all(); +```php +collect([1, 2, 3])->all(); - // [1, 2, 3] +// [1, 2, 3] +``` #### `average()` -Псевдоним для метода [`avg`](#method-avg). +Псевдоним для метода [avg](#method-avg). #### `avg()` Метод `avg` возвращает [среднее значение](https://en.wikipedia.org/wiki/Average) переданного ключа: - $average = collect([ - ['foo' => 10], - ['foo' => 10], - ['foo' => 20], - ['foo' => 40] - ])->avg('foo'); +```php +$average = collect([ + ['foo' => 10], + ['foo' => 10], + ['foo' => 20], + ['foo' => 40] +])->avg('foo'); - // 20 +// 20 - $average = collect([1, 1, 2, 4])->avg(); +$average = collect([1, 1, 2, 4])->avg(); - // 2 +// 2 +``` #### `before()` -Метод `before` является противоположностью метода [`after`](#method-after). Он возвращает элемент перед данным элементом. `null` возвращается, если данный элемент не найден или является первым элементом: +Метод `before` является противоположностью метода [after](#method-after). Он возвращает элемент перед данным элементом. `null` возвращается, если данный элемент не найден или является первым элементом: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->before(3); +$collection->before(3); - // 2 +// 2 - $collection->before(1); +$collection->before(1); - // null +// null - collect([2, 4, 6, 8])->before('4', strict: true); +collect([2, 4, 6, 8])->before('4', strict: true); - // null +// null - collect([2, 4, 6, 8])->before(function (int $item, int $key) { - return $item > 5; - }); +collect([2, 4, 6, 8])->before(function (int $item, int $key) { + return $item > 5; +}); - // 4 +// 4 +``` #### `chunk()` Метод `chunk` разбивает коллекцию на несколько меньших коллекций указанного размера: - $collection = collect([1, 2, 3, 4, 5, 6, 7]); +```php +$collection = collect([1, 2, 3, 4, 5, 6, 7]); - $chunks = $collection->chunk(4); +$chunks = $collection->chunk(4); - $chunks->all(); +$chunks->all(); - // [[1, 2, 3, 4], [5, 6, 7]] +// [[1, 2, 3, 4], [5, 6, 7]] +``` Этот метод особенно полезен в [шаблонах](/docs/{{version}}/views) при работе с сеткой, такой как [Bootstrap](https://getbootstrap.com/docs/5.3/layout/grid/). Например, представьте, что у вас есть коллекция моделей [Eloquent](/docs/{{version}}/eloquent), которые вы хотите отобразить в сетке: @@ -345,63 +373,94 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `chunkWhile` разбивает коллекцию на несколько меньших по размеру коллекций на основе результата переданного замыкания. Переменная `$chunk`, переданная в замыкание, может использоваться для проверки предыдущего элемента: - $collection = collect(str_split('AABBCCCD')); +```php +$collection = collect(str_split('AABBCCCD')); - $chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) { - return $value === $chunk->last(); - }); +$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) { + return $value === $chunk->last(); +}); - $chunks->all(); +$chunks->all(); - // [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']] +// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']] +``` #### `collapse()` -Метод `collapse` сворачивает коллекцию массивов в единую плоскую коллекцию: +Метод `collapse` сворачивает коллекцию массивов или коллекций в единую плоскую коллекцию: + +```php +$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] +``` + + +#### `collapseWithKeys()` + +Метод `collapseWithKeys` сглаживает коллекцию массивов или коллекций в одну коллекцию, сохраняя исходные ключи нетронутыми. Если коллекция уже плоская, он вернет пустую коллекцию: - $collection = collect([ - [1, 2, 3], - [4, 5, 6], - [7, 8, 9], - ]); +```php +$collection = collect([ + ['first' => collect([1, 2, 3])], + ['second' => [4, 5, 6]], + ['third' => collect([7, 8, 9])] +]); - $collapsed = $collection->collapse(); +$collapsed = $collection->collapseWithKeys(); - $collapsed->all(); +$collapsed->all(); - // [1, 2, 3, 4, 5, 6, 7, 8, 9] +// [ +// 'first' => [1, 2, 3], +// 'second' => [4, 5, 6], +// 'third' => [7, 8, 9], +// ] +``` #### `collect()` Метод `collect` возвращает новый экземпляр `Collection` с элементами, находящимися в текущей коллекции: - $collectionA = collect([1, 2, 3]); +```php +$collectionA = collect([1, 2, 3]); - $collectionB = $collectionA->collect(); +$collectionB = $collectionA->collect(); - $collectionB->all(); +$collectionB->all(); - // [1, 2, 3] +// [1, 2, 3] +``` Метод `collect` в первую очередь полезен для преобразования [отложенных коллекций](#lazy-collections) в стандартные экземпляры `Collection`: - $lazyCollection = LazyCollection::make(function () { - yield 1; - yield 2; - yield 3; - }); +```php +$lazyCollection = LazyCollection::make(function () { + yield 1; + yield 2; + yield 3; +}); - $collection = $lazyCollection->collect(); +$collection = $lazyCollection->collect(); - $collection::class; +$collection::class; - // 'Illuminate\Support\Collection' +// 'Illuminate\Support\Collection' - $collection->all(); +$collection->all(); - // [1, 2, 3] +// [1, 2, 3] +``` > [!NOTE] > Метод `collect` особенно полезен, когда у вас есть экземпляр `Enumerable` и вам нужен «не-отложенный» экземпляр коллекции. Так как `collect()` является частью контракта `Enumerable`, вы можете безопасно использовать его для получения экземпляра `Collection`. @@ -411,26 +470,30 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `combine` объединяет значения коллекции в качестве ключей со значениями другого массива или коллекции: - $collection = collect(['name', 'age']); +```php +$collection = collect(['name', 'age']); - $combined = $collection->combine(['George', 29]); +$combined = $collection->combine(['George', 29]); - $combined->all(); +$combined->all(); - // ['name' => 'George', 'age' => 29] +// ['name' => 'George', 'age' => 29] +``` #### `concat()` Метод `concat` добавляет значения переданного массива или коллекции в конец другой коллекции: - $collection = collect(['John Doe']); +```php +$collection = collect(['John Doe']); - $concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']); +$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']); - $concatenated->all(); +$concatenated->all(); - // ['John Doe', 'Jane Doe', 'Johnny Doe'] +// ['John Doe', 'Jane Doe', 'Johnny Doe'] +``` Метод `concat` численно переиндексирует ключи для элементов, добавленных к исходной коллекции. Чтобы сохранить ключи в ассоциативных коллекциях, см. метод [merge](#method-merge). @@ -439,62 +502,74 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `contains` определяет, содержит ли коллекция данный элемент. Вы можете передать в `contains` функцию, чтобы определить, существует ли в коллекции элемент, соответствующий указанному критерию истинности: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->contains(function (int $value, int $key) { - return $value > 5; - }); +$collection->contains(function (int $value, int $key) { + return $value > 5; +}); - // false +// false +``` Вы также можете передать строку методу `contains`, чтобы определить, содержит ли коллекция указанное значение элемента: - $collection = collect(['name' => 'Desk', 'price' => 100]); +```php +$collection = collect(['name' => 'Desk', 'price' => 100]); - $collection->contains('Desk'); +$collection->contains('Desk'); - // true +// true - $collection->contains('New York'); +$collection->contains('New York'); - // false +// false +``` Вы также можете передать пару ключ / значение методу `contains`, который определит, существует ли данная пара в коллекции: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Chair', 'price' => 100], - ]); +```php +$collection = collect([ + ['product' => 'Desk', 'price' => 200], + ['product' => 'Chair', 'price' => 100], +]); - $collection->contains('product', 'Bookcase'); +$collection->contains('product', 'Bookcase'); - // false +// false +``` -Метод `contains` использует «гибкое» сравнение при проверке значений элементов, то есть строка с целочисленным значением будет считаться равной целому числу того же значения. Используйте метод [`containsStrict`](#method-containsstrict) для фильтрации с использованием «жесткого» сравнения. +Метод `contains` использует «гибкое» сравнение при проверке значений элементов, то есть строка с целочисленным значением будет считаться равной целому числу того же значения. Используйте метод [containsStrict](#method-containsstrict) для фильтрации с использованием «жесткого» сравнения. -Противоположным для метода `contains`, является метод [`doesntContain`](#method-doesntcontain). +Противоположным для метода `contains`, является метод [doesntContain](#method-doesntcontain). #### `containsOneItem()` Метод `containsOneItem` определяет, содержит ли коллекция только один элемент: - collect([])->containsOneItem(); +```php +collect([])->containsOneItem(); + +// false - // false +collect(['1'])->containsOneItem(); - collect(['1'])->containsOneItem(); +// true - // true +collect(['1', '2'])->containsOneItem(); - collect(['1', '2'])->containsOneItem(); +// false - // false +collect([1, 2, 3])->containsOneItem(fn (int $item) => $item === 2); + +// true +``` #### `containsStrict()` -Этот метод имеет ту же сигнатуру, что и метод [`contains`](#method-contains); однако, все значения сравниваются с использованием «жесткого» сравнения. +Этот метод имеет ту же сигнатуру, что и метод [contains](#method-contains); однако, все значения сравниваются с использованием «жесткого» сравнения. > [!NOTE] > Поведение этого метода изменяется при использовании [коллекций Eloquent](/docs/{{version}}/eloquent-collections#method-contains). @@ -504,108 +579,120 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `count` возвращает общее количество элементов в коллекции: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $collection->count(); +$collection->count(); - // 4 +// 4 +``` #### `countBy()` Метод `countBy` подсчитывает вхождения значений в коллекцию. По умолчанию метод подсчитывает вхождения каждого элемента, что позволяет подсчитать определенные «типы» элементов в коллекции: - $collection = collect([1, 2, 2, 2, 3]); +```php +$collection = collect([1, 2, 2, 2, 3]); - $counted = $collection->countBy(); +$counted = $collection->countBy(); - $counted->all(); +$counted->all(); - // [1 => 1, 2 => 3, 3 => 1] +// [1 => 1, 2 => 3, 3 => 1] +``` Вы можете передать замыкание методу `countBy` для подсчета всех элементов по собственным критериям: - $collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']); +```php +$collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']); - $counted = $collection->countBy(function (string $email) { - return substr(strrchr($email, "@"), 1); - }); +$counted = $collection->countBy(function (string $email) { + return substr(strrchr($email, "@"), 1); +}); - $counted->all(); +$counted->all(); - // ['gmail.com' => 2, 'yahoo.com' => 1] +// ['gmail.com' => 2, 'yahoo.com' => 1] +``` #### `crossJoin()` Метод `crossJoin` перекрестно соединяет значения коллекции среди переданных массивов или коллекций, возвращая декартово произведение со всеми возможными перестановками: - $collection = collect([1, 2]); +```php +$collection = collect([1, 2]); - $matrix = $collection->crossJoin(['a', 'b']); +$matrix = $collection->crossJoin(['a', 'b']); - $matrix->all(); +$matrix->all(); - /* - [ - [1, 'a'], - [1, 'b'], - [2, 'a'], - [2, 'b'], - ] - */ +/* + [ + [1, 'a'], + [1, 'b'], + [2, 'a'], + [2, 'b'], + ] +*/ - $collection = collect([1, 2]); +$collection = collect([1, 2]); - $matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']); +$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']); - $matrix->all(); +$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'], - ] - */ +/* + [ + [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']); +```php +$collection = collect(['John Doe', 'Jane Doe']); - $collection->dd(); +$collection->dd(); - /* - Collection { - #items: array:2 [ - 0 => "John Doe" - 1 => "Jane Doe" - ] - } - */ +/* + Collection { + #items: array:2 [ + 0 => "John Doe" + 1 => "Jane Doe" + ] + } +*/ +``` -Если вы не хотите останавливать выполнение вашего скрипта, используйте вместо этого метод [`dump`](#method-dump). +Если вы не хотите останавливать выполнение вашего скрипта, используйте вместо этого метод [dump](#method-dump). #### `diff()` Метод `diff` сравнивает коллекцию с другой коллекцией или простым массивом PHP на основе его значений. Этот метод вернет значения из исходной коллекции, которых нет в переданной коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $diff = $collection->diff([2, 4, 6, 8]); +$diff = $collection->diff([2, 4, 6, 8]); - $diff->all(); +$diff->all(); - // [1, 3, 5] +// [1, 3, 5] +``` > [!NOTE] > Поведение этого метода изменяется при использовании [коллекций Eloquent](/docs/{{version}}/eloquent-collections#method-diff). @@ -615,105 +702,117 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `diffAssoc` сравнивает коллекцию с другой коллекцией или простым массивом PHP на основе его ключей и значений. Этот метод вернет пары ключ / значение из исходной коллекции, которых нет в переданной коллекции: - $collection = collect([ - 'color' => 'orange', - 'type' => 'fruit', - 'remain' => 6, - ]); +```php +$collection = collect([ + 'color' => 'orange', + 'type' => 'fruit', + 'remain' => 6, +]); - $diff = $collection->diffAssoc([ - 'color' => 'yellow', - 'type' => 'fruit', - 'remain' => 3, - 'used' => 6, - ]); +$diff = $collection->diffAssoc([ + 'color' => 'yellow', + 'type' => 'fruit', + 'remain' => 3, + 'used' => 6, +]); - $diff->all(); +$diff->all(); - // ['color' => 'orange', 'remain' => 6] +// ['color' => 'orange', 'remain' => 6] +``` #### `diffAssocUsing()` В отличие от `diffAssoc`, `diffAssocUsing` принимает пользовательскую функцию обратного вызова для сравнения индексов: - $collection = collect([ - 'color' => 'orange', - 'type' => 'fruit', - 'remain' => 6, - ]); +```php +$collection = collect([ + 'color' => 'orange', + 'type' => 'fruit', + 'remain' => 6, +]); - $diff = $collection->diffAssocUsing([ - 'Color' => 'yellow', - 'Type' => 'fruit', - 'Remain' => 3, - ], 'strnatcasecmp'); +$diff = $collection->diffAssocUsing([ + 'Color' => 'yellow', + 'Type' => 'fruit', + 'Remain' => 3, +], 'strnatcasecmp'); - $diff->all(); +$diff->all(); - // ['color' => 'orange', 'remain' => 6] +// ['color' => 'orange', 'remain' => 6] +``` -Обратный вызов должен быть функцией сравнения, которая возвращает целое число меньше, равное или больше нуля. Дополнительную информацию можно найти в документации PHP по array_diff_uassoc, функции PHP, которую внутренне использует метод diffAssocUsing. +Обратный вызов должен быть функцией сравнения, которая возвращает целое число меньше, равное или больше нуля. Дополнительную информацию можно найти в документации PHP по [array_diff_uassoc](https://www.php.net/array_diff_uassoc#refsect1-function.array-diff-uassoc-parameters), функции PHP, которую внутренне использует метод diffAssocUsing. #### `diffKeys()` Метод `diffKeys` сравнивает коллекцию с другой коллекцией или простым массивом PHP на основе его ключей. Этот метод вернет пары ключ / значение из исходной коллекции, которых нет в переданной коллекции: - $collection = collect([ - 'one' => 10, - 'two' => 20, - 'three' => 30, - 'four' => 40, - 'five' => 50, - ]); +```php +$collection = collect([ + 'one' => 10, + 'two' => 20, + 'three' => 30, + 'four' => 40, + 'five' => 50, +]); - $diff = $collection->diffKeys([ - 'two' => 2, - 'four' => 4, - 'six' => 6, - 'eight' => 8, - ]); +$diff = $collection->diffKeys([ + 'two' => 2, + 'four' => 4, + 'six' => 6, + 'eight' => 8, +]); - $diff->all(); +$diff->all(); - // ['one' => 10, 'three' => 30, 'five' => 50] +// ['one' => 10, 'three' => 30, 'five' => 50] +``` #### `doesntContain()` Метод `doesntContain` определяет, не содержит ли коллекция данный элемент. Вы можете передать замыкание методу `doesntContain`, чтобы определить, не существует ли элемента в коллекции, соответствующего заданному критерию: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->doesntContain(function (int $value, int $key) { - return $value < 5; - }); +$collection->doesntContain(function (int $value, int $key) { + return $value < 5; +}); - // false +// false +``` В качестве альтернативы вы можете передать строку методу `doesntContain`, чтобы определить, не содержит ли коллекция заданного значения элемента: - $collection = collect(['name' => 'Desk', 'price' => 100]); +```php +$collection = collect(['name' => 'Desk', 'price' => 100]); - $collection->doesntContain('Table'); +$collection->doesntContain('Table'); - // true +// true - $collection->doesntContain('Desk'); +$collection->doesntContain('Desk'); - // false +// false +``` Вы также можете передать пару ключ/значение методу `doesntContain`, который определит, не существует ли данная пара в коллекции: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Chair', 'price' => 100], - ]); +```php +$collection = collect([ + ['product' => 'Desk', 'price' => 200], + ['product' => 'Chair', 'price' => 100], +]); - $collection->doesntContain('product', 'Bookcase'); +$collection->doesntContain('product', 'Bookcase'); - // true +// true +``` Метод `doesntContain` использует "не строгое" сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. @@ -722,110 +821,130 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `dot` сглаживает многомерную коллекцию в коллекцию одного уровня, используя "точечную" нотацию для указания глубины: - $collection = collect(['products' => ['desk' => ['price' => 100]]]); +```php +$collection = collect(['products' => ['desk' => ['price' => 100]]]); - $flattened = $collection->dot(); +$flattened = $collection->dot(); - $flattened->all(); +$flattened->all(); - // ['products.desk.price' => 100] +// ['products.desk.price' => 100] +``` #### `dump()` Метод `dump` выводит элементы коллекции: - $collection = collect(['John Doe', 'Jane Doe']); +```php +$collection = collect(['John Doe', 'Jane Doe']); - $collection->dump(); +$collection->dump(); - /* - Collection { - #items: array:2 [ - 0 => "John Doe" - 1 => "Jane Doe" - ] - } - */ +/* + Collection { + #items: array:2 [ + 0 => "John Doe" + 1 => "Jane Doe" + ] + } +*/ +``` -Если вы хотите прекратить выполнение скрипта после вывода элементов коллекции, используйте вместо этого метод [`dd`](#method-dd). +Если вы хотите прекратить выполнение скрипта после вывода элементов коллекции, используйте вместо этого метод [dd](#method-dd). #### `duplicates()` Метод `duplicates` извлекает и возвращает повторяющиеся значения из коллекции: - $collection = collect(['a', 'b', 'a', 'c', 'b']); +```php +$collection = collect(['a', 'b', 'a', 'c', 'b']); - $collection->duplicates(); +$collection->duplicates(); - // [2 => 'a', 4 => 'b'] +// [2 => 'a', 4 => 'b'] +``` Если коллекция содержит массивы или объекты, вы можете передать ключ атрибутов, которые вы хотите проверить на наличие повторяющихся значений: - $employees = collect([ - ['email' => 'abigail@example.com', 'position' => 'Developer'], - ['email' => 'james@example.com', 'position' => 'Designer'], - ['email' => 'victoria@example.com', 'position' => 'Developer'], - ]); +```php +$employees = collect([ + ['email' => 'abigail@example.com', 'position' => 'Developer'], + ['email' => 'james@example.com', 'position' => 'Designer'], + ['email' => 'victoria@example.com', 'position' => 'Developer'], +]); - $employees->duplicates('position'); +$employees->duplicates('position'); - // [2 => 'Developer'] +// [2 => 'Developer'] +``` #### `duplicatesStrict()` -Этот метод имеет ту же сигнатуру, что и метод [`duplicates`](#method-duplicates); однако, все значения сравниваются с использованием «жесткого» сравнения. +Этот метод имеет ту же сигнатуру, что и метод [duplicates](#method-duplicates); однако, все значения сравниваются с использованием «жесткого» сравнения. #### `each()` Метод `each` перебирает элементы в коллекции и передает каждый элемент в замыкание: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $collection->each(function (int $item, int $key) { - // ... - }); +$collection->each(function (int $item, int $key) { + // ... +}); +``` Если вы хотите прекратить итерацию по элементам, вы можете вернуть `false` из вашего замыкания: - $collection->each(function (int $item, int $key) { - if (/* условие */) { - return false; - } - }); +```php +$collection->each(function (int $item, int $key) { + if (/* условие */) { + return false; + } +}); +``` #### `eachSpread()` Метод `eachSpread` выполняет итерацию по элементам коллекции, передавая значение каждого вложенного элемента в замыкание: - $collection = collect([['John Doe', 35], ['Jane Doe', 33]]); +```php +$collection = collect([['John Doe', 35], ['Jane Doe', 33]]); - $collection->eachSpread(function (string $name, int $age) { - // ... - }); +$collection->eachSpread(function (string $name, int $age) { + // ... +}); +``` Если вы хотите прекратить итерацию по элементам, вы можете вернуть `false` из вашего замыкания: - $collection->eachSpread(function (string $name, int $age) { - return false; - }); +```php +$collection->eachSpread(function (string $name, int $age) { + return false; +}); +``` #### `ensure()` Метод `ensure` может использоваться для проверки того, что все элементы коллекции имеют определенный тип или список типов. В противном случае будет выброшено исключение `UnexpectedValueException`: - return $collection->ensure(User::class); +```php +return $collection->ensure(User::class); - return $collection->ensure([User::class, Customer::class]); +return $collection->ensure([User::class, Customer::class]); +``` Примитивные типы, такие как `string`, `int`, `float`, `bool` и `array`, также могут быть указаны: - return $collection->ensure('int'); +```php +return $collection->ensure('int'); +``` > [!WARNING] > Метод `ensure` не гарантирует, что элементы разных типов не будут добавлены в коллекцию в будущем. @@ -835,34 +954,40 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `every` используется для проверки того, что все элементы коллекции проходят указанный тест истинности: - collect([1, 2, 3, 4])->every(function (int $value, int $key) { - return $value > 2; - }); +```php +collect([1, 2, 3, 4])->every(function (int $value, int $key) { + return $value > 2; +}); - // false +// false +``` Если коллекция пуста, метод `every` вернет `true`: - $collection = collect([]); +```php +$collection = collect([]); - $collection->every(function (int $value, int $key) { - return $value > 2; - }); +$collection->every(function (int $value, int $key) { + return $value > 2; +}); - // true +// true +``` #### `except()` Метод `except` возвращает все элементы из коллекции, кроме тех, которые имеют указанные ключи: - $collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]); +```php +$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]); - $filtered = $collection->except(['price', 'discount']); +$filtered = $collection->except(['price', 'discount']); - $filtered->all(); +$filtered->all(); - // ['product_id' => 1] +// ['product_id' => 1] +``` Противоположным методу `except` является метод [only](#method-only). @@ -874,23 +999,27 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `filter` фильтрует коллекцию, используя переданное замыкание, сохраняя только те элементы, которые проходят указанный тест истинности: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $filtered = $collection->filter(function (int $value, int $key) { - return $value > 2; - }); +$filtered = $collection->filter(function (int $value, int $key) { + return $value > 2; +}); - $filtered->all(); +$filtered->all(); - // [3, 4] +// [3, 4] +``` Если замыкание не указано, то все записи коллекции, эквивалентные `false`, будут удалены: - $collection = collect([1, 2, 3, null, false, '', 0, []]); +```php +$collection = collect([1, 2, 3, null, false, '', 0, []]); - $collection->filter()->all(); +$collection->filter()->all(); - // [1, 2, 3] +// [1, 2, 3] +``` Противоположным методу `filter` является метод [reject](#method-reject). @@ -899,127 +1028,147 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `first` возвращает первый элемент из коллекции, который проходит указанную проверку истинности: - collect([1, 2, 3, 4])->first(function (int $value, int $key) { - return $value > 2; - }); +```php +collect([1, 2, 3, 4])->first(function (int $value, int $key) { + return $value > 2; +}); - // 3 +// 3 +``` Вы также можете вызвать метод `first` без аргументов, чтобы получить первый элемент из коллекции. Если коллекция пуста, возвращается `null`: - collect([1, 2, 3, 4])->first(); +```php +collect([1, 2, 3, 4])->first(); - // 1 +// 1 +``` #### `firstOrFail()` Метод `firstOrFail` идентичен методу `first`; однако, если результат не найден, будет сгенерировано исключение `Illuminate\Support\ItemNotFoundException`: - collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) { - return $value > 5; - }); +```php +collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) { + return $value > 5; +}); - // Генерирует исключение ItemNotFoundException... +// Генерирует исключение ItemNotFoundException... +``` Вы также можете вызвать метод `firstOrFail` без аргументов, чтобы получить первый элемент в коллекции. Если коллекция пуста, будет сгенерировано исключение `Illuminate\Support\ItemNotFoundException`: - collect([])->firstOrFail(); +```php +collect([])->firstOrFail(); - // Генерирует исключение ItemNotFoundException... +// Генерирует исключение ItemNotFoundException... +``` #### `firstWhere()` Метод `firstWhere` возвращает первый элемент коллекции с переданной парой ключ / значение: - $collection = collect([ - ['name' => 'Regena', 'age' => null], - ['name' => 'Linda', 'age' => 14], - ['name' => 'Diego', 'age' => 23], - ['name' => 'Linda', 'age' => 84], - ]); +```php +$collection = collect([ + ['name' => 'Regena', 'age' => null], + ['name' => 'Linda', 'age' => 14], + ['name' => 'Diego', 'age' => 23], + ['name' => 'Linda', 'age' => 84], +]); - $collection->firstWhere('name', 'Linda'); +$collection->firstWhere('name', 'Linda'); - // ['name' => 'Linda', 'age' => 14] +// ['name' => 'Linda', 'age' => 14] +``` Вы также можете вызвать метод `firstWhere` с оператором сравнения: - $collection->firstWhere('age', '>=', 18); +```php +$collection->firstWhere('age', '>=', 18); - // ['name' => 'Diego', 'age' => 23] +// ['name' => 'Diego', 'age' => 23] +``` Подобно методу [where](#method-where), вы можете передать один аргумент методу `firstWhere`. В этом сценарии метод `firstWhere` вернет первый элемент, для которого значение данного ключа элемента является «истинным»: - $collection->firstWhere('age'); +```php +$collection->firstWhere('age'); - // ['name' => 'Linda', 'age' => 14] +// ['name' => 'Linda', 'age' => 14] +``` #### `flatMap()` Метод `flatMap` выполняет итерацию по коллекции и передает каждое значение переданному замыканию. Замыкание может изменить элемент и вернуть его, таким образом формируя новую коллекцию измененных элементов. Затем массив преобразуется в плоскую структуру: - $collection = collect([ - ['name' => 'Sally'], - ['school' => 'Arkansas'], - ['age' => 28] - ]); +```php +$collection = collect([ + ['name' => 'Sally'], + ['school' => 'Arkansas'], + ['age' => 28] +]); - $flattened = $collection->flatMap(function (array $values) { - return array_map('strtoupper', $values); - }); +$flattened = $collection->flatMap(function (array $values) { + return array_map('strtoupper', $values); +}); - $flattened->all(); +$flattened->all(); - // ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28']; +// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28']; +``` #### `flatten()` Метод `flatten` объединяет многомерную коллекцию в одноуровневую: - $collection = collect([ - 'name' => 'taylor', - 'languages' => [ - 'php', 'javascript' - ] - ]); +```php +$collection = collect([ + 'name' => 'taylor', + 'languages' => [ + 'php', 'javascript' + ] +]); - $flattened = $collection->flatten(); +$flattened = $collection->flatten(); - $flattened->all(); +$flattened->all(); - // ['taylor', 'php', 'javascript']; +// ['taylor', 'php', 'javascript']; +``` Если необходимо, вы можете передать методу `flatten` аргумент «глубины»: - $collection = collect([ - 'Apple' => [ - [ - 'name' => 'iPhone 6S', - 'brand' => 'Apple' - ], +```php +$collection = collect([ + 'Apple' => [ + [ + 'name' => 'iPhone 6S', + 'brand' => 'Apple' ], - 'Samsung' => [ - [ - 'name' => 'Galaxy S7', - 'brand' => 'Samsung' - ], + ], + 'Samsung' => [ + [ + 'name' => 'Galaxy S7', + 'brand' => 'Samsung' ], - ]); + ], +]); - $products = $collection->flatten(1); +$products = $collection->flatten(1); - $products->values()->all(); +$products->values()->all(); - /* - [ - ['name' => 'iPhone 6S', 'brand' => 'Apple'], - ['name' => 'Galaxy S7', 'brand' => 'Samsung'], - ] - */ +/* + [ + ['name' => 'iPhone 6S', 'brand' => 'Apple'], + ['name' => 'Galaxy S7', 'brand' => 'Samsung'], + ] +*/ +``` В этом примере вызов `flatten` без указания глубины также привел бы к сглаживанию вложенных массивов, что привело бы к `['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']`. Предоставление глубины позволяет указать количество уровней, на которые будут сглажены вложенные массивы. @@ -1028,25 +1177,27 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `flip` меняет местами ключи коллекции на их соответствующие значения: - $collection = collect(['name' => 'taylor', 'framework' => 'laravel']); +```php +$collection = collect(['name' => 'Taylor', 'framework' => 'Laravel']); - $flipped = $collection->flip(); +$flipped = $collection->flip(); - $flipped->all(); +$flipped->all(); - // ['taylor' => 'name', 'laravel' => 'framework'] +// ['Taylor' => 'name', 'Laravel' => 'framework'] +``` #### `forget()` Метод `forget` удаляет элемент из коллекции по его ключу: - $collection = collect(['name' => 'taylor', 'framework' => 'laravel']); + $collection = collect(['name' => 'Taylor', 'framework' => 'Laravel']); // Забыть один ключ... $collection->forget('name'); - // ['framework' => 'laravel'] + // ['framework' => 'Laravel'] // Забыть несколько ключей... $collection->forget(['name', 'framework']); @@ -1061,362 +1212,471 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Метод `forPage` возвращает новую коллекцию, содержащую элементы, которые будут присутствовать на указанном номере страницы. Метод принимает номер страницы в качестве первого аргумента и количество элементов, отображаемых на странице, в качестве второго аргумента: - $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]); +```php +$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]); + +$chunk = $collection->forPage(2, 3); + +$chunk->all(); - $chunk = $collection->forPage(2, 3); +// [4, 5, 6] +``` + + +#### `fromJson()` + +Статический метод `fromJson` создает новый экземпляр коллекции путем декодирования заданной строки JSON с помощью функции PHP `json_decode`: + +```php +use Illuminate\Support\Collection; - $chunk->all(); +$json = json_encode([ + 'name' => 'Taylor Otwell', + 'role' => 'Developer', + 'status' => 'Active', +]); - // [4, 5, 6] +$collection = Collection::fromJson($json); +``` #### `get()` Метод `get` возвращает элемент по указанному ключу. Если ключ не существует, возвращается `null`: - $collection = collect(['name' => 'taylor', 'framework' => 'laravel']); +```php +$collection = collect(['name' => 'Taylor', 'framework' => 'Laravel']); - $value = $collection->get('name'); +$value = $collection->get('name'); - // taylor +// Taylor +``` При желании вы можете передать значение по умолчанию в качестве второго аргумента: - $collection = collect(['name' => 'taylor', 'framework' => 'laravel']); +```php +$collection = collect(['name' => 'Taylor', 'framework' => 'Laravel']); - $value = $collection->get('age', 34); +$value = $collection->get('age', 34); - // 34 +// 34 +``` Вы даже можете передать замыкание как значение метода по умолчанию. Результат замыкания будет возвращен, если указанный ключ не существует: - $collection->get('email', function () { - return 'taylor@example.com'; - }); +```php +$collection->get('email', function () { + return 'taylor@example.com'; +}); - // taylor@example.com +// taylor@example.com +``` #### `groupBy()` Метод `groupBy` группирует элементы коллекции по указанному ключу: - $collection = collect([ - ['account_id' => 'account-x10', 'product' => 'Chair'], - ['account_id' => 'account-x10', 'product' => 'Bookcase'], - ['account_id' => 'account-x11', 'product' => 'Desk'], - ]); +```php +$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 = $collection->groupBy('account_id'); - $grouped->all(); +$grouped->all(); - /* - [ - 'account-x10' => [ - ['account_id' => 'account-x10', 'product' => 'Chair'], - ['account_id' => 'account-x10', 'product' => 'Bookcase'], - ], - 'account-x11' => [ - ['account_id' => 'account-x11', 'product' => 'Desk'], - ], - ] - */ +/* + [ + 'account-x10' => [ + ['account_id' => 'account-x10', 'product' => 'Chair'], + ['account_id' => 'account-x10', 'product' => 'Bookcase'], + ], + 'account-x11' => [ + ['account_id' => 'account-x11', 'product' => 'Desk'], + ], + ] +*/ +``` Вместо передачи строкового ключа вы можете передать замыкание. Замыкание должно вернуть значение, используемое в качестве ключа для группировки: - $grouped = $collection->groupBy(function (array $item, int $key) { - return substr($item['account_id'], -3); - }); +```php +$grouped = $collection->groupBy(function (array $item, int $key) { + return substr($item['account_id'], -3); +}); - $grouped->all(); +$grouped->all(); - /* - [ - 'x10' => [ - ['account_id' => 'account-x10', 'product' => 'Chair'], - ['account_id' => 'account-x10', 'product' => 'Bookcase'], - ], - 'x11' => [ - ['account_id' => 'account-x11', 'product' => 'Desk'], - ], - ] - */ +/* + [ + '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']], - ]); +```php +$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 (array $item) { - return $item['roles']; - }], preserveKeys: true); +$result = $data->groupBy(['skill', function (array $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']], - ], +/* +[ + 1 => [ + 'Role_1' => [ + 10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']], + 20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']], ], - 2 => [ - 'Role_1' => [ - 30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']], - ], - 'Role_2' => [ - 40 => ['user' => 4, 'skill' => 2, 'roles' => ['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]); +```php +$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]); - $collection->has('product'); +$collection->has('product'); - // true +// true - $collection->has(['product', 'amount']); +$collection->has(['product', 'amount']); - // true +// true - $collection->has(['amount', 'price']); +$collection->has(['amount', 'price']); - // false +// false +``` #### `hasAny()` Метод `hasAny` определяет, существует ли хотя бы один из заданных ключей в коллекции: - $collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]); +```php +$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]); - $collection->hasAny(['product', 'price']); +$collection->hasAny(['product', 'price']); - // true +// true - $collection->hasAny(['name', 'price']); +$collection->hasAny(['name', 'price']); - // false +// false +``` #### `implode()` Метод `implode` объединяет элементы коллекции. Его аргументы зависят от типа элементов в коллекции. Если коллекция содержит массивы или объекты, вы должны передать ключ объединяемых атрибутов, и «связующую строку», размещаемую между значениями: - $collection = collect([ - ['account_id' => 1, 'product' => 'Desk'], - ['account_id' => 2, 'product' => 'Chair'], - ]); +```php +$collection = collect([ + ['account_id' => 1, 'product' => 'Desk'], + ['account_id' => 2, 'product' => 'Chair'], +]); - $collection->implode('product', ', '); +$collection->implode('product', ', '); - // Desk, Chair +// Desk, Chair +``` Если коллекция содержит простые строки или числовые значения, вы должны передать «связующую строку» как единственный аргумент методу: - collect([1, 2, 3, 4, 5])->implode('-'); +```php +collect([1, 2, 3, 4, 5])->implode('-'); - // '1-2-3-4-5' +// '1-2-3-4-5' +``` Вы можете передать замыкание методу `implode`, если хотите форматировать значения, которые объединяются: - $collection->implode(function (array $item, int $key) { - return strtoupper($item['product']); - }, ', '); +```php +$collection->implode(function (array $item, int $key) { + return strtoupper($item['product']); +}, ', '); - // DESK, CHAIR +// DESK, CHAIR +``` #### `intersect()` Метод `intersect` удаляет любые значения из исходной коллекции, которых нет в указанном массиве или коллекции. Полученная коллекция сохранит ключи исходной коллекции: - $collection = collect(['Desk', 'Sofa', 'Chair']); +```php +$collection = collect(['Desk', 'Sofa', 'Chair']); - $intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']); +$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']); - $intersect->all(); +$intersect->all(); - // [0 => 'Desk', 2 => 'Chair'] +// [0 => 'Desk', 2 => 'Chair'] +``` > [!NOTE] > Поведение этого метода изменяется при использовании [коллекций Eloquent](/docs/{{version}}/eloquent-collections#method-intersect). + +#### `intersectUsing()` + +Метод `intersectUsing` удаляет любые значения из исходной коллекции, которые отсутствуют в заданном массиве или коллекции, используя пользовательский обратный вызов для сравнения значений. Результирующая коллекция сохранит ключи исходной коллекции: + +```php +$collection = collect(['Desk', 'Sofa', 'Chair']); + +$intersect = $collection->intersectUsing(['desk', 'chair', 'bookcase'], function (string $a, string $b) { + return strcasecmp($a, $b); +}); + +$intersect->all(); + +// [0 => 'Desk', 2 => 'Chair'] +``` + #### `intersectAssoc()` -Метод `intersectAssoc` сравнивает исходную коллекцию с другой коллекцией или `array`, возвращая пары ключ / значение, которые присутствуют во всех заданных коллекциях: +Метод `intersectAssoc` сравнивает исходную коллекцию с другой коллекцией или массивом, возвращая пары ключ / значение, которые присутствуют во всех заданных коллекциях: + +```php +$collection = collect([ + 'color' => 'red', + 'size' => 'M', + 'material' => 'cotton' +]); + +$intersect = $collection->intersectAssoc([ + 'color' => 'blue', + 'size' => 'M', + 'material' => 'polyester' +]); + +$intersect->all(); + +// ['size' => 'M'] +``` - $collection = collect([ - 'color' => 'red', - 'size' => 'M', - 'material' => 'cotton' - ]); + +#### `intersectAssocUsing()` + +Метод `intersectAssocUsing` сравнивает исходную коллекцию с другой коллекцией или массивом, возвращая пары ключ/значение, присутствующие в обеих, используя пользовательский обратный вызов сравнения для определения равенства как ключей, так и значений: + +```php +$collection = collect([ + 'color' => 'red', + 'Size' => 'M', + 'material' => 'cotton', +]); - $intersect = $collection->intersectAssoc([ - 'color' => 'blue', - 'size' => 'M', - 'material' => 'polyester' - ]); +$intersect = $collection->intersectAssocUsing([ + 'color' => 'blue', + 'size' => 'M', + 'material' => 'polyester', +], function (string $a, string $b) { + return strcasecmp($a, $b); +}); - $intersect->all(); +$intersect->all(); - // ['size' => 'M'] +// ['Size' => 'M'] +``` #### `intersectByKeys()` Метод `intersectByKeys` удаляет все ключи и соответствующие им значения из исходной коллекции, ключи которых отсутствуют в указанном массиве или коллекции: - $collection = collect([ - 'serial' => 'UX301', 'type' => 'screen', 'year' => 2009, - ]); +```php +$collection = collect([ + 'serial' => 'UX301', 'type' => 'screen', 'year' => 2009, +]); - $intersect = $collection->intersectByKeys([ - 'reference' => 'UX404', 'type' => 'tab', 'year' => 2011, - ]); +$intersect = $collection->intersectByKeys([ + 'reference' => 'UX404', 'type' => 'tab', 'year' => 2011, +]); - $intersect->all(); +$intersect->all(); - // ['type' => 'screen', 'year' => 2009] +// ['type' => 'screen', 'year' => 2009] +``` #### `isEmpty()` Метод `isEmpty` возвращает `true`, если коллекция пуста; в противном случае возвращается `false`: - collect([])->isEmpty(); +```php +collect([])->isEmpty(); - // true +// true +``` #### `isNotEmpty()` Метод `isNotEmpty` возвращает `true`, если коллекция не пуста; в противном случае возвращается `false`: - collect([])->isNotEmpty(); +```php +collect([])->isNotEmpty(); - // false +// 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 '); // '' +```php +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'], - ]); +```php +$collection = collect([ + ['product_id' => 'prod-100', 'name' => 'Desk'], + ['product_id' => 'prod-200', 'name' => 'Chair'], +]); - $keyed = $collection->keyBy('product_id'); +$keyed = $collection->keyBy('product_id'); - $keyed->all(); +$keyed->all(); - /* - [ - 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'], - 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'], - ] - */ +/* + [ + 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'], + 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'], + ] +*/ +``` Вы также можете передать методу замыкание. Замыкание должно возвращать имя для ключа коллекции: - $keyed = $collection->keyBy(function (array $item, int $key) { - return strtoupper($item['product_id']); - }); +```php +$keyed = $collection->keyBy(function (array $item, int $key) { + return strtoupper($item['product_id']); +}); - $keyed->all(); +$keyed->all(); - /* - [ - 'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'], - 'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'], - ] - */ +/* + [ + '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'], - ]); +```php +$collection = collect([ + 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'], + 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'], +]); - $keys = $collection->keys(); +$keys = $collection->keys(); - $keys->all(); +$keys->all(); - // ['prod-100', 'prod-200'] +// ['prod-100', 'prod-200'] +``` #### `last()` Метод `last` возвращает последний элемент в коллекции, который проходит указанную проверку истинности: - collect([1, 2, 3, 4])->last(function (int $value, int $key) { - return $value < 3; - }); +```php +collect([1, 2, 3, 4])->last(function (int $value, int $key) { + return $value < 3; +}); - // 2 +// 2 +``` Вы также можете вызвать метод `last` без аргументов, чтобы получить последний элемент коллекции. Если коллекция пуста, возвращается `null`: - collect([1, 2, 3, 4])->last(); +```php +collect([1, 2, 3, 4])->last(); - // 4 +// 4 +``` #### `lazy()` -Метод `lazy` возвращает новый экземпляр [`LazyCollection`](#lazy-collections) из базового массива элементов: +Метод `lazy` возвращает новый экземпляр [LazyCollection](#lazy-collections) из базового массива элементов: - $lazyCollection = collect([1, 2, 3, 4])->lazy(); +```php +$lazyCollection = collect([1, 2, 3, 4])->lazy(); - $lazyCollection::class; +$lazyCollection::class; - // Illuminate\Support\LazyCollection +// Illuminate\Support\LazyCollection - $lazyCollection->all(); +$lazyCollection->all(); - // [1, 2, 3, 4] +// [1, 2, 3, 4] +``` Это особенно полезно, когда вам нужно выполнять преобразования в огромной `Collection`, содержащей множество элементов: - $count = $hugeCollection - ->lazy() - ->where('country', 'FR') - ->where('balance', '>', '100') - ->count(); +```php +$count = $hugeCollection + ->lazy() + ->where('country', 'FR') + ->where('balance', '>', '100') + ->count(); +``` Преобразовав коллекцию в `LazyCollection`, мы избегаем необходимости выделять огромное количество дополнительной памяти. Хотя исходная коллекция все еще хранит свои значения в памяти, последующие фильтры этого не делают. Таким образом, при фильтрации результатов коллекции практически не выделяется дополнительной памяти. @@ -1430,240 +1690,270 @@ git: 660e0c0b5d1a90c8d7e04b1711032d4499496ee2 Статический метод `make` создает новый экземпляр коллекции. См. раздел [Создание коллекций](#creating-collections). +```php +use Illuminate\Support\Collection; + +$collection = Collection::make([1, 2, 3]); +``` + #### `map()` Метод `map` выполняет итерацию по коллекции и передает каждое значение указанному замыканию. Замыкание может изменить элемент и вернуть его, образуя новую коллекцию измененных элементов: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $multiplied = $collection->map(function (int $item, int $key) { - return $item * 2; - }); +$multiplied = $collection->map(function (int $item, int $key) { + return $item * 2; +}); - $multiplied->all(); +$multiplied->all(); - // [2, 4, 6, 8, 10] +// [2, 4, 6, 8, 10] +``` > [!WARNING] -> Как и большинство других методов коллекции, `map` возвращает новый экземпляр коллекции; он не модифицирует коллекцию. Если вы хотите преобразовать исходную коллекцию, используйте метод [`transform`](#method-transform). +> Как и большинство других методов коллекции, `map` возвращает новый экземпляр коллекции; он не модифицирует коллекцию. Если вы хотите преобразовать исходную коллекцию, используйте метод [transform](#method-transform). #### `mapInto()` Метод `mapInto()` выполняет итерацию коллекции, создавая новый экземпляр указанного класса, и передавая значение в его конструктор: - class Currency - { - /** - * Создать новый экземпляр валюты. - */ - function __construct( - public string $code - ) {} - } +```php +class Currency +{ + /** + * Создать новый экземпляр валюты. + */ + function __construct( + public string $code + ) {} +} - $collection = collect(['USD', 'EUR', 'GBP']); +$collection = collect(['USD', 'EUR', 'GBP']); - $currencies = $collection->mapInto(Currency::class); +$currencies = $collection->mapInto(Currency::class); - $currencies->all(); +$currencies->all(); - // [Currency('USD'), Currency('EUR'), Currency('GBP')] +// [Currency('USD'), Currency('EUR'), Currency('GBP')] +``` #### `mapSpread()` Метод `mapSpread` выполняет итерацию по элементам коллекции, передавая значение каждого вложенного элемента в указанное замыкание. Замыкание может изменить элемент и вернуть его, таким образом формируя новую коллекцию измененных элементов: - $collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); +```php +$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); - $chunks = $collection->chunk(2); +$chunks = $collection->chunk(2); - $sequence = $chunks->mapSpread(function (int $even, int $odd) { - return $even + $odd; - }); +$sequence = $chunks->mapSpread(function (int $even, int $odd) { + return $even + $odd; +}); - $sequence->all(); +$sequence->all(); - // [1, 5, 9, 13, 17] +// [1, 5, 9, 13, 17] +``` #### `mapToGroups()` Метод `mapToGroups` группирует элементы коллекции по указанному замыканию. Замыкание должно возвращать ассоциативный массив, содержащий одну пару ключ / значение, таким образом формируя новую коллекцию сгруппированных значений: - $collection = collect([ - [ - 'name' => 'John Doe', - 'department' => 'Sales', - ], - [ - 'name' => 'Jane Doe', - 'department' => 'Sales', - ], - [ - 'name' => 'Johnny Doe', - 'department' => 'Marketing', - ] - ]); +```php +$collection = collect([ + [ + 'name' => 'John Doe', + 'department' => 'Sales', + ], + [ + 'name' => 'Jane Doe', + 'department' => 'Sales', + ], + [ + 'name' => 'Johnny Doe', + 'department' => 'Marketing', + ] +]); - $grouped = $collection->mapToGroups(function (array $item, int $key) { - return [$item['department'] => $item['name']]; - }); +$grouped = $collection->mapToGroups(function (array $item, int $key) { + return [$item['department'] => $item['name']]; +}); - $grouped->all(); +$grouped->all(); - /* - [ - 'Sales' => ['John Doe', 'Jane Doe'], - 'Marketing' => ['Johnny Doe'], - ] - */ +/* + [ + 'Sales' => ['John Doe', 'Jane Doe'], + 'Marketing' => ['Johnny Doe'], + ] +*/ - $grouped->get('Sales')->all(); +$grouped->get('Sales')->all(); - // ['John Doe', 'Jane Doe'] +// ['John Doe', 'Jane Doe'] +``` #### `mapWithKeys()` Метод `mapWithKeys` выполняет итерацию по коллекции и передает каждое значение в указанное замыкание. Замыкание должно возвращать ассоциативный массив, содержащий одну пару ключ / значение: - $collection = collect([ - [ - 'name' => 'John', - 'department' => 'Sales', - 'email' => 'john@example.com', - ], - [ - 'name' => 'Jane', - 'department' => 'Marketing', - 'email' => 'jane@example.com', - ] - ]); +```php +$collection = collect([ + [ + 'name' => 'John', + 'department' => 'Sales', + 'email' => 'john@example.com', + ], + [ + 'name' => 'Jane', + 'department' => 'Marketing', + 'email' => 'jane@example.com', + ] +]); - $keyed = $collection->mapWithKeys(function (array $item, int $key) { - return [$item['email'] => $item['name']]; - }); +$keyed = $collection->mapWithKeys(function (array $item, int $key) { + return [$item['email'] => $item['name']]; +}); - $keyed->all(); +$keyed->all(); - /* - [ - 'john@example.com' => 'John', - 'jane@example.com' => 'Jane', - ] - */ +/* + [ + 'john@example.com' => 'John', + 'jane@example.com' => 'Jane', + ] +*/ +``` #### `max()` Метод `max` возвращает максимальное значение переданного ключа: - $max = collect([ - ['foo' => 10], - ['foo' => 20] - ])->max('foo'); +```php +$max = collect([ + ['foo' => 10], + ['foo' => 20] +])->max('foo'); - // 20 +// 20 - $max = collect([1, 2, 3, 4, 5])->max(); +$max = collect([1, 2, 3, 4, 5])->max(); - // 5 +// 5 +``` #### `median()` Метод `median` возвращает [медиану](https://en.wikipedia.org/wiki/Median) переданного ключа: - $median = collect([ - ['foo' => 10], - ['foo' => 10], - ['foo' => 20], - ['foo' => 40] - ])->median('foo'); +```php +$median = collect([ + ['foo' => 10], + ['foo' => 10], + ['foo' => 20], + ['foo' => 40] +])->median('foo'); - // 15 +// 15 - $median = collect([1, 1, 2, 4])->median(); +$median = collect([1, 1, 2, 4])->median(); - // 1.5 +// 1.5 +``` #### `merge()` Метод `merge` объединяет переданный массив или коллекцию с исходной коллекцией. Если строковый ключ в переданных элементах соответствует строковому ключу в исходной коллекции, значение переданного элемента перезапишет значение в исходной коллекции: - $collection = collect(['product_id' => 1, 'price' => 100]); +```php +$collection = collect(['product_id' => 1, 'price' => 100]); - $merged = $collection->merge(['price' => 200, 'discount' => false]); +$merged = $collection->merge(['price' => 200, 'discount' => false]); - $merged->all(); +$merged->all(); - // ['product_id' => 1, 'price' => 200, 'discount' => false] +// ['product_id' => 1, 'price' => 200, 'discount' => false] +``` Если ключи переданных элементов являются числовыми, значения будут добавлены в конец коллекции: - $collection = collect(['Desk', 'Chair']); +```php +$collection = collect(['Desk', 'Chair']); - $merged = $collection->merge(['Bookcase', 'Door']); +$merged = $collection->merge(['Bookcase', 'Door']); - $merged->all(); +$merged->all(); - // ['Desk', 'Chair', 'Bookcase', 'Door'] +// ['Desk', 'Chair', 'Bookcase', 'Door'] +``` #### `mergeRecursive()` Метод `mergeRecursive` рекурсивно объединяет переданный массив или коллекцию с исходной коллекцией. Если строковый ключ в переданных элементах совпадает со строковым ключом в исходной коллекции, тогда значения этих ключей объединяются в массив, и это делается рекурсивно: - $collection = collect(['product_id' => 1, 'price' => 100]); +```php +$collection = collect(['product_id' => 1, 'price' => 100]); - $merged = $collection->mergeRecursive([ - 'product_id' => 2, - 'price' => 200, - 'discount' => false - ]); +$merged = $collection->mergeRecursive([ + 'product_id' => 2, + 'price' => 200, + 'discount' => false +]); - $merged->all(); +$merged->all(); - // ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false] +// ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false] +``` #### `min()` Метод `min` возвращает минимальное значение переданного ключа: - $min = collect([['foo' => 10], ['foo' => 20]])->min('foo'); +```php +$min = collect([['foo' => 10], ['foo' => 20]])->min('foo'); - // 10 +// 10 - $min = collect([1, 2, 3, 4, 5])->min(); +$min = collect([1, 2, 3, 4, 5])->min(); - // 1 +// 1 +``` #### `mode()` Метод `mode` возвращает [значение моды](https://en.wikipedia.org/wiki/Mode_(statistics)) указанного ключа: - $mode = collect([ - ['foo' => 10], - ['foo' => 10], - ['foo' => 20], - ['foo' => 40] - ])->mode('foo'); +```php +$mode = collect([ + ['foo' => 10], + ['foo' => 10], + ['foo' => 20], + ['foo' => 40] +])->mode('foo'); - // [10] +// [10] - $mode = collect([1, 1, 2, 4])->mode(); +$mode = collect([1, 1, 2, 4])->mode(); - // [1] +// [1] - $mode = collect([1, 1, 2, 2])->mode(); +$mode = collect([1, 1, 2, 2])->mode(); - // [1, 2] +// [1, 2] +``` #### `multiply()` @@ -1693,35 +1983,41 @@ $users = collect([ Метод `nth` создает новую коллекцию, состоящую из каждого `n`-го элемента: - $collection = collect(['a', 'b', 'c', 'd', 'e', 'f']); +```php +$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']); - $collection->nth(4); +$collection->nth(4); - // ['a', 'e'] +// ['a', 'e'] +``` При желании вы можете передать начальное смещение в качестве второго аргумента: - $collection->nth(4, 1); +```php +$collection->nth(4, 1); - // ['b', 'f'] +// ['b', 'f'] +``` #### `only()` Метод `only` возвращает элементы коллекции только с указанными ключами: - $collection = collect([ - 'product_id' => 1, - 'name' => 'Desk', - 'price' => 100, - 'discount' => false - ]); +```php +$collection = collect([ + 'product_id' => 1, + 'name' => 'Desk', + 'price' => 100, + 'discount' => false +]); - $filtered = $collection->only(['product_id', 'name']); +$filtered = $collection->only(['product_id', 'name']); - $filtered->all(); +$filtered->all(); - // ['product_id' => 1, 'name' => 'Desk'] +// ['product_id' => 1, 'name' => 'Desk'] +``` Противоположным методу `only` является метод [except](#method-except). @@ -1735,38 +2031,45 @@ $users = collect([ Для дополнения слева следует указать отрицательный размер. Если абсолютное значение указанного размера меньше или равно длине массива, заполнение не произойдет: - $collection = collect(['A', 'B', 'C']); +```php +$collection = collect(['A', 'B', 'C']); - $filtered = $collection->pad(5, 0); +$filtered = $collection->pad(5, 0); - $filtered->all(); +$filtered->all(); - // ['A', 'B', 'C', 0, 0] +// ['A', 'B', 'C', 0, 0] - $filtered = $collection->pad(-5, 0); +$filtered = $collection->pad(-5, 0); - $filtered->all(); +$filtered->all(); - // [0, 0, 'A', 'B', 'C'] +// [0, 0, 'A', 'B', 'C'] +``` #### `partition()` Метод `partition` используется в связке с деструктуризацией массивов PHP (вместо функции list в предыдущих версиях), чтобы разделить элементы, прошедшие указанную проверку истинности, от тех, которые ее не прошли: - $collection = collect([1, 2, 3, 4, 5, 6]); +```php +$collection = collect([1, 2, 3, 4, 5, 6]); - [$underThree, $equalOrAboveThree] = $collection->partition(function (int $i) { - return $i < 3; - }); +[$underThree, $equalOrAboveThree] = $collection->partition(function (int $i) { + return $i < 3; +}); - $underThree->all(); +$underThree->all(); - // [1, 2] +// [1, 2] - $equalOrAboveThree->all(); +$equalOrAboveThree->all(); - // [3, 4, 5, 6] +// [3, 4, 5, 6] +``` + +> [!NOTE] +> This method's behavior is modified when interacting with [Eloquent collections](/docs/{{version}}/eloquent-collections#method-partition). #### `percentage()` @@ -1776,7 +2079,7 @@ $users = collect([ ```php $collection = collect([1, 1, 2, 2, 2, 3]); -$percentage = $collection->percentage(fn ($value) => $value === 1); +$percentage = $collection->percentage(fn (int $value) => $value === 1); // 33.33 ``` @@ -1784,7 +2087,7 @@ $percentage = $collection->percentage(fn ($value) => $value === 1); По умолчанию процент будет округлен до двух знаков после запятой. Однако, вы можете настроить это поведение, указав второй аргумент метода: ```php -$percentage = $collection->percentage(fn ($value) => $value === 1, precision: 3); +$percentage = $collection->percentage(fn (int $value) => $value === 1, precision: 3); // 33.333 ``` @@ -1794,409 +2097,467 @@ $percentage = $collection->percentage(fn ($value) => $value === 1, precision: 3) Метод `pipe` передает коллекцию указанному замыканию и возвращает результат выполненного замыкания: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); - $piped = $collection->pipe(function (Collection $collection) { - return $collection->sum(); - }); +$piped = $collection->pipe(function (Collection $collection) { + return $collection->sum(); +}); - // 6 +// 6 +``` #### `pipeInto()` Метод `pipeInto` создает новый экземпляр указанного класса и передает коллекцию в конструктор: - class ResourceCollection - { - /** - * Создать новый экземпляр ResourceCollection. - */ - public function __construct( - public Collection $collection, - ) {} - } +```php +class ResourceCollection +{ + /** + * Создать новый экземпляр ResourceCollection. + */ + public function __construct( + public Collection $collection, + ) {} +} - $collection = collect([1, 2, 3]); +$collection = collect([1, 2, 3]); - $resource = $collection->pipeInto(ResourceCollection::class); +$resource = $collection->pipeInto(ResourceCollection::class); - $resource->collection->all(); +$resource->collection->all(); - // [1, 2, 3] +// [1, 2, 3] +``` #### `pipeThrough()` Метод `pipeThrough` передает коллекцию заданному массиву замыканий и возвращает результат выполненных замыканий: - use Illuminate\Support\Collection; +```php +use Illuminate\Support\Collection; - $collection = collect([1, 2, 3]); +$collection = collect([1, 2, 3]); - $result = $collection->pipeThrough([ - function (Collection $collection) { - return $collection->merge([4, 5]); - }, - function (Collection $collection) { - return $collection->sum(); - }, - ]); +$result = $collection->pipeThrough([ + function (Collection $collection) { + return $collection->merge([4, 5]); + }, + function (Collection $collection) { + return $collection->sum(); + }, +]); - // 15 +// 15 +``` #### `pluck()` Метод `pluck` извлекает все значения для указанного ключа: - $collection = collect([ - ['product_id' => 'prod-100', 'name' => 'Desk'], - ['product_id' => 'prod-200', 'name' => 'Chair'], - ]); +```php +$collection = collect([ + ['product_id' => 'prod-100', 'name' => 'Desk'], + ['product_id' => 'prod-200', 'name' => 'Chair'], +]); - $plucked = $collection->pluck('name'); +$plucked = $collection->pluck('name'); - $plucked->all(); +$plucked->all(); - // ['Desk', 'Chair'] +// ['Desk', 'Chair'] +``` Вы также можете задать ключ результирующей коллекции: - $plucked = $collection->pluck('name', 'product_id'); +```php +$plucked = $collection->pluck('name', 'product_id'); - $plucked->all(); +$plucked->all(); - // ['prod-100' => 'Desk', 'prod-200' => 'Chair'] +// ['prod-100' => 'Desk', 'prod-200' => 'Chair'] +``` Метод `pluck` также поддерживает получение вложенных значений с использованием «точечной нотации»: - $collection = collect([ - [ - 'name' => 'Laracon', - 'speakers' => [ - 'first_day' => ['Rosa', 'Judith'], - ], +```php +$collection = collect([ + [ + 'name' => 'Laracon', + 'speakers' => [ + 'first_day' => ['Rosa', 'Judith'], ], - [ - 'name' => 'VueConf', - 'speakers' => [ - 'first_day' => ['Abigail', 'Joey'], - ], + ], + [ + 'name' => 'VueConf', + 'speakers' => [ + 'first_day' => ['Abigail', 'Joey'], ], - ]); + ], +]); - $plucked = $collection->pluck('speakers.first_day'); +$plucked = $collection->pluck('speakers.first_day'); - $plucked->all(); +$plucked->all(); - // [['Rosa', 'Judith'], ['Abigail', 'Joey']] +// [['Rosa', 'Judith'], ['Abigail', 'Joey']] +``` Если существуют повторяющиеся ключи, последний соответствующий элемент будет вставлен в результирующую коллекцию: - $collection = collect([ - ['brand' => 'Tesla', 'color' => 'red'], - ['brand' => 'Pagani', 'color' => 'white'], - ['brand' => 'Tesla', 'color' => 'black'], - ['brand' => 'Pagani', 'color' => 'orange'], - ]); +```php +$collection = collect([ + ['brand' => 'Tesla', 'color' => 'red'], + ['brand' => 'Pagani', 'color' => 'white'], + ['brand' => 'Tesla', 'color' => 'black'], + ['brand' => 'Pagani', 'color' => 'orange'], +]); - $plucked = $collection->pluck('color', 'brand'); +$plucked = $collection->pluck('color', 'brand'); - $plucked->all(); +$plucked->all(); - // ['Tesla' => 'black', 'Pagani' => 'orange'] +// ['Tesla' => 'black', 'Pagani' => 'orange'] +``` #### `pop()` -Метод `pop` удаляет и возвращает последний элемент из коллекции: +Метод `pop` удаляет и возвращает последний элемент из коллекции. Если коллекция пуста, будет возвращен `null`: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->pop(); +$collection->pop(); - // 5 +// 5 - $collection->all(); +$collection->all(); - // [1, 2, 3, 4] +// [1, 2, 3, 4] +``` Вы можете передать целое число в метод `pop`, чтобы удалить и вернуть несколько элементов из конца коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->pop(3); +$collection->pop(3); - // collect([5, 4, 3]) +// collect([5, 4, 3]) - $collection->all(); +$collection->all(); - // [1, 2] +// [1, 2] +``` #### `prepend()` Метод `prepend` добавляет элемент в начало коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->prepend(0); +$collection->prepend(0); - $collection->all(); +$collection->all(); - // [0, 1, 2, 3, 4, 5] +// [0, 1, 2, 3, 4, 5] +``` Вы также можете передать второй аргумент, чтобы указать ключ добавляемого элемента: - $collection = collect(['one' => 1, 'two' => 2]); +```php +$collection = collect(['one' => 1, 'two' => 2]); - $collection->prepend(0, 'zero'); +$collection->prepend(0, 'zero'); - $collection->all(); +$collection->all(); - // ['zero' => 0, 'one' => 1, 'two' => 2] +// ['zero' => 0, 'one' => 1, 'two' => 2] +``` #### `pull()` Метод `pull` удаляет и возвращает элемент из коллекции по его ключу: - $collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']); +```php +$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']); - $collection->pull('name'); +$collection->pull('name'); - // 'Desk' +// 'Desk' - $collection->all(); +$collection->all(); - // ['product_id' => 'prod-100'] +// ['product_id' => 'prod-100'] +``` #### `push()` Метод `push` добавляет элемент в конец коллекции: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $collection->push(5); +$collection->push(5); - $collection->all(); +$collection->all(); - // [1, 2, 3, 4, 5] +// [1, 2, 3, 4, 5] +``` #### `put()` Метод `put` помещает указанные ключ и значение в коллекцию: - $collection = collect(['product_id' => 1, 'name' => 'Desk']); +```php +$collection = collect(['product_id' => 1, 'name' => 'Desk']); - $collection->put('price', 100); +$collection->put('price', 100); - $collection->all(); +$collection->all(); - // ['product_id' => 1, 'name' => 'Desk', 'price' => 100] +// ['product_id' => 1, 'name' => 'Desk', 'price' => 100] +``` #### `random()` Метод `random` возвращает случайный элемент из коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->random(); +$collection->random(); - // 4 - (retrieved randomly) +// 4 - (retrieved randomly) +``` Вы можете передать целое число в `random`, чтобы указать, сколько случайных элементов вы хотите получить. Коллекция элементов всегда возвращается при явной передаче количества элементов, которые вы хотите получить: - $random = $collection->random(3); +```php +$random = $collection->random(3); - $random->all(); +$random->all(); - // [2, 4, 5] - (retrieved randomly) +// [2, 4, 5] - (retrieved randomly) +``` Если в экземпляре коллекции меньше элементов, чем запрошено, метод `random` сгенерирует исключение `InvalidArgumentException`. Метод `random` также принимает замыкание, которое будет получать текущий экземпляр коллекции: - use Illuminate\Support\Collection; +```php +use Illuminate\Support\Collection; - $random = $collection->random(fn (Collection $items) => min(10, count($items))); +$random = $collection->random(fn (Collection $items) => min(10, count($items))); - $random->all(); +$random->all(); - // [1, 2, 3, 4, 5] - (retrieved randomly) +// [1, 2, 3, 4, 5] - (retrieved randomly) +``` #### `range()` Метод `range` возвращает коллекцию, содержащую целые числа в указанном диапазоне: - $collection = collect()->range(3, 6); +```php +$collection = collect()->range(3, 6); - $collection->all(); +$collection->all(); - // [3, 4, 5, 6] +// [3, 4, 5, 6] +``` #### `reduce()` Метод `reduce` сокращает коллекцию до одного значения, передавая результат каждой итерации следующей итерации: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); - $total = $collection->reduce(function (?int $carry, int $item) { - return $carry + $item; - }); +$total = $collection->reduce(function (?int $carry, int $item) { + return $carry + $item; +}); - // 6 +// 6 +``` Значение `$carry` первой итерации равно `null`; однако вы можете указать его начальное значение, передав второй аргумент методу `reduce`: - $collection->reduce(function (int $carry, int $item) { - return $carry + $item; - }, 4); +```php +$collection->reduce(function (int $carry, int $item) { + return $carry + $item; +}, 4); - // 10 +// 10 +``` -Метод `reduce` также передает ключи массива ассоциативных коллекций указанному замыканию: +Метод `reduce` также передает ключи массива указанному замыканию: - $collection = collect([ - 'usd' => 1400, - 'gbp' => 1200, - 'eur' => 1000, - ]); +```php +$collection = collect([ + 'usd' => 1400, + 'gbp' => 1200, + 'eur' => 1000, +]); - $ratio = [ - 'usd' => 1, - 'gbp' => 1.37, - 'eur' => 1.22, - ]; +$ratio = [ + 'usd' => 1, + 'gbp' => 1.37, + 'eur' => 1.22, +]; - $collection->reduce(function (int $carry, int $value, int $key) use ($ratio) { - return $carry + ($value * $ratio[$key]); - }); +$collection->reduce(function (int $carry, int $value, string $key) use ($ratio) { + return $carry + ($value * $ratio[$key]); +}); - // 4264 +// 4264 +``` #### `reduceSpread()` Метод `reduceSpread` сокращает коллекцию до массива значений, передавая результаты каждой итерации в следующую итерацию. Этот метод похож на метод `reduce`, однако он может принимать несколько начальных значений: - [$creditsRemaining, $batch] = Image::where('status', 'unprocessed') - ->get() - ->reduceSpread(function (int $creditsRemaining, Collection $batch, Image $image) { - if ($creditsRemaining >= $image->creditsRequired()) { - $batch->push($image); +```php +[$creditsRemaining, $batch] = Image::where('status', 'unprocessed') + ->get() + ->reduceSpread(function (int $creditsRemaining, Collection $batch, Image $image) { + if ($creditsRemaining >= $image->creditsRequired()) { + $batch->push($image); - $creditsRemaining -= $image->creditsRequired(); - } + $creditsRemaining -= $image->creditsRequired(); + } - return [$creditsRemaining, $batch]; - }, $creditsAvailable, collect()); + return [$creditsRemaining, $batch]; + }, $creditsAvailable, collect()); +``` #### `reject()` Метод `reject` фильтрует коллекцию, используя переданное замыкание. Замыкание должно возвращать `true`, если элемент должен быть удален из результирующей коллекции: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $filtered = $collection->reject(function (int $value, int $key) { - return $value > 2; - }); +$filtered = $collection->reject(function (int $value, int $key) { + return $value > 2; +}); - $filtered->all(); +$filtered->all(); - // [1, 2] +// [1, 2] +``` -Противоположным методу `reject` является метод [`filter`](#method-filter). +Противоположным методу `reject` является метод [filter](#method-filter). #### `replace()` Метод `replace` ведет себя аналогично методу `merge`; однако, помимо перезаписи совпадающих элементов, имеющих строковые ключи, метод `replace` также перезаписывает элементы в коллекции, у которых есть совпадающие числовые ключи: - $collection = collect(['Taylor', 'Abigail', 'James']); +```php +$collection = collect(['Taylor', 'Abigail', 'James']); - $replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']); +$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']); - $replaced->all(); +$replaced->all(); - // ['Taylor', 'Victoria', 'James', 'Finn'] +// ['Taylor', 'Victoria', 'James', 'Finn'] +``` #### `replaceRecursive()` -Этот метод работает как и `replace`, но он будет повторяться в массивах и применять тот же процесс замены к внутренним значениям: +Метод `replaceRecursive` ведет себя аналогично `replace`, но он будет повторяться в массивах и применять тот же процесс замены к внутренним значениям: - $collection = collect([ - 'Taylor', - 'Abigail', - [ - 'James', - 'Victoria', - 'Finn' - ] - ]); +```php +$collection = collect([ + 'Taylor', + 'Abigail', + [ + 'James', + 'Victoria', + 'Finn' + ] +]); - $replaced = $collection->replaceRecursive([ - 'Charlie', - 2 => [1 => 'King'] - ]); +$replaced = $collection->replaceRecursive([ + 'Charlie', + 2 => [1 => 'King'] +]); - $replaced->all(); +$replaced->all(); - // ['Charlie', 'Abigail', ['James', 'King', 'Finn']] +// ['Charlie', 'Abigail', ['James', 'King', 'Finn']] +``` #### `reverse()` Метод `reverse` меняет порядок элементов коллекции на обратный, сохраняя исходные ключи: - $collection = collect(['a', 'b', 'c', 'd', 'e']); +```php +$collection = collect(['a', 'b', 'c', 'd', 'e']); - $reversed = $collection->reverse(); +$reversed = $collection->reverse(); - $reversed->all(); +$reversed->all(); - /* - [ - 4 => 'e', - 3 => 'd', - 2 => 'c', - 1 => 'b', - 0 => 'a', - ] - */ +/* + [ + 4 => 'e', + 3 => 'd', + 2 => 'c', + 1 => 'b', + 0 => 'a', + ] +*/ +``` #### `search()` Метод `search` ищет в коллекции указанное значение и возвращает его ключ, если он найден. Если элемент не найден, возвращается `false`: - $collection = collect([2, 4, 6, 8]); +```php +$collection = collect([2, 4, 6, 8]); - $collection->search(4); +$collection->search(4); - // 1 +// 1 +``` Поиск выполняется с использованием «гибкого» сравнения, то есть строка с целым значением будет считаться равной целому числу того же значения. Чтобы использовать «жесткое» сравнение, передайте `true` в качестве второго аргумента метода: - collect([2, 4, 6, 8])->search('4', strict: true); +```php +collect([2, 4, 6, 8])->search('4', strict: true); - // false +// false +``` В качестве альтернативы вы можете передать собственное замыкание для поиска первого элемента, который проходит указанный тест на истинность: - collect([2, 4, 6, 8])->search(function (int $item, int $key) { - return $item > 5; - }); +```php +collect([2, 4, 6, 8])->search(function (int $item, int $key) { + return $item > 5; +}); - // 2 +// 2 +``` #### `select()` @@ -2224,78 +2585,90 @@ $users->select(['name', 'role']); Метод `shift` удаляет и возвращает первый элемент из коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->shift(); +$collection->shift(); - // 1 +// 1 - $collection->all(); +$collection->all(); - // [2, 3, 4, 5] +// [2, 3, 4, 5] +``` Вы можете передать целое число в метод `shift`, чтобы удалить и вернуть несколько элементов из начала коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->shift(3); +$collection->shift(3); - // collect([1, 2, 3]) +// collect([1, 2, 3]) - $collection->all(); +$collection->all(); - // [4, 5] +// [4, 5] +``` #### `shuffle()` Метод `shuffle` случайным образом перемешивает элементы в коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $shuffled = $collection->shuffle(); +$shuffled = $collection->shuffle(); - $shuffled->all(); +$shuffled->all(); - // [3, 2, 5, 1, 4] - (последовательность случайная) +// [3, 2, 5, 1, 4] - (последовательность случайная) +``` #### `skip()` Метод `skip` возвращает новую коллекцию с указанным количеством удаляемых из начала коллекции элементов: - $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); +```php +$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); - $collection = $collection->skip(4); +$collection = $collection->skip(4); - $collection->all(); +$collection->all(); - // [5, 6, 7, 8, 9, 10] +// [5, 6, 7, 8, 9, 10] +``` #### `skipUntil()` Метод `skipUntil` пропускает элементы из коллекции, в то время как данное замыкание возвращает `false`. Как только замыкание вернет `true`, все оставшиеся элементы коллекции будут возвращены как новая коллекция: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $subset = $collection->skipUntil(function (int $item) { - return $item >= 3; - }); +$subset = $collection->skipUntil(function (int $item) { + return $item >= 3; +}); - $subset->all(); +$subset->all(); - // [3, 4] +// [3, 4] +``` Вы также можете передать простое значение методу `skipUntil`, чтобы пропустить все элементы, пока не будет найдено указанное значение: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $subset = $collection->skipUntil(3); +$subset = $collection->skipUntil(3); - $subset->all(); +$subset->all(); - // [3, 4] +// [3, 4] +``` > [!WARNING] > Если указанное значение не найдено или замыкание никогда не возвращает `true`, то метод `skipUntil` вернет пустую коллекцию. @@ -2305,15 +2678,17 @@ $users->select(['name', 'role']); Метод `skipWhile` пропускает элементы из коллекции, в то время как замыкане возвращает `true`. Как только обратный вызов вернет `false`, все оставшиеся элементы коллекции будут возвращены как новая коллекция: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $subset = $collection->skipWhile(function (int $item) { - return $item <= 3; - }); +$subset = $collection->skipWhile(function (int $item) { + return $item <= 3; +}); - $subset->all(); +$subset->all(); - // [4] +// [4] +``` > [!WARNING] > Если замыкание никогда не возвращает `false`, то метод `skipWhile` вернет пустую коллекцию. @@ -2323,450 +2698,508 @@ $users->select(['name', 'role']); Метод `slice` возвращает фрагмент коллекции, начиная с указанного индекса: - $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); +```php +$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); - $slice = $collection->slice(4); +$slice = $collection->slice(4); - $slice->all(); +$slice->all(); - // [5, 6, 7, 8, 9, 10] +// [5, 6, 7, 8, 9, 10] +``` Если вы хотите ограничить размер возвращаемого фрагмента, то передайте желаемый размер в качестве второго аргумента метода: - $slice = $collection->slice(4, 2); +```php +$slice = $collection->slice(4, 2); - $slice->all(); +$slice->all(); - // [5, 6] +// [5, 6] +``` -Возвращенный фрагмент по умолчанию сохранит ключи. Если вы не хотите сохранять исходные ключи, вы можете использовать метод [`values`](#method-values), чтобы переиндексировать их. +Возвращенный фрагмент по умолчанию сохранит ключи. Если вы не хотите сохранять исходные ключи, вы можете использовать метод [values](#method-values), чтобы переиндексировать их. #### `sliding()` Метод `sliding` возвращает новую коллекцию фрагментов (chunks), представляющих представление элементов коллекции в виде "скользящего окна": - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $chunks = $collection->sliding(2); +$chunks = $collection->sliding(2); - $chunks->toArray(); +$chunks->toArray(); - // [[1, 2], [2, 3], [3, 4], [4, 5]] +// [[1, 2], [2, 3], [3, 4], [4, 5]] +``` -Это особенно полезно в сочетании с методом [`eachSpread`](#method-eachspread): +Это особенно полезно в сочетании с методом [eachSpread](#method-eachspread): - $transactions->sliding(2)->eachSpread(function (Collection $previous, Collection $current) { - $current->total = $previous->total + $current->amount; - }); +```php +$transactions->sliding(2)->eachSpread(function (Collection $previous, Collection $current) { + $current->total = $previous->total + $current->amount; +}); +``` По желанию вторым аргументом можно передать "шаг", который определяет расстояние между первым элементом каждого фрагмента: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $chunks = $collection->sliding(3, step: 2); +$chunks = $collection->sliding(3, step: 2); - $chunks->toArray(); +$chunks->toArray(); - // [[1, 2, 3], [3, 4, 5]] +// [[1, 2, 3], [3, 4, 5]] +``` #### `sole()` Метод `sole` возвращает первый элемент в коллекции, который проходит заданный тест на истинность, но только если тест на истинность соответствует ровно одному элементу: - collect([1, 2, 3, 4])->sole(function (int $value, int $key) { - return $value === 2; - }); +```php +collect([1, 2, 3, 4])->sole(function (int $value, int $key) { + return $value === 2; +}); - // 2 +// 2 +``` Вы также можете передать пару ключ / значение в метод `sole`, который вернет первый элемент коллекции, соответствующий данной паре, но только в том случае, если совпадает ровно один элемент: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Chair', 'price' => 100], - ]); +```php +$collection = collect([ + ['product' => 'Desk', 'price' => 200], + ['product' => 'Chair', 'price' => 100], +]); - $collection->sole('product', 'Chair'); +$collection->sole('product', 'Chair'); - // ['product' => 'Chair', 'price' => 100] +// ['product' => 'Chair', 'price' => 100] +``` В качестве альтернативы вы также можете вызвать метод `sole` без аргумента, чтобы получить первый элемент в коллекции, если в ней только один элемент: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ]); +```php +$collection = collect([ + ['product' => 'Desk', 'price' => 200], +]); - $collection->sole(); +$collection->sole(); - // ['product' => 'Desk', 'price' => 200] +// ['product' => 'Desk', 'price' => 200] +``` Если в коллекции нет элементов, которые должны быть возвращены методом `sole`, будет брошено исключение `\Illuminate\Collections\ItemNotFoundException`. Если есть более одного элемента, который должен быть возвращен, то будет брошено исключение `\Illuminate\Collections\MultipleItemsFoundException`. #### `some()` -Псевдоним для метода [`contains`](#method-contains). +Псевдоним для метода [contains](#method-contains). #### `sort()` -Метод `sort` сортирует коллекцию. В отсортированной коллекции хранятся исходные ключи массива, поэтому в следующем примере мы будем использовать метод [`values`](#method-values) для сброса ключей для последовательной нумерации индексов: +Метод `sort` сортирует коллекцию. В отсортированной коллекции хранятся исходные ключи массива, поэтому в следующем примере мы будем использовать метод [values](#method-values) для сброса ключей для последовательной нумерации индексов: - $collection = collect([5, 3, 1, 2, 4]); +```php +$collection = collect([5, 3, 1, 2, 4]); - $sorted = $collection->sort(); +$sorted = $collection->sort(); - $sorted->values()->all(); +$sorted->values()->all(); - // [1, 2, 3, 4, 5] +// [1, 2, 3, 4, 5] +``` -Если ваши потребности в сортировке более сложны, вы можете передать замыкание методу `sort` с вашим собственным алгоритмом. Обратитесь к документации PHP по [`uasort`](https://www.php.net/manual/ru/function.uasort.php#refsect1-function.uasort-parameters), который используется внутри метода `sort`. +Если ваши потребности в сортировке более сложны, вы можете передать замыкание методу `sort` с вашим собственным алгоритмом. Обратитесь к документации PHP по [uasort](https://www.php.net/manual/ru/function.uasort.php#refsect1-function.uasort-parameters), который используется внутри метода `sort`. > [!NOTE] -> Если вам нужно отсортировать коллекцию вложенных массивов или объектов, то см. методы [`sortBy`](#method-sortby) и [`sortByDesc`](#method-sortbydesc). +> Если вам нужно отсортировать коллекцию вложенных массивов или объектов, то см. методы [sortBy](#method-sortby) и [sortByDesc](#method-sortbydesc). #### `sortBy()` -Метод `sortBy` сортирует коллекцию по указанному ключу. В отсортированной коллекции хранятся исходные ключи массива, поэтому в следующем примере мы будем использовать метод [`values`](#method-values) для сброса ключей для последовательной нумерации индексов: +Метод `sortBy` сортирует коллекцию по указанному ключу. В отсортированной коллекции хранятся исходные ключи массива, поэтому в следующем примере мы будем использовать метод [values](#method-values) для сброса ключей для последовательной нумерации индексов: - $collection = collect([ - ['name' => 'Desk', 'price' => 200], +```php +$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], + ] +*/ +``` - $sorted = $collection->sortBy('price'); +Метод `sortBy` принимает [флаги типа сортировки](https://www.php.net/manual/ru/function.sort.php) в качестве второго аргумента: - $sorted->values()->all(); +```php +$collection = collect([ + ['title' => 'Item 1'], + ['title' => 'Item 12'], + ['title' => 'Item 3'], +]); - /* - [ - ['name' => 'Chair', 'price' => 100], - ['name' => 'Bookcase', 'price' => 150], - ['name' => 'Desk', 'price' => 200], - ] - */ +$sorted = $collection->sortBy('title', SORT_NATURAL); -Метод `sortBy` принимает [флаги типа сортировки](https://www.php.net/manual/ru/function.sort.php) в качестве второго аргумента: +$sorted->values()->all(); - $collection = collect([ +/* + [ ['title' => 'Item 1'], - ['title' => 'Item 12'], ['title' => 'Item 3'], - ]); + ['title' => 'Item 12'], + ] +*/ +``` - $sorted = $collection->sortBy('title', SORT_NATURAL); +В качестве альтернативы вы можете передать собственное замыкание, чтобы определить, как сортировать значения коллекции: - $sorted->values()->all(); +```php +$collection = collect([ + ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']], + ['name' => 'Chair', 'colors' => ['Black']], + ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']], +]); - /* - [ - ['title' => 'Item 1'], - ['title' => 'Item 3'], - ['title' => 'Item 12'], - ] - */ +$sorted = $collection->sortBy(function (array $product, int $key) { + return count($product['colors']); +}); -В качестве альтернативы вы можете передать собственное замыкание, чтобы определить, как сортировать значения коллекции: +$sorted->values()->all(); - $collection = collect([ - ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']], +/* + [ ['name' => 'Chair', 'colors' => ['Black']], + ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']], ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']], - ]); + ] +*/ +``` - $sorted = $collection->sortBy(function (array $product, int $key) { - return count($product['colors']); - }); +Если вы хотите отсортировать свою коллекцию по нескольким атрибутам, вы можете передать массив операций сортировки методу `sortBy`. Каждая операция сортировки должна быть массивом, состоящим из атрибута, по которому вы хотите сортировать, и направления желаемой сортировки: - $sorted->values()->all(); +```php +$collection = collect([ + ['name' => 'Taylor Otwell', 'age' => 34], + ['name' => 'Abigail Otwell', 'age' => 30], + ['name' => 'Taylor Otwell', 'age' => 36], + ['name' => 'Abigail Otwell', 'age' => 32], +]); - /* - [ - ['name' => 'Chair', 'colors' => ['Black']], - ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']], - ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']], - ] - */ +$sorted = $collection->sortBy([ + ['name', 'asc'], + ['age', 'desc'], +]); -Если вы хотите отсортировать свою коллекцию по нескольким атрибутам, вы можете передать массив операций сортировки методу `sortBy`. Каждая операция сортировки должна быть массивом, состоящим из атрибута, по которому вы хотите сортировать, и направления желаемой сортировки: +$sorted->values()->all(); - $collection = collect([ - ['name' => 'Taylor Otwell', 'age' => 34], +/* + [ + ['name' => 'Abigail Otwell', 'age' => 32], ['name' => 'Abigail Otwell', 'age' => 30], ['name' => 'Taylor Otwell', 'age' => 36], - ['name' => 'Abigail Otwell', 'age' => 32], - ]); + ['name' => 'Taylor Otwell', 'age' => 34], + ] +*/ +``` - $sorted = $collection->sortBy([ - ['name', 'asc'], - ['age', 'desc'], - ]); +При сортировке коллекции по нескольким атрибутам вы также можете указать замыкания, определяющие каждую операцию сортировки: - $sorted->values()->all(); +```php +$collection = collect([ + ['name' => 'Taylor Otwell', 'age' => 34], + ['name' => 'Abigail Otwell', 'age' => 30], + ['name' => 'Taylor Otwell', 'age' => 36], + ['name' => 'Abigail Otwell', 'age' => 32], +]); - /* - [ - ['name' => 'Abigail Otwell', 'age' => 32], - ['name' => 'Abigail Otwell', 'age' => 30], - ['name' => 'Taylor Otwell', 'age' => 36], - ['name' => 'Taylor Otwell', 'age' => 34], - ] - */ +$sorted = $collection->sortBy([ + fn (array $a, array $b) => $a['name'] <=> $b['name'], + fn (array $a, array $b) => $b['age'] <=> $a['age'], +]); -При сортировке коллекции по нескольким атрибутам вы также можете указать замыкания, определяющие каждую операцию сортировки: +$sorted->values()->all(); - $collection = collect([ - ['name' => 'Taylor Otwell', 'age' => 34], +/* + [ + ['name' => 'Abigail Otwell', 'age' => 32], ['name' => 'Abigail Otwell', 'age' => 30], ['name' => 'Taylor Otwell', 'age' => 36], - ['name' => 'Abigail Otwell', 'age' => 32], - ]); - - $sorted = $collection->sortBy([ - fn (array $a, array $b) => $a['name'] <=> $b['name'], - fn (array $a, array $b) => $b['age'] <=> $a['age'], - ]); - - $sorted->values()->all(); - - /* - [ - ['name' => 'Abigail Otwell', 'age' => 32], - ['name' => 'Abigail Otwell', 'age' => 30], - ['name' => 'Taylor Otwell', 'age' => 36], - ['name' => 'Taylor Otwell', 'age' => 34], - ] - */ + ['name' => 'Taylor Otwell', 'age' => 34], + ] +*/ +``` #### `sortByDesc()` -Этот метод имеет ту же сигнатуру, что и метод [`sortBy`](#method-sortby), но отсортирует коллекцию в обратном порядке. +Этот метод имеет ту же сигнатуру, что и метод [sortBy](#method-sortby), но отсортирует коллекцию в обратном порядке. #### `sortDesc()` -Этот метод сортирует коллекцию в порядке, обратном методу [`sort`](#method-sort): +Этот метод сортирует коллекцию в порядке, обратном методу [sort](#method-sort): - $collection = collect([5, 3, 1, 2, 4]); +```php +$collection = collect([5, 3, 1, 2, 4]); - $sorted = $collection->sortDesc(); +$sorted = $collection->sortDesc(); - $sorted->values()->all(); +$sorted->values()->all(); - // [5, 4, 3, 2, 1] +// [5, 4, 3, 2, 1] +``` -В отличие от `sort`, вы не можете передавать замыкание в `sortDesc`. Вместо этого вы должны использовать метод [`sort`](#method-sort) и инвертировать ваше сравнение. +В отличие от `sort`, вы не можете передавать замыкание в `sortDesc`. Вместо этого вы должны использовать метод [sort](#method-sort) и инвертировать ваше сравнение. #### `sortKeys()` Метод `sortKeys` сортирует коллекцию по ключам базового ассоциативного массива: - $collection = collect([ - 'id' => 22345, - 'first' => 'John', - 'last' => 'Doe', - ]); +```php +$collection = collect([ + 'id' => 22345, + 'first' => 'John', + 'last' => 'Doe', +]); - $sorted = $collection->sortKeys(); +$sorted = $collection->sortKeys(); - $sorted->all(); +$sorted->all(); - /* - [ - 'first' => 'John', - 'id' => 22345, - 'last' => 'Doe', - ] - */ +/* + [ + 'first' => 'John', + 'id' => 22345, + 'last' => 'Doe', + ] +*/ +``` #### `sortKeysDesc()` -Этот метод имеет ту же сигнатуру, что и метод [`sortKeys`](#method-sortkeys), но отсортирует коллекцию в обратном порядке. +Этот метод имеет ту же сигнатуру, что и метод [sortKeys](#method-sortkeys), но отсортирует коллекцию в обратном порядке. #### `sortKeysUsing()` Метод `sortKeysUsing` сортирует коллекцию по ключам базового ассоциативного массива с помощью обратного вызова: - $collection = collect([ - 'ID' => 22345, - 'first' => 'John', - 'last' => 'Doe', - ]); +```php +$collection = collect([ + 'ID' => 22345, + 'first' => 'John', + 'last' => 'Doe', +]); - $sorted = $collection->sortKeysUsing('strnatcasecmp'); +$sorted = $collection->sortKeysUsing('strnatcasecmp'); - $sorted->all(); +$sorted->all(); - /* - [ - 'first' => 'John', - 'ID' => 22345, - 'last' => 'Doe', - ] - */ +/* + [ + 'first' => 'John', + 'ID' => 22345, + 'last' => 'Doe', + ] +*/ +``` -Обратный вызов должен быть функцией сравнения, которая возвращает целое число, меньшее, равное или большее нуля. Для получения дополнительной информации обратитесь к документации по PHP [`uksort`](https://www.php.net/manual/ru/function.uksort.php#refsect1-function.uksort-parameters), которая представляет собой функцию PHP, используемую внутри метода `sortKeysUsing`. +Обратный вызов должен быть функцией сравнения, которая возвращает целое число, меньшее, равное или большее нуля. Для получения дополнительной информации обратитесь к документации по PHP [uksort](https://www.php.net/manual/ru/function.uksort.php#refsect1-function.uksort-parameters), которая представляет собой функцию PHP, используемую внутри метода `sortKeysUsing`. #### `splice()` Метод `splice` удаляет и возвращает фрагмент элементов, начиная с указанного индекса: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $chunk = $collection->splice(2); +$chunk = $collection->splice(2); - $chunk->all(); +$chunk->all(); - // [3, 4, 5] +// [3, 4, 5] - $collection->all(); +$collection->all(); - // [1, 2] +// [1, 2] +``` Вы можете передать второй аргумент, чтобы ограничить размер результирующей коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $chunk = $collection->splice(2, 1); +$chunk = $collection->splice(2, 1); - $chunk->all(); +$chunk->all(); - // [3] +// [3] - $collection->all(); +$collection->all(); - // [1, 2, 4, 5] +// [1, 2, 4, 5] +``` Кроме того, вы можете передать третий аргумент, содержащий новые элементы, чтобы заменить элементы, удаленные из коллекции: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $chunk = $collection->splice(2, 1, [10, 11]); +$chunk = $collection->splice(2, 1, [10, 11]); - $chunk->all(); +$chunk->all(); - // [3] +// [3] - $collection->all(); +$collection->all(); - // [1, 2, 10, 11, 4, 5] +// [1, 2, 10, 11, 4, 5] +``` #### `split()` Метод `split` разбивает коллекцию на указанное количество групп: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $groups = $collection->split(3); +$groups = $collection->split(3); - $groups->all(); +$groups->all(); - // [[1, 2], [3, 4], [5]] +// [[1, 2], [3, 4], [5]] +``` #### `splitIn()` Метод `splitIn` разбивает коллекцию на указанное количество групп, полностью заполняя нетерминальные группы перед тем, как выделить остаток последней группе: - $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); +```php +$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); - $groups = $collection->splitIn(3); +$groups = $collection->splitIn(3); - $groups->all(); +$groups->all(); - // [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]] +// [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]] +``` #### `sum()` Метод `sum` возвращает сумму всех элементов в коллекции: - collect([1, 2, 3, 4, 5])->sum(); +```php +collect([1, 2, 3, 4, 5])->sum(); - // 15 +// 15 +``` Если коллекция содержит вложенные массивы или объекты, вы должны передать ключ, который будет использоваться для определения суммирования значений: - $collection = collect([ - ['name' => 'JavaScript: The Good Parts', 'pages' => 176], - ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096], - ]); +```php +$collection = collect([ + ['name' => 'JavaScript: The Good Parts', 'pages' => 176], + ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096], +]); - $collection->sum('pages'); +$collection->sum('pages'); - // 1272 +// 1272 +``` Кроме того, вы можете передать собственное замыкание, чтобы определить, какие значения коллекции суммировать: - $collection = collect([ - ['name' => 'Chair', 'colors' => ['Black']], - ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']], - ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']], - ]); +```php +$collection = collect([ + ['name' => 'Chair', 'colors' => ['Black']], + ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']], + ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']], +]); - $collection->sum(function (array $product) { - return count($product['colors']); - }); +$collection->sum(function (array $product) { + return count($product['colors']); +}); - // 6 +// 6 +``` #### `take()` Метод `take` возвращает новую коллекцию с указанным количеством элементов: - $collection = collect([0, 1, 2, 3, 4, 5]); +```php +$collection = collect([0, 1, 2, 3, 4, 5]); - $chunk = $collection->take(3); +$chunk = $collection->take(3); - $chunk->all(); +$chunk->all(); - // [0, 1, 2] +// [0, 1, 2] +``` Вы также можете передать отрицательное целое число, чтобы получить указанное количество элементов из конца коллекции: - $collection = collect([0, 1, 2, 3, 4, 5]); +```php +$collection = collect([0, 1, 2, 3, 4, 5]); - $chunk = $collection->take(-2); +$chunk = $collection->take(-2); - $chunk->all(); +$chunk->all(); - // [4, 5] +// [4, 5] +``` #### `takeUntil()` Метод `takeUntil` возвращает элементы коллекции, пока указанное замыкание не вернет `true`: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $subset = $collection->takeUntil(function (int $item) { - return $item >= 3; - }); +$subset = $collection->takeUntil(function (int $item) { + return $item >= 3; +}); - $subset->all(); +$subset->all(); - // [1, 2] +// [1, 2] +``` Вы также можете передать простое значение методу `takeUntil`, чтобы получать элементы, пока не будет найдено указанное значение: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $subset = $collection->takeUntil(3); +$subset = $collection->takeUntil(3); - $subset->all(); +$subset->all(); - // [1, 2] +// [1, 2] +``` > [!WARNING] > Если указанное значение не найдено или замыкание никогда не возвращает `true`, то метод `takeUntil` вернет все элементы коллекции. @@ -2776,15 +3209,17 @@ $users->select(['name', 'role']); Метод `takeWhile` возвращает элементы коллекции до тех пор, пока указанное замыкание не вернет `false`: - $collection = collect([1, 2, 3, 4]); +```php +$collection = collect([1, 2, 3, 4]); - $subset = $collection->takeWhile(function (int $item) { - return $item < 3; - }); +$subset = $collection->takeWhile(function (int $item) { + return $item < 3; +}); - $subset->all(); +$subset->all(); - // [1, 2] +// [1, 2] +``` > [!WARNING] > Если замыкание никогда не возвращает `false`, метод `takeWhile` вернет все элементы коллекции. @@ -2794,175 +3229,195 @@ $users->select(['name', 'role']); Метод `tap` передает коллекцию указанному замыканию, позволяя вам «перехватить» коллекцию в определенный момент и сделать что-то с элементами, не затрагивая саму коллекцию. Затем коллекция возвращается методом `tap`: - collect([2, 4, 3, 1, 5]) - ->sort() - ->tap(function (Collection $collection) { - Log::debug('Values after sorting', $collection->values()->all()); - }) - ->shift(); - - // 1 +```php +collect([2, 4, 3, 1, 5]) + ->sort() + ->tap(function (Collection $collection) { + Log::debug('Values after sorting', $collection->values()->all()); + }) + ->shift(); + +// 1 +``` #### `times()` Статический метод `times` создает новую коллекцию, вызывая переданное замыкание указанное количество раз: - $collection = Collection::times(10, function (int $number) { - return $number * 9; - }); +```php +$collection = Collection::times(10, function (int $number) { + return $number * 9; +}); - $collection->all(); +$collection->all(); - // [9, 18, 27, 36, 45, 54, 63, 72, 81, 90] +// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90] +``` #### `toArray()` Метод `toArray` преобразует коллекцию в простой массив PHP. Если значениями коллекции являются модели [Eloquent](/docs/{{version}}/eloquent), то модели также будут преобразованы в массивы: - $collection = collect(['name' => 'Desk', 'price' => 200]); +```php +$collection = collect(['name' => 'Desk', 'price' => 200]); - $collection->toArray(); +$collection->toArray(); - /* - [ - ['name' => 'Desk', 'price' => 200], - ] - */ +/* + [ + ['name' => 'Desk', 'price' => 200], + ] +*/ +``` > [!WARNING] -> Метод `toArray` также преобразует все вложенные объекты коллекции, которые являются экземпляром `Arrayable`, в массив. Если вы хотите получить необработанный массив, лежащий в основе коллекции, используйте вместо этого метод [`all`](#method-all). +> Метод `toArray` также преобразует все вложенные объекты коллекции, которые являются экземпляром `Arrayable`, в массив. Если вы хотите получить необработанный массив, лежащий в основе коллекции, используйте вместо этого метод [all](#method-all). #### `toJson()` Метод `toJson` преобразует коллекцию в сериализованную строку JSON: - $collection = collect(['name' => 'Desk', 'price' => 200]); +```php +$collection = collect(['name' => 'Desk', 'price' => 200]); - $collection->toJson(); +$collection->toJson(); - // '{"name":"Desk", "price":200}' +// '{"name":"Desk", "price":200}' +``` #### `transform()` Метод `transform` выполняет итерацию коллекции и вызывает указанное замыкание для каждого элемента в коллекции. Элементы в коллекции будут заменены значениями, возвращаемыми замыканием: - $collection = collect([1, 2, 3, 4, 5]); +```php +$collection = collect([1, 2, 3, 4, 5]); - $collection->transform(function (int $item, int $key) { - return $item * 2; - }); +$collection->transform(function (int $item, int $key) { + return $item * 2; +}); - $collection->all(); +$collection->all(); - // [2, 4, 6, 8, 10] +// [2, 4, 6, 8, 10] +``` > [!WARNING] -> В отличие от большинства других методов коллекции, `transform` модифицирует коллекцию. Если вы хотите вместо этого создать новую коллекцию, используйте метод [`map`](#method-map). +> В отличие от большинства других методов коллекции, `transform` модифицирует коллекцию. Если вы хотите вместо этого создать новую коллекцию, используйте метод [map](#method-map). #### `undot()` Метод `undot` расширяет одномерную коллекцию, использующую «точечную» нотацию, в многомерную коллекцию: - $person = collect([ - 'name.first_name' => 'Marie', - 'name.last_name' => 'Valentine', - 'address.line_1' => '2992 Eagle Drive', - 'address.line_2' => '', - 'address.suburb' => 'Detroit', - 'address.state' => 'MI', - 'address.postcode' => '48219' - ]); +```php +$person = collect([ + 'name.first_name' => 'Marie', + 'name.last_name' => 'Valentine', + 'address.line_1' => '2992 Eagle Drive', + 'address.line_2' => '', + 'address.suburb' => 'Detroit', + 'address.state' => 'MI', + 'address.postcode' => '48219' +]); - $person = $person->undot(); +$person = $person->undot(); - $person->toArray(); +$person->toArray(); - /* - [ - "name" => [ - "first_name" => "Marie", - "last_name" => "Valentine", - ], - "address" => [ - "line_1" => "2992 Eagle Drive", - "line_2" => "", - "suburb" => "Detroit", - "state" => "MI", - "postcode" => "48219", - ], - ] - */ +/* + [ + "name" => [ + "first_name" => "Marie", + "last_name" => "Valentine", + ], + "address" => [ + "line_1" => "2992 Eagle Drive", + "line_2" => "", + "suburb" => "Detroit", + "state" => "MI", + "postcode" => "48219", + ], + ] +*/ +``` #### `union()` Метод `union` добавляет переданный массив в коллекцию. Если переданный массив содержит ключи, которые уже находятся в исходной коллекции, предпочтительнее будут значения исходной коллекции: - $collection = collect([1 => ['a'], 2 => ['b']]); +```php +$collection = collect([1 => ['a'], 2 => ['b']]); - $union = $collection->union([3 => ['c'], 1 => ['d']]); +$union = $collection->union([3 => ['c'], 1 => ['d']]); - $union->all(); +$union->all(); - // [1 => ['a'], 2 => ['b'], 3 => ['c']] +// [1 => ['a'], 2 => ['b'], 3 => ['c']] +``` #### `unique()` -Метод `unique` возвращает все уникальные элементы коллекции. Возвращенная коллекция сохраняет исходные ключи массива, поэтому в следующем примере мы будем использовать метод [`values`](#method-values) для сброса ключей для последовательной нумерации индексов: +Метод `unique` возвращает все уникальные элементы коллекции. Возвращенная коллекция сохраняет исходные ключи массива, поэтому в следующем примере мы будем использовать метод [values](#method-values) для сброса ключей для последовательной нумерации индексов: - $collection = collect([1, 1, 2, 2, 3, 4, 2]); +```php +$collection = collect([1, 1, 2, 2, 3, 4, 2]); - $unique = $collection->unique(); +$unique = $collection->unique(); - $unique->values()->all(); +$unique->values()->all(); - // [1, 2, 3, 4] +// [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'], - ]); +```php +$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 = $collection->unique('brand'); - $unique->values()->all(); +$unique->values()->all(); - /* - [ - ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'], - ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'], - ] - */ +/* + [ + ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'], + ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'], + ] +*/ +``` Наконец, вы также можете передать собственное замыкание методу `unique`, чтобы указать, какое значение должно определять уникальность элемента: - $unique = $collection->unique(function (array $item) { - return $item['brand'].$item['type']; - }); +```php +$unique = $collection->unique(function (array $item) { + return $item['brand'].$item['type']; +}); - $unique->values()->all(); +$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'], - ] - */ +/* + [ + ['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`](#method-uniquestrict) для фильтрации с использованием «жесткого» сравнения. +Метод `unique` использует «гибкое» сравнение при проверке значений элементов, то есть строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [uniqueStrict](#method-uniquestrict) для фильтрации с использованием «жесткого» сравнения. > [!NOTE] > Поведение этого метода изменяется при использовании [коллекций Eloquent](/docs/{{version}}/eloquent-collections#method-unique). @@ -2975,496 +3430,543 @@ $users->select(['name', 'role']); #### `unless()` -Метод `unless` выполнит указанное замыкание, если первый аргумент, переданный методу, не будет иметь значение `true`: +Метод `unless` выполнит указанное замыкание, если первый аргумент, переданный методу, не будет иметь значение `true`. Экземпляр коллекции и первый аргумент, переданный методу `unless`, будут переданы замыканию: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); - $collection->unless(true, function (Collection $collection) { - return $collection->push(4); - }); +$collection->unless(true, function (Collection $collection, bool $value) { + return $collection->push(4); +}); - $collection->unless(false, function (Collection $collection) { - return $collection->push(5); - }); +$collection->unless(false, function (Collection $collection, bool $value) { + return $collection->push(5); +}); - $collection->all(); +$collection->all(); - // [1, 2, 3, 5] +// [1, 2, 3, 5] +``` Второе замыкание может быть передано методу `unless`. Второе замыкание будет выполнено, когда первый аргумент, переданный методу `unless` будет иметь значение `true`: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); - $collection->unless(true, function (Collection $collection) { - return $collection->push(4); - }, function (Collection $collection) { - return $collection->push(5); - }); +$collection->unless(true, function (Collection $collection, bool $value) { + return $collection->push(4); +}, function (Collection $collection, bool $value) { + return $collection->push(5); +}); - $collection->all(); +$collection->all(); - // [1, 2, 3, 5] +// [1, 2, 3, 5] +``` -Противоположным методу `unless` является метод [`when`](#method-when). +Противоположным методу `unless` является метод [when](#method-when). #### `unlessEmpty()` -Псевдоним для метода [`whenNotEmpty`](#method-whennotempty). +Псевдоним для метода [whenNotEmpty](#method-whennotempty). #### `unlessNotEmpty()` -Псевдоним для метода [`whenEmpty`](#method-whenempty). +Псевдоним для метода [whenEmpty](#method-whenempty). #### `unwrap()` Статический метод `unwrap` возвращает базовые элементы коллекции из указанного значения, когда это применимо: - Collection::unwrap(collect('John Doe')); +```php +Collection::unwrap(collect('John Doe')); - // ['John Doe'] +// ['John Doe'] - Collection::unwrap(['John Doe']); +Collection::unwrap(['John Doe']); - // ['John Doe'] +// ['John Doe'] - Collection::unwrap('John Doe'); +Collection::unwrap('John Doe'); - // 'John Doe' +// 'John Doe' +``` #### `value()` Метод `value` извлекает заданное значение из первого элемента коллекции: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Speaker', 'price' => 400], - ]); +```php +$collection = collect([ + ['product' => 'Desk', 'price' => 200], + ['product' => 'Speaker', 'price' => 400], +]); - $value = $collection->value('price'); +$value = $collection->value('price'); - // 200 +// 200 +``` #### `values()` Метод `values` возвращает новую коллекцию с ключами, сброшенными на последовательные целые числа: - $collection = collect([ - 10 => ['product' => 'Desk', 'price' => 200], - 11 => ['product' => 'Desk', 'price' => 200], - ]); +```php +$collection = collect([ + 10 => ['product' => 'Desk', 'price' => 200], + 11 => ['product' => 'Desk', 'price' => 200], +]); - $values = $collection->values(); +$values = $collection->values(); - $values->all(); +$values->all(); - /* - [ - 0 => ['product' => 'Desk', 'price' => 200], - 1 => ['product' => 'Desk', 'price' => 200], - ] - */ +/* + [ + 0 => ['product' => 'Desk', 'price' => 200], + 1 => ['product' => 'Desk', 'price' => 200], + ] +*/ +``` #### `when()` Метод `when` выполнит указанное замыкание, когда первый аргумент, переданный методу, оценивается как` true`. Экземпляр коллекции и первый аргумент, переданный методу `when`, будут предоставлены в замыкание: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); - $collection->when(true, function (Collection $collection, int $value) { - return $collection->push(4); - }); +$collection->when(true, function (Collection $collection, bool $value) { + return $collection->push(4); +}); - $collection->when(false, function (Collection $collection, int $value) { - return $collection->push(5); - }); +$collection->when(false, function (Collection $collection, bool $value) { + return $collection->push(5); +}); - $collection->all(); +$collection->all(); - // [1, 2, 3, 4] +// [1, 2, 3, 4] +``` Второе замыкание может быть передано методу `when`. Второе замыкание будет выполнено, когда первый аргумент, переданный методу `when` будет иметь значение `false`: - $collection = collect([1, 2, 3]); +```php +$collection = collect([1, 2, 3]); - $collection->when(false, function (Collection $collection, int $value) { - return $collection->push(4); - }, function (Collection $collection) { - return $collection->push(5); - }); +$collection->when(false, function (Collection $collection, bool $value) { + return $collection->push(4); +}, function (Collection $collection, bool $value) { + return $collection->push(5); +}); - $collection->all(); +$collection->all(); - // [1, 2, 3, 5] +// [1, 2, 3, 5] +``` -Противоположным методу `when` является метод [`unless`](#method-unless). +Противоположным методу `when` является метод [unless](#method-unless). #### `whenEmpty()` Метод `whenEmpty` выполнит указанное замыкание, когда коллекция пуста: - $collection = collect(['Michael', 'Tom']); - - $collection->whenEmpty(function (Collection $collection) { - return $collection->push('Adam'); - }); +```php +$collection = collect(['Michael', 'Tom']); - $collection->all(); +$collection->whenEmpty(function (Collection $collection) { + return $collection->push('Adam'); +}); - // ['Michael', 'Tom'] +$collection->all(); +// ['Michael', 'Tom'] - $collection = collect(); +$collection = collect(); - $collection->whenEmpty(function (Collection $collection) { - return $collection->push('Adam'); - }); +$collection->whenEmpty(function (Collection $collection) { + return $collection->push('Adam'); +}); - $collection->all(); +$collection->all(); - // ['Adam'] +// ['Adam'] +``` Второе замыкание может быть передано методу `whenEmpty`, которое будет выполняться, если коллекция не пуста: - $collection = collect(['Michael', 'Tom']); +```php +$collection = collect(['Michael', 'Tom']); - $collection->whenEmpty(function (Collection $collection) { - return $collection->push('Adam'); - }, function (Collection $collection) { - return $collection->push('Taylor'); - }); +$collection->whenEmpty(function (Collection $collection) { + return $collection->push('Adam'); +}, function (Collection $collection) { + return $collection->push('Taylor'); +}); - $collection->all(); +$collection->all(); - // ['Michael', 'Tom', 'Taylor'] +// ['Michael', 'Tom', 'Taylor'] +``` -Противоположным методу `whenEmpty` является метод [`whenNotEmpty`](#method-whennotempty). +Противоположным методу `whenEmpty` является метод [whenNotEmpty](#method-whennotempty). #### `whenNotEmpty()` Метод `whenNotEmpty` выполнит указанное замыкание, если коллекция не пуста: - $collection = collect(['michael', 'tom']); +```php +$collection = collect(['michael', 'Tom']); - $collection->whenNotEmpty(function (Collection $collection) { - return $collection->push('adam'); - }); +$collection->whenNotEmpty(function (Collection $collection) { + return $collection->push('Adam'); +}); - $collection->all(); +$collection->all(); - // ['michael', 'tom', 'adam'] +// ['Michael', 'Tom', 'Adam'] - $collection = collect(); +$collection = collect(); - $collection->whenNotEmpty(function (Collection $collection) { - return $collection->push('adam'); - }); +$collection->whenNotEmpty(function (Collection $collection) { + return $collection->push('Adam'); +}); - $collection->all(); +$collection->all(); - // [] +// [] +``` Второе замыкание может быть передано методу `whenNotEmpty`, которое будет выполняться, если коллекция пуста: - $collection = collect(); +```php +$collection = collect(); - $collection->whenNotEmpty(function (Collection $collection) { - return $collection->push('adam'); - }, function (Collection $collection) { - return $collection->push('taylor'); - }); +$collection->whenNotEmpty(function (Collection $collection) { + return $collection->push('Adam'); +}, function (Collection $collection) { + return $collection->push('Taylor'); +}); - $collection->all(); +$collection->all(); - // ['taylor'] +// ['Taylor'] +``` -Противоположным методу `whenNotEmpty` является метод [`whenEmpty`](#method-whenempty). +Противоположным методу `whenNotEmpty` является метод [whenEmpty](#method-whenempty). #### `where()` Метод `where` фильтрует коллекцию по указанной паре ключ / значение: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Chair', 'price' => 100], - ['product' => 'Bookcase', 'price' => 150], - ['product' => 'Door', 'price' => 100], - ]); +```php +$collection = collect([ + ['product' => 'Desk', 'price' => 200], + ['product' => 'Chair', 'price' => 100], + ['product' => 'Bookcase', 'price' => 150], + ['product' => 'Door', 'price' => 100], +]); - $filtered = $collection->where('price', 100); +$filtered = $collection->where('price', 100); - $filtered->all(); +$filtered->all(); - /* - [ - ['product' => 'Chair', 'price' => 100], - ['product' => 'Door', 'price' => 100], - ] - */ +/* + [ + ['product' => 'Chair', 'price' => 100], + ['product' => 'Door', 'price' => 100], + ] +*/ +``` -Метод `where` использует «гибкое» сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [`whereStrict`](#method-wherestrict) для фильтрации с использованием «жесткого» сравнения. +Метод `where` использует «гибкое» сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [whereStrict](#method-wherestrict) для фильтрации с использованием «жесткого» сравнения. При желании вы можете передать оператор сравнения в качестве второго параметра. Поддерживаемые операторы: '===', '!==', '!=', '==', '=', '<>', '>', '<', '>=', и '<=': - $collection = collect([ - ['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'], - ['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'], - ['name' => 'Sue', 'deleted_at' => null], - ]); +```php +$collection = collect([ + ['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'], + ['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'], + ['name' => 'Sue', 'deleted_at' => null], +]); - $filtered = $collection->where('deleted_at', '!=', null); +$filtered = $collection->where('deleted_at', '!=', null); - $filtered->all(); +$filtered->all(); - /* - [ - ['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'], - ['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'], - ] - */ +/* + [ + ['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'], + ['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'], + ] +*/ +``` #### `whereStrict()` -Этот метод имеет ту же сигнатуру, что и метод [`where`](#method-where); однако, все значения сравниваются с использованием «жесткого» сравнения. +Этот метод имеет ту же сигнатуру, что и метод [where](#method-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], - ]); +```php +$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 = $collection->whereBetween('price', [100, 200]); - $filtered->all(); +$filtered->all(); - /* - [ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Bookcase', 'price' => 150], - ['product' => 'Door', 'price' => 100], - ] - */ +/* + [ + ['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], - ]); +```php +$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 = $collection->whereIn('price', [150, 200]); - $filtered->all(); +$filtered->all(); - /* - [ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Bookcase', 'price' => 150], - ] - */ +/* + [ + ['product' => 'Desk', 'price' => 200], + ['product' => 'Bookcase', 'price' => 150], + ] +*/ +``` -Метод `whereIn` использует «гибкое» сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [`whereInStrict`](#method-whereinstrict) для фильтрации с использованием «жесткого» сравнения. +Метод `whereIn` использует «гибкое» сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [whereInStrict](#method-whereinstrict) для фильтрации с использованием «жесткого» сравнения. #### `whereInStrict()` -Этот метод имеет ту же сигнатуру, что и метод [`whereIn`](#method-wherein); однако, все значения сравниваются с использованием «жесткого» сравнения. +Этот метод имеет ту же сигнатуру, что и метод [whereIn](#method-wherein); однако, все значения сравниваются с использованием «жесткого» сравнения. #### `whereInstanceOf()` Метод `whereInstanceOf` фильтрует коллекцию по указанному типу класса: - use App\Models\User; - use App\Models\Post; +```php +use App\Models\User; +use App\Models\Post; - $collection = collect([ - new User, - new User, - new Post, - ]); +$collection = collect([ + new User, + new User, + new Post, +]); - $filtered = $collection->whereInstanceOf(User::class); +$filtered = $collection->whereInstanceOf(User::class); - $filtered->all(); +$filtered->all(); - // [App\Models\User, App\Models\User] +// [App\Models\User, App\Models\User] +``` #### `whereNotBetween()` Метод `whereNotBetween` фильтрует коллекцию, определяя, находится ли переданное значение элемента вне указанного диапазона: - $collection = collect([ - ['product' => 'Desk', 'price' => 200], - ['product' => 'Chair', 'price' => 80], - ['product' => 'Bookcase', 'price' => 150], - ['product' => 'Pencil', 'price' => 30], - ['product' => 'Door', 'price' => 100], - ]); +```php +$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 = $collection->whereNotBetween('price', [100, 200]); - $filtered->all(); +$filtered->all(); - /* - [ - ['product' => 'Chair', 'price' => 80], - ['product' => 'Pencil', 'price' => 30], - ] - */ +/* + [ + ['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], - ]); +```php +$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 = $collection->whereNotIn('price', [150, 200]); - $filtered->all(); +$filtered->all(); - /* - [ - ['product' => 'Chair', 'price' => 100], - ['product' => 'Door', 'price' => 100], - ] - */ +/* + [ + ['product' => 'Chair', 'price' => 100], + ['product' => 'Door', 'price' => 100], + ] +*/ +``` -Метод `whereNotIn` использует «гибкое» сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [`whereNotInStrict`](#method-wherenotinstrict) для фильтрации с использованием «жесткого» сравнения. +Метод `whereNotIn` использует «гибкое» сравнение при проверке значений элементов, что означает, что строка с целым значением будет считаться равной целому числу того же значения. Используйте метод [whereNotInStrict](#method-wherenotinstrict) для фильтрации с использованием «жесткого» сравнения. #### `whereNotInStrict()` -Этот метод имеет ту же сигнатуру, что и метод [`whereNotIn`](#method-wherenotin); однако, все значения сравниваются с использованием «жесткого» сравнения. +Этот метод имеет ту же сигнатуру, что и метод [whereNotIn](#method-wherenotin); однако, все значения сравниваются с использованием «жесткого» сравнения. #### `whereNotNull()` Метод `whereNotNull` возвращает элементы из коллекции, для которых значение указанного ключа не равно `null`: - $collection = collect([ - ['name' => 'Desk'], - ['name' => null], - ['name' => 'Bookcase'], - ]); +```php +$collection = collect([ + ['name' => 'Desk'], + ['name' => null], + ['name' => 'Bookcase'], +]); - $filtered = $collection->whereNotNull('name'); +$filtered = $collection->whereNotNull('name'); - $filtered->all(); +$filtered->all(); - /* - [ - ['name' => 'Desk'], - ['name' => 'Bookcase'], - ] - */ +/* + [ + ['name' => 'Desk'], + ['name' => 'Bookcase'], + ] +*/ +``` #### `whereNull()` Метод `whereNull` возвращает элементы из коллекции, для которых значение указанного ключа равно `null`: - $collection = collect([ - ['name' => 'Desk'], - ['name' => null], - ['name' => 'Bookcase'], - ]); +```php +$collection = collect([ + ['name' => 'Desk'], + ['name' => null], + ['name' => 'Bookcase'], +]); - $filtered = $collection->whereNull('name'); +$filtered = $collection->whereNull('name'); - $filtered->all(); +$filtered->all(); - /* - [ - ['name' => null], - ] - */ +/* + [ + ['name' => null], + ] +*/ +``` #### `wrap()` Статический метод `wrap` оборачивает указанное значение в коллекцию, если это применимо: - use Illuminate\Support\Collection; +```php +use Illuminate\Support\Collection; - $collection = Collection::wrap('John Doe'); +$collection = Collection::wrap('John Doe'); - $collection->all(); +$collection->all(); - // ['John Doe'] +// ['John Doe'] - $collection = Collection::wrap(['John Doe']); +$collection = Collection::wrap(['John Doe']); - $collection->all(); +$collection->all(); - // ['John Doe'] +// ['John Doe'] - $collection = Collection::wrap(collect('John Doe')); +$collection = Collection::wrap(collect('John Doe')); - $collection->all(); +$collection->all(); - // ['John Doe'] +// ['John Doe'] +``` #### `zip()` Метод `zip` объединяет значения переданного массива со значениями исходной коллекции по их соответствующему индексу: - $collection = collect(['Chair', 'Desk']); +```php +$collection = collect(['Chair', 'Desk']); - $zipped = $collection->zip([100, 200]); +$zipped = $collection->zip([100, 200]); - $zipped->all(); +$zipped->all(); - // [['Chair', 100], ['Desk', 200]] +// [['Chair', 100], ['Desk', 200]] +``` ## Сообщения высшего порядка -Коллекции также обеспечивают поддержку «сообщений высшего порядка», которые являются сокращениями для выполнения общих действий с коллекциями. Методы коллекции, которые предоставляют сообщения высшего порядка: [`average`](#method-average), [`avg`](#method-avg), [`contains`](#method-contains), [`each`](#method-each), [`every`](#method-every), [`filter`](#method-filter), [`first`](#method-first), [`flatMap`](#method-flatmap), [`groupBy`](#method-groupby), [`keyBy`](#method-keyby), [`map`](#method-map), [`max`](#method-max), [`min`](#method-min), [`partition`](#method-partition), [`reject`](#method-reject), [`skipUntil`](#method-skipuntil), [`skipWhile`](#method-skipwhile), [`some`](#method-some), [`sortBy`](#method-sortby), [`sortByDesc`](#method-sortbydesc), [`sum`](#method-sum), [`takeUntil`](#method-takeuntil), [`takeWhile`](#method-takewhile), и [`unique`](#method-unique). +Коллекции также обеспечивают поддержку «сообщений высшего порядка», которые являются сокращениями для выполнения общих действий с коллекциями. Методы коллекции, которые предоставляют сообщения высшего порядка: [average](#method-average), [avg](#method-avg), [contains](#method-contains), [each](#method-each), [every](#method-every), [filter](#method-filter), [first](#method-first), [flatMap](#method-flatmap), [groupBy](#method-groupby), [keyBy](#method-keyby), [map](#method-map), [max](#method-max), [min](#method-min), [partition](#method-partition), [reject](#method-reject), [skipUntil](#method-skipuntil), [skipWhile](#method-skipwhile), [some](#method-some), [sortBy](#method-sortby), [sortByDesc](#method-sortbydesc), [sum](#method-sum), [takeUntil](#method-takeuntil), [takeWhile](#method-takewhile) и [unique](#method-unique). К каждому сообщению высшего порядка можно получить доступ как к динамическому свойству экземпляра коллекции. Например, давайте использовать сообщение высшего порядка `each`, вызывая метод для каждого объекта коллекции: - use App\Models\User; +```php +use App\Models\User; - $users = User::where('votes', '>', 500)->get(); +$users = User::where('votes', '>', 500)->get(); - $users->each->markAsVip(); +$users->each->markAsVip(); +``` Точно так же мы можем использовать сообщение высшего порядка `sum`, чтобы собрать общее количество «голосов» для коллекции пользователей: - $users = User::where('group', 'Development')->get(); +```php +$users = User::where('group', 'Development')->get(); - return $users->sum->votes; +return $users->sum->votes; +``` ## Отложенные коллекции @@ -3479,55 +3981,65 @@ $users->select(['name', 'role']); Например, представьте, что ваше приложение должно обрабатывать файл журнала размером в несколько гигабайт, используя при этом методы коллекций Laravel для анализа журналов. Вместо одновременного чтения всего файла в память можно использовать отложенные коллекции, чтобы сохранить в памяти только небольшую часть файла в текущий момент: - use App\Models\LogEntry; - use Illuminate\Support\LazyCollection; +```php +use App\Models\LogEntry; +use Illuminate\Support\LazyCollection; - LazyCollection::make(function () { - $handle = fopen('log.txt', 'r'); +LazyCollection::make(function () { + $handle = fopen('log.txt', 'r'); - while (($line = fgets($handle)) !== false) { - yield $line; - } - })->chunk(4)->map(function (array $lines) { - return LogEntry::fromLines($lines); - })->each(function (LogEntry $logEntry) { - // Обработка записи журнала... - }); + while (($line = fgets($handle)) !== false) { + yield $line; + } +})->chunk(4)->map(function (array $lines) { + return LogEntry::fromLines($lines); +})->each(function (LogEntry $logEntry) { + // Обработка записи журнала... +}); +``` Или представьте, что вам нужно перебрать 10 000 моделей Eloquent. При использовании традиционных коллекций Laravel все 10 000 моделей Eloquent должны быть загружены в память одновременно: - use App\Models\User; +```php +use App\Models\User; - $users = User::all()->filter(function (User $user) { - return $user->id > 500; - }); +$users = User::all()->filter(function (User $user) { + return $user->id > 500; +}); +``` Однако, метод `cursor` построителя запросов возвращает экземпляр `LazyCollection`. Это позволяет вам по-прежнему выполнять только один запрос к базе данных, но при этом одновременно загружать в память только одну модель Eloquent. В этом примере замыкание метода `filter` не выполнится до тех пор, пока мы на самом деле не переберем каждого пользователя индивидуально, что позволяет значительно сократить использование памяти: - use App\Models\User; +```php +use App\Models\User; - $users = User::cursor()->filter(function (User $user) { - return $user->id > 500; - }); +$users = User::cursor()->filter(function (User $user) { + return $user->id > 500; +}); - foreach ($users as $user) { - echo $user->id; - } +foreach ($users as $user) { + echo $user->id; +} +``` ### Создание отложенных коллекций Чтобы создать экземпляр отложенной коллекции, вы должны передать функцию генератора PHP методу `make` коллекции: - use Illuminate\Support\LazyCollection; +```php +use Illuminate\Support\LazyCollection; - LazyCollection::make(function () { - $handle = fopen('log.txt', 'r'); +LazyCollection::make(function () { + $handle = fopen('log.txt', 'r'); - while (($line = fgets($handle)) !== false) { - yield $line; - } - }); + while (($line = fgets($handle)) !== false) { + yield $line; + } + + fclose($handle); +}); +``` ### Контракт `Enumerable` @@ -3536,117 +4048,117 @@ $users->select(['name', 'role']);
-- [`all()`](#method-all) -- [`average()`](#method-average) -- [`avg()`](#method-avg) -- [`chunk()`](#method-chunk) -- [`chunkWhile()`](#method-chunkwhile) -- [`collapse()`](#method-collapse) -- [`collect()`](#method-collect) -- [`combine()`](#method-combine) -- [`concat()`](#method-concat) -- [`contains()`](#method-contains) -- [`containsStrict()`](#method-containsstrict) -- [`count()`](#method-count) -- [`countBy()`](#method-countBy) -- [`crossJoin()`](#method-crossjoin) -- [`dd()`](#method-dd) -- [`diff()`](#method-diff) -- [`diffAssoc()`](#method-diffassoc) -- [`diffKeys()`](#method-diffkeys) -- [`dump()`](#method-dump) -- [`duplicates()`](#method-duplicates) -- [`duplicatesStrict()`](#method-duplicatesstrict) -- [`each()`](#method-each) -- [`eachSpread()`](#method-eachspread) -- [`every()`](#method-every) -- [`except()`](#method-except) -- [`filter()`](#method-filter) -- [`first()`](#method-first) -- [`firstOrFail()`](#method-first-or-fail) -- [`firstWhere()`](#method-firstwhere) -- [`flatMap()`](#method-flatmap) -- [`flatten()`](#method-flatten) -- [`flip()`](#method-flip) -- [`forPage()`](#method-forpage) -- [`get()`](#method-get) -- [`groupBy()`](#method-groupby) -- [`has()`](#method-has) -- [`implode()`](#method-implode) -- [`intersect()`](#method-intersect) -- [`intersectAssoc()`](#method-intersectAssoc) -- [`intersectByKeys()`](#method-intersectbykeys) -- [`isEmpty()`](#method-isempty) -- [`isNotEmpty()`](#method-isnotempty) -- [`join()`](#method-join) -- [`keyBy()`](#method-keyby) -- [`keys()`](#method-keys) -- [`last()`](#method-last) -- [`macro()`](#method-macro) -- [`make()`](#method-make) -- [`map()`](#method-map) -- [`mapInto()`](#method-mapinto) -- [`mapSpread()`](#method-mapspread) -- [`mapToGroups()`](#method-maptogroups) -- [`mapWithKeys()`](#method-mapwithkeys) -- [`max()`](#method-max) -- [`median()`](#method-median) -- [`merge()`](#method-merge) -- [`mergeRecursive()`](#method-mergerecursive) -- [`min()`](#method-min) -- [`mode()`](#method-mode) -- [`nth()`](#method-nth) -- [`only()`](#method-only) -- [`pad()`](#method-pad) -- [`partition()`](#method-partition) -- [`pipe()`](#method-pipe) -- [`pluck()`](#method-pluck) -- [`random()`](#method-random) -- [`reduce()`](#method-reduce) -- [`reject()`](#method-reject) -- [`replace()`](#method-replace) -- [`replaceRecursive()`](#method-replacerecursive) -- [`reverse()`](#method-reverse) -- [`search()`](#method-search) -- [`shuffle()`](#method-shuffle) -- [`skip()`](#method-skip) -- [`slice()`](#method-slice) -- [`sole()`](#method-sole) -- [`some()`](#method-some) -- [`sort()`](#method-sort) -- [`sortBy()`](#method-sortby) -- [`sortByDesc()`](#method-sortbydesc) -- [`sortKeys()`](#method-sortkeys) -- [`sortKeysDesc()`](#method-sortkeysdesc) -- [`split()`](#method-split) -- [`sum()`](#method-sum) -- [`take()`](#method-take) -- [`tap()`](#method-tap) -- [`times()`](#method-times) -- [`toArray()`](#method-toarray) -- [`toJson()`](#method-tojson) -- [`union()`](#method-union) -- [`unique()`](#method-unique) -- [`uniqueStrict()`](#method-uniquestrict) -- [`unless()`](#method-unless) -- [`unlessEmpty()`](#method-unlessempty) -- [`unlessNotEmpty()`](#method-unlessnotempty) -- [`unwrap()`](#method-unwrap) -- [`values()`](#method-values) -- [`when()`](#method-when) -- [`whenEmpty()`](#method-whenempty) -- [`whenNotEmpty()`](#method-whennotempty) -- [`where()`](#method-where) -- [`whereStrict()`](#method-wherestrict) -- [`whereBetween()`](#method-wherebetween) -- [`whereIn()`](#method-wherein) -- [`whereInStrict()`](#method-whereinstrict) -- [`whereInstanceOf()`](#method-whereinstanceof) -- [`whereNotBetween()`](#method-wherenotbetween) -- [`whereNotIn()`](#method-wherenotin) -- [`whereNotInStrict()`](#method-wherenotinstrict) -- [`wrap()`](#method-wrap) -- [`zip()`](#method-zip) +- [all](#method-all) +- [average](#method-average) +- [avg](#method-avg) +- [chunk](#method-chunk) +- [chunkWhile](#method-chunkwhile) +- [collapse](#method-collapse) +- [collect](#method-collect) +- [combine](#method-combine) +- [concat](#method-concat) +- [contains](#method-contains) +- [containsStrict](#method-containsstrict) +- [count](#method-count) +- [countBy](#method-countBy) +- [crossJoin](#method-crossjoin) +- [dd](#method-dd) +- [diff](#method-diff) +- [diffAssoc](#method-diffassoc) +- [diffKeys](#method-diffkeys) +- [dump](#method-dump) +- [duplicates](#method-duplicates) +- [duplicatesStrict](#method-duplicatesstrict) +- [each](#method-each) +- [eachSpread](#method-eachspread) +- [every](#method-every) +- [except](#method-except) +- [filter](#method-filter) +- [first](#method-first) +- [firstOrFail](#method-first-or-fail) +- [firstWhere](#method-firstwhere) +- [flatMap](#method-flatmap) +- [flatten](#method-flatten) +- [flip](#method-flip) +- [forPage](#method-forpage) +- [get](#method-get) +- [groupBy](#method-groupby) +- [has](#method-has) +- [implode](#method-implode) +- [intersect](#method-intersect) +- [intersectAssoc](#method-intersectAssoc) +- [intersectByKeys](#method-intersectbykeys) +- [isEmpty](#method-isempty) +- [isNotEmpty](#method-isnotempty) +- [join](#method-join) +- [keyBy](#method-keyby) +- [keys](#method-keys) +- [last](#method-last) +- [macro](#method-macro) +- [make](#method-make) +- [map](#method-map) +- [mapInto](#method-mapinto) +- [mapSpread](#method-mapspread) +- [mapToGroups](#method-maptogroups) +- [mapWithKeys](#method-mapwithkeys) +- [max](#method-max) +- [median](#method-median) +- [merge](#method-merge) +- [mergeRecursive](#method-mergerecursive) +- [min](#method-min) +- [mode](#method-mode) +- [nth](#method-nth) +- [only](#method-only) +- [pad](#method-pad) +- [partition](#method-partition) +- [pipe](#method-pipe) +- [pluck](#method-pluck) +- [random](#method-random) +- [reduce](#method-reduce) +- [reject](#method-reject) +- [replace](#method-replace) +- [replaceRecursive](#method-replacerecursive) +- [reverse](#method-reverse) +- [search](#method-search) +- [shuffle](#method-shuffle) +- [skip](#method-skip) +- [slice](#method-slice) +- [sole](#method-sole) +- [some](#method-some) +- [sort](#method-sort) +- [sortBy](#method-sortby) +- [sortByDesc](#method-sortbydesc) +- [sortKeys](#method-sortkeys) +- [sortKeysDesc](#method-sortkeysdesc) +- [split](#method-split) +- [sum](#method-sum) +- [take](#method-take) +- [tap](#method-tap) +- [times](#method-times) +- [toArray](#method-toarray) +- [toJson](#method-tojson) +- [union](#method-union) +- [unique](#method-unique) +- [uniqueStrict](#method-uniquestrict) +- [unless](#method-unless) +- [unlessEmpty](#method-unlessempty) +- [unlessNotEmpty](#method-unlessnotempty) +- [unwrap](#method-unwrap) +- [values](#method-values) +- [when](#method-when) +- [whenEmpty](#method-whenempty) +- [whenNotEmpty](#method-whennotempty) +- [where](#method-where) +- [whereStrict](#method-wherestrict) +- [whereBetween](#method-wherebetween) +- [whereIn](#method-wherein) +- [whereInStrict](#method-whereinstrict) +- [whereInstanceOf](#method-whereinstanceof) +- [whereNotBetween](#method-wherenotbetween) +- [whereNotIn](#method-wherenotin) +- [whereNotInStrict](#method-wherenotinstrict) +- [wrap](#method-wrap) +- [zip](#method-zip)
@@ -3663,48 +4175,54 @@ $users->select(['name', 'role']); Метод `takeUntilTimeout` возвращает новую отложенную коллекцию, которая будет перечислять значения до указанного времени. По истечении этого времени коллекция перестанет перечислять: - $lazyCollection = LazyCollection::times(INF) - ->takeUntilTimeout(now()->addMinute()); +```php +$lazyCollection = LazyCollection::times(INF) + ->takeUntilTimeout(now()->addMinute()); - $lazyCollection->each(function (int $number) { - dump($number); +$lazyCollection->each(function (int $number) { + dump($number); - sleep(1); - }); + sleep(1); +}); - // 1 - // 2 - // ... - // 58 - // 59 +// 1 +// 2 +// ... +// 58 +// 59 +``` Чтобы проиллюстрировать использование этого метода, представьте приложение, которое отправляет счета из базы данных с помощью курсора. Вы можете определить [запланированную задачу](/docs/{{version}}/scheduling), которая запускается каждые 15 минут и обрабатывает счета максимум 14 минут: - use App\Models\Invoice; - use Illuminate\Support\Carbon; - - Invoice::pending()->cursor() - ->takeUntilTimeout( - Carbon::createFromTimestamp(LARAVEL_START)->add(14, 'minutes') - ) - ->each(fn (Invoice $invoice) => $invoice->submit()); +```php +use App\Models\Invoice; +use Illuminate\Support\Carbon; + +Invoice::pending()->cursor() + ->takeUntilTimeout( + Carbon::createFromTimestamp(LARAVEL_START)->add(14, 'minutes') + ) + ->each(fn (Invoice $invoice) => $invoice->submit()); +``` #### `tapEach()` В то время как метод `each` вызывает переданное замыкание для каждого элемента в коллекции сразу же, метод `tapEach` вызывает переданное замыкание только тогда, когда элементы извлекаются из списка один за другим: - // Пока ничего не выведено ... - $lazyCollection = LazyCollection::times(INF)->tapEach(function (int $value) { - dump($value); - }); +```php +// Пока ничего не выведено ... +$lazyCollection = LazyCollection::times(INF)->tapEach(function (int $value) { + dump($value); +}); - // Три элемента выведено ... - $array = $lazyCollection->take(3)->all(); +// Три элемента выведено ... +$array = $lazyCollection->take(3)->all(); - // 1 - // 2 - // 3 +// 1 +// 2 +// 3 +``` #### `throttle()` @@ -3727,13 +4245,15 @@ User::where('vip', true) Метод `remember` возвращает новую отложенную коллекцию, запоминающую любые значения, которые уже были перечислены, и не будет извлекать их снова при последующих перечислениях коллекции: - // Запрос еще не выполнен ... - $users = User::cursor()->remember(); +```php +// Запрос еще не выполнен ... +$users = User::cursor()->remember(); - // Запрос выполнен ... - // Первые 5 пользователей из базы данных включены в результирующий набор ... - $users->take(5)->all(); +// Запрос выполнен ... +// Первые 5 пользователей из базы данных включены в результирующий набор ... +$users->take(5)->all(); - // Первые 5 пользователей пришли из кеша коллекции ... - // Остальные из базы данных включены в результирующий набор ... - $users->take(20)->all(); +// Первые 5 пользователей пришли из кеша коллекции ... +// Остальные из базы данных включены в результирующий набор ... +$users->take(20)->all(); +```