컬렉션

소개
- 컬렉션 생성
- 컬렉션 확장
사용 가능한 메서드
고차 메시지
레이지 컬렉션

소개

Illuminate\Support\Collection 클래스는 데이터 배열을 처리하기 위한 유창하고 편리한 래퍼를 제공합니다. 예를 들어 다음 코드를 확인하십시오. collect 헬퍼를 사용하여 배열에서 새 컬렉션 인스턴스를 생성하고 각 요소에 대해 strtoupper 함수를 실행한 다음 모든 빈 요소를 제거합니다.

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

보시다시피 Collection 클래스를 사용하면 메서드를 체이닝하여 기본 배열의 유창한 매핑 및 축소를 수행할 수 있습니다. 일반적으로 컬렉션은 불변이며, 이는 모든 Collection 메서드가 완전히 새로운 Collection 인스턴스를 반환함을 의미합니다.

컬렉션 생성

위에서 언급했듯이 collect 헬퍼는 주어진 배열에 대한 새로운 Illuminate\Support\Collection 인스턴스를 반환합니다. 따라서 컬렉션 생성은 다음과 같이 간단합니다.

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

Eloquent 쿼리 결과는 항상 Collection 인스턴스로 반환됩니다.

컬렉션은 "매크로화"할 수 있으므로 런타임에 Collection 클래스에 추가 메서드를 추가할 수 있습니다. Illuminate\Support\Collection 클래스의 macro 메서드는 매크로가 호출될 때 실행될 클로저를 허용합니다. 매크로 클로저는 컬렉션 클래스의 실제 메서드인 것처럼 $this를 통해 컬렉션의 다른 메서드에 접근할 수 있습니다. 예를 들어 다음 코드는 Collection 클래스에 toUpper 메서드를 추가합니다.

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
 
Collection::macro('toUpper', function () {
    return $this->map(function (string $value) {
        return Str::upper($value);
    });
});
 
$collection = collect(['first', 'second']);
 
$upper = $collection->toUpper();
 
// ['FIRST', 'SECOND']

일반적으로 서비스 공급자의 boot 메서드에서 컬렉션 매크로를 선언해야 합니다.

매크로 인수

필요한 경우 추가 인수를 허용하는 매크로를 정의할 수 있습니다.

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 = collect(['first', 'second']);
 
$translated = $collection->toLocale('es');

사용 가능한 메서드

나머지 컬렉션 문서의 대부분에서 Collection 클래스에서 사용할 수 있는 각 메서드에 대해 설명합니다. 이러한 모든 메서드를 체이닝하여 기본 배열을 유연하게 조작할 수 있음을 기억하십시오. 또한 거의 모든 메서드가 새로운 Collection 인스턴스를 반환하므로 필요한 경우 컬렉션의 원본 복사본을 보존할 수 있습니다.

after all average avg before chunk chunkWhile collapse collect combine concat contains containsOneItem containsStrict count countBy crossJoin dd diff diffAssoc diffAssocUsing diffKeys doesntContain dot dump duplicates duplicatesStrict each eachSpread ensure every except filter first firstOrFail firstWhere flatMap flatten flip forget forPage get groupBy has hasAny implode intersect intersectAssoc intersectByKeys isEmpty isNotEmpty join keyBy keys last lazy macro make map mapInto mapSpread mapToGroups mapWithKeys max median merge mergeRecursive min mode multiply nth only pad partition percentage pipe pipeInto pipeThrough pluck pop prepend pull push put random range reduce reduceSpread reject replace replaceRecursive reverse search select shift shuffle skip skipUntil skipWhile slice sliding sole some sort sortBy sortByDesc sortDesc sortKeys sortKeysDesc sortKeysUsing splice split splitIn sum take takeUntil takeWhile tap times toArray toJson transform undot union unique uniqueStrict unless unlessEmpty unlessNotEmpty unwrap value values when whenEmpty whenNotEmpty where whereStrict whereBetween whereIn whereInStrict whereInstanceOf whereNotBetween whereNotIn whereNotInStrict whereNotNull whereNull wrap zip

메서드 목록

`after()`

after 메서드는 주어진 항목 다음의 항목을 반환합니다. 주어진 항목을 찾을 수 없거나 마지막 항목인 경우 null이 반환됩니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->after(3);
 
// 4
 
$collection->after(5);
 
// null

이 메서드는 "느슨한" 비교를 사용하여 주어진 항목을 검색합니다. 즉, 정수 값을 포함하는 문자열은 동일한 값의 정수와 같은 것으로 간주됩니다. "엄격한" 비교를 사용하려면 메서드에 strict 인수를 제공할 수 있습니다.

collect([2, 4, 6, 8])->after('4', strict: true);
 
// null

또는 주어진 진실 테스트를 통과하는 첫 번째 항목을 검색하기 위해 자신의 클로저를 제공할 수 있습니다.

collect([2, 4, 6, 8])->after(function (int $item, int $key) {
    return $item > 5;
});
 
// 8

`all()`

all 메서드는 컬렉션으로 표현되는 기본 배열을 반환합니다.

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

`average()`

avg 메서드의 별칭입니다.

`avg()`

avg 메서드는 주어진 키의 평균 값을 반환합니다.

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

`before()`

before 메서드는 after 메서드의 반대입니다. 주어진 항목 이전의 항목을 반환합니다. 주어진 항목을 찾을 수 없거나 첫 번째 항목인 경우 null이 반환됩니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->before(3);
 
// 2
 
$collection->before(1);
 
// null
 
collect([2, 4, 6, 8])->before('4', strict: true);
 
// null
 
collect([2, 4, 6, 8])->before(function (int $item, int $key) {
    return $item > 5;
});
 
// 4

`chunk()`

chunk 메서드는 컬렉션을 지정된 크기의 여러 개의 작은 컬렉션으로 나눕니다.

$collection = collect([1, 2, 3, 4, 5, 6, 7]);
 
$chunks = $collection->chunk(4);
 
$chunks->all();
 
// [[1, 2, 3, 4], [5, 6, 7]]

이 메서드는 Bootstrap과 같은 그리드 시스템을 사용하여 뷰에서 작업할 때 특히 유용합니다. 예를 들어 그리드에 표시할 Eloquent 모델 컬렉션이 있다고 가정해 보겠습니다.

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

`chunkWhile()`

chunkWhile 메서드는 주어진 콜백의 평가를 기반으로 컬렉션을 여러 개의 더 작은 컬렉션으로 나눕니다. 클로저에 전달되는 $chunk 변수를 사용하여 이전 요소를 검사할 수 있습니다.

$collection = collect(str_split('AABBCCCD'));
 
$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) {
    return $value === $chunk->last();
});
 
$chunks->all();
 
// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]

`collapse()`

collapse 메서드는 배열 컬렉션을 단일 평면 컬렉션으로 축소합니다.

$collection = collect([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]);
 
$collapsed = $collection->collapse();
 
$collapsed->all();
 
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

`collect()`

collect 메서드는 컬렉션에 현재 있는 항목들로 새로운 Collection 인스턴스를 반환합니다.

$collectionA = collect([1, 2, 3]);
 
$collectionB = $collectionA->collect();
 
$collectionB->all();
 
// [1, 2, 3]

collect 메서드는 주로 지연 컬렉션을 표준 Collection 인스턴스로 변환하는 데 유용합니다.

$lazyCollection = LazyCollection::make(function () {
    yield 1;
    yield 2;
    yield 3;
});
 
$collection = $lazyCollection->collect();
 
$collection::class;
 
// 'Illuminate\Support\Collection'
 
$collection->all();
 
// [1, 2, 3]

collect 메서드는 특히 Enumerable의 인스턴스가 있고 지연되지 않은 컬렉션 인스턴스가 필요한 경우에 유용합니다. collect()는 Enumerable 계약의 일부이므로 이를 사용하여 Collection 인스턴스를 안전하게 가져올 수 있습니다.

`combine()`

combine 메서드는 컬렉션의 값을 키로 사용하여 다른 배열 또는 컬렉션의 값과 결합합니다.

$collection = collect(['name', 'age']);
 
$combined = $collection->combine(['George', 29]);
 
$combined->all();
 
// ['name' => 'George', 'age' => 29]

`concat()`

concat 메서드는 주어진 array 또는 컬렉션의 값을 다른 컬렉션의 끝에 추가합니다.

$collection = collect(['John Doe']);
 
$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
 
$concatenated->all();
 
// ['John Doe', 'Jane Doe', 'Johnny Doe']

concat 메서드는 원본 컬렉션에 연결된 항목에 대한 키를 숫자 방식으로 다시 색인합니다. 연관 컬렉션에서 키를 유지하려면 merge 메서드를 참조하십시오.

`contains()`

contains 메서드는 컬렉션에 주어진 항목이 포함되어 있는지 확인합니다. contains 메서드에 클로저를 전달하여 주어진 진실 테스트와 일치하는 컬렉션에 요소가 있는지 확인할 수 있습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->contains(function (int $value, int $key) {
    return $value > 5;
});
 
// false

또는 contains 메서드에 문자열을 전달하여 컬렉션에 주어진 항목 값이 포함되어 있는지 확인할 수 있습니다.

$collection = collect(['name' => 'Desk', 'price' => 100]);
 
$collection->contains('Desk');
 
// true
 
$collection->contains('New York');
 
// false

contains 메서드에 키/값 쌍을 전달하여 컬렉션에 주어진 쌍이 있는지 확인할 수도 있습니다.

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
]);
 
$collection->contains('product', 'Bookcase');
 
// false

contains 메서드는 항목 값을 확인할 때 "느슨한" 비교를 사용합니다. 즉, 정수 값을 가진 문자열은 같은 값의 정수와 같은 것으로 간주됩니다. "엄격한" 비교를 사용하여 필터링하려면 containsStrict 메서드를 사용하십시오.

contains의 반대 기능을 보려면 doesntContain 메서드를 참조하십시오.

`containsOneItem()`

containsOneItem 메서드는 컬렉션에 단일 항목이 포함되어 있는지 확인합니다.

collect([])->containsOneItem();
 
// false
 
collect(['1'])->containsOneItem();
 
// true
 
collect(['1', '2'])->containsOneItem();
 
// false

`containsStrict()`

이 메서드는 contains 메서드와 동일한 서명을 갖지만 모든 값은 "엄격한" 비교를 사용하여 비교됩니다.

이 메서드의 동작은 Eloquent 컬렉션을 사용할 때 수정됩니다.

`count()`

count 메서드는 컬렉션의 총 항목 수를 반환합니다.

$collection = collect([1, 2, 3, 4]);
 
$collection->count();
 
// 4

`countBy()`

countBy 메서드는 컬렉션에서 값의 발생 횟수를 계산합니다. 기본적으로 메서드는 모든 요소의 발생 횟수를 계산하여 컬렉션에서 특정 "유형"의 요소를 계산할 수 있습니다.

$collection = collect([1, 2, 2, 2, 3]);
 
$counted = $collection->countBy();
 
$counted->all();
 
// [1 => 1, 2 => 3, 3 => 1]

countBy 메서드에 클로저를 전달하여 사용자 정의 값으로 모든 항목을 계산할 수 있습니다.

$collection = collect(['[email protected]', '[email protected]', '[email protected]']);
 
$counted = $collection->countBy(function (string $email) {
    return substr(strrchr($email, "@"), 1);
});
 
$counted->all();
 
// ['gmail.com' => 2, 'yahoo.com' => 1]

`crossJoin()`

crossJoin 메서드는 주어진 배열 또는 컬렉션 간에 컬렉션의 값을 교차 결합하여 가능한 모든 순열을 사용하여 데카르트 곱을 반환합니다.

$collection = collect([1, 2]);
 
$matrix = $collection->crossJoin(['a', 'b']);
 
$matrix->all();
 
/*
    [
        [1, 'a'],
        [1, 'b'],
        [2, 'a'],
        [2, 'b'],
    ]
*/
 
$collection = collect([1, 2]);
 
$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);
 
$matrix->all();
 
/*
    [
        [1, 'a', 'I'],
        [1, 'a', 'II'],
        [1, 'b', 'I'],
        [1, 'b', 'II'],
        [2, 'a', 'I'],
        [2, 'a', 'II'],
        [2, 'b', 'I'],
        [2, 'b', 'II'],
    ]
*/

`dd()`

dd 메서드는 컬렉션의 항목을 덤프하고 스크립트 실행을 종료합니다.

$collection = collect(['John Doe', 'Jane Doe']);
 
$collection->dd();
 
/*
    Collection {
        #items: array:2 [
            0 => "John Doe"
            1 => "Jane Doe"
        ]
    }
*/

스크립트 실행을 중지하지 않으려면 대신 dump 메서드를 사용하십시오.

`diff()`

diff 메서드는 해당 값을 기반으로 다른 컬렉션 또는 일반 PHP array에 대해 컬렉션을 비교합니다. 이 메서드는 주어진 컬렉션에 없는 원본 컬렉션의 값을 반환합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$diff = $collection->diff([2, 4, 6, 8]);
 
$diff->all();
 
// [1, 3, 5]

이 메서드의 동작은 Eloquent 컬렉션을 사용할 때 수정됩니다.

`diffAssoc()`

diffAssoc 메서드는 해당 키와 값을 기반으로 다른 컬렉션 또는 일반 PHP array에 대해 컬렉션을 비교합니다. 이 메서드는 주어진 컬렉션에 없는 원본 컬렉션의 키/값 쌍을 반환합니다.

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

`diffAssocUsing()`

diffAssoc와 달리, diffAssocUsing은 인덱스 비교를 위해 사용자 제공 콜백 함수를 허용합니다.

$collection = collect([
    'color' => 'orange',
    'type' => 'fruit',
    'remain' => 6,
]);
 
$diff = $collection->diffAssocUsing([
    'Color' => 'yellow',
    'Type' => 'fruit',
    'Remain' => 3,
], 'strnatcasecmp');
 
$diff->all();
 
// ['color' => 'orange', 'remain' => 6]

콜백은 0보다 작거나 같거나 큰 정수를 반환하는 비교 함수여야 합니다. 자세한 내용은 diffAssocUsing 메서드가 내부적으로 사용하는 PHP 함수인 array_diff_uassoc에 대한 PHP 설명서를 참조하십시오.

`diffKeys()`

diffKeys 메서드는 해당 키를 기반으로 다른 컬렉션 또는 일반 PHP array에 대해 컬렉션을 비교합니다. 이 메서드는 주어진 컬렉션에 없는 원본 컬렉션의 키/값 쌍을 반환합니다.

$collection = collect([
    'one' => 10,
    'two' => 20,
    'three' => 30,
    'four' => 40,
    'five' => 50,
]);
 
$diff = $collection->diffKeys([
    'two' => 2,
    'four' => 4,
    'six' => 6,
    'eight' => 8,
]);
 
$diff->all();
 
// ['one' => 10, 'three' => 30, 'five' => 50]

`doesntContain()`

doesntContain 메서드는 컬렉션에 주어진 항목이 포함되어 있지 않은지 확인합니다. doesntContain 메서드에 클로저를 전달하여 주어진 진실 테스트와 일치하는 컬렉션에 요소가 없는지 확인할 수 있습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->doesntContain(function (int $value, int $key) {
    return $value < 5;
});
 
// false

또는 doesntContain 메서드에 문자열을 전달하여 컬렉션에 주어진 항목 값이 포함되어 있지 않은지 확인할 수 있습니다.

$collection = collect(['name' => 'Desk', 'price' => 100]);
 
$collection->doesntContain('Table');
 
// true
 
$collection->doesntContain('Desk');
 
// false

doesntContain 메서드에 키/값 쌍을 전달하여 컬렉션에 주어진 쌍이 없는지 확인할 수도 있습니다.

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
]);
 
$collection->doesntContain('product', 'Bookcase');
 
// true

doesntContain 메서드는 항목 값을 확인할 때 "느슨한" 비교를 사용합니다. 즉, 정수 값을 가진 문자열은 같은 값의 정수와 같은 것으로 간주됩니다.

`dot()`

dot 메서드는 다차원 컬렉션을 "점" 표기법을 사용하여 깊이를 나타내는 단일 수준 컬렉션으로 평면화합니다.

$collection = collect(['products' => ['desk' => ['price' => 100]]]);
 
$flattened = $collection->dot();
 
$flattened->all();
 
// ['products.desk.price' => 100]

`dump()`

dump 메서드는 컬렉션의 항목을 덤프합니다.

$collection = collect(['John Doe', 'Jane Doe']);
 
$collection->dump();
 
/*
    Collection {
        #items: array:2 [
            0 => "John Doe"
            1 => "Jane Doe"
        ]
    }
*/

컬렉션을 덤프한 후 스크립트 실행을 중지하려면 대신 dd 메서드를 사용하십시오.

`duplicates()`

duplicates 메서드는 컬렉션에서 중복된 값을 검색하고 반환합니다.

$collection = collect(['a', 'b', 'a', 'c', 'b']);
 
$collection->duplicates();
 
// [2 => 'a', 4 => 'b']

컬렉션에 배열 또는 객체가 포함된 경우 중복 값을 확인하려는 속성의 키를 전달할 수 있습니다.

$employees = collect([
    ['email' => '[email protected]', 'position' => 'Developer'],
    ['email' => '[email protected]', 'position' => 'Designer'],
    ['email' => '[email protected]', 'position' => 'Developer'],
]);
 
$employees->duplicates('position');
 
// [2 => 'Developer']

`duplicatesStrict()`

이 메서드는 duplicates 메서드와 동일한 서명을 갖지만 모든 값은 "엄격한" 비교를 사용하여 비교됩니다.

`each()`

each 메서드는 컬렉션의 항목을 반복하고 각 항목을 클로저에 전달합니다.

$collection = collect([1, 2, 3, 4]);
 
$collection->each(function (int $item, int $key) {
    // ...
});

항목을 반복하는 것을 중지하려면 클로저에서 false를 반환할 수 있습니다.

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

`eachSpread()`

eachSpread 메서드는 컬렉션의 항목을 반복하면서 중첩된 각 항목 값을 주어진 콜백으로 전달합니다.

$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
 
$collection->eachSpread(function (string $name, int $age) {
    // ...
});

콜백에서 false를 반환하여 항목 반복을 중지할 수 있습니다.

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

`ensure()`

ensure 메서드는 컬렉션의 모든 요소가 지정된 유형 또는 유형 목록인지 확인하는 데 사용할 수 있습니다. 그렇지 않으면 UnexpectedValueException이 발생합니다.

return $collection->ensure(User::class);
 
return $collection->ensure([User::class, Customer::class]);

string, int, float, bool, array와 같은 기본 유형도 지정할 수 있습니다.

return $collection->ensure('int');

ensure 메서드는 서로 다른 유형의 요소가 나중에 컬렉션에 추가되지 않음을 보장하지 않습니다.

`every()`

every 메서드는 컬렉션의 모든 요소가 주어진 진실 테스트를 통과하는지 확인하는 데 사용할 수 있습니다.

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

컬렉션이 비어 있으면 every 메서드는 true를 반환합니다.

$collection = collect([]);
 
$collection->every(function (int $value, int $key) {
    return $value > 2;
});
 
// true

`except()`

except 메서드는 지정된 키가 있는 항목을 제외한 컬렉션의 모든 항목을 반환합니다.

$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
 
$filtered = $collection->except(['price', 'discount']);
 
$filtered->all();
 
// ['product_id' => 1]

except의 반대 기능을 보려면 only 메서드를 참조하십시오.

이 메서드의 동작은 Eloquent 컬렉션을 사용할 때 수정됩니다.

`filter()`

filter 메서드는 주어진 콜백을 사용하여 컬렉션을 필터링하여 주어진 진실 테스트를 통과하는 항목만 유지합니다.

$collection = collect([1, 2, 3, 4]);
 
$filtered = $collection->filter(function (int $value, int $key) {
    return $value > 2;
});
 
$filtered->all();
 
// [3, 4]

콜백이 제공되지 않으면 false와 동일한 컬렉션의 모든 항목이 제거됩니다.

$collection = collect([1, 2, 3, null, false, '', 0, []]);
 
$collection->filter()->all();
 
// [1, 2, 3]

filter의 반대 기능을 보려면 reject 메서드를 참조하십시오.

`first()`

first 메서드는 주어진 진실 테스트를 통과하는 컬렉션의 첫 번째 요소를 반환합니다.

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

인수 없이 first 메서드를 호출하여 컬렉션의 첫 번째 요소를 가져올 수도 있습니다. 컬렉션이 비어 있으면 null이 반환됩니다.

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

`firstOrFail()`

firstOrFail 메서드는 first 메서드와 동일하지만 결과가 없으면 Illuminate\Support\ItemNotFoundException 예외가 발생합니다.

collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) {
    return $value > 5;
});
 
// ItemNotFoundException 발생...

인수 없이 firstOrFail 메서드를 호출하여 컬렉션의 첫 번째 요소를 가져올 수도 있습니다. 컬렉션이 비어 있으면 Illuminate\Support\ItemNotFoundException 예외가 발생합니다.

collect([])->firstOrFail();
 
// ItemNotFoundException 발생...

`firstWhere()`

firstWhere 메서드는 주어진 키/값 쌍이 있는 컬렉션의 첫 번째 요소를 반환합니다.

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

비교 연산자를 사용하여 firstWhere 메서드를 호출할 수도 있습니다.

$collection->firstWhere('age', '>=', 18);
 
// ['name' => 'Diego', 'age' => 23]

where 메서드와 마찬가지로 firstWhere 메서드에 하나의 인수를 전달할 수 있습니다. 이 시나리오에서 firstWhere 메서드는 지정된 항목 키의 값이 "진실"인 첫 번째 항목을 반환합니다.

$collection->firstWhere('age');
 
// ['name' => 'Linda', 'age' => 14]

`flatMap()`

flatMap 메서드는 컬렉션을 반복하고 각 값을 주어진 클로저에 전달합니다. 클로저는 항목을 자유롭게 수정하고 반환하여 수정된 항목의 새 컬렉션을 형성할 수 있습니다. 그런 다음 배열은 한 수준씩 평면화됩니다.

$collection = collect([
    ['name' => 'Sally'],
    ['school' => 'Arkansas'],
    ['age' => 28]
]);
 
$flattened = $collection->flatMap(function (array $values) {
    return array_map('strtoupper', $values);
});
 
$flattened->all();
 
// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];

`flatten()`

flatten 메서드는 다차원 컬렉션을 단일 차원으로 평면화합니다.

$collection = collect([
    'name' => 'taylor',
    'languages' => [
        'php', 'javascript'
    ]
]);
 
$flattened = $collection->flatten();
 
$flattened->all();
 
// ['taylor', 'php', 'javascript'];

필요한 경우 flatten 메서드에 "깊이" 인수를 전달할 수 있습니다.

$collection = collect([
    'Apple' => [
        [
            'name' => 'iPhone 6S',
            'brand' => 'Apple'
        ],
    ],
    'Samsung' => [
        [
            'name' => 'Galaxy S7',
            'brand' => 'Samsung'
        ],
    ],
]);
 
$products = $collection->flatten(1);
 
$products->values()->all();
 
/*
    [
        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
        ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
    ]
*/

이 예제에서 깊이를 제공하지 않고 flatten을 호출하면 중첩된 배열도 평면화되어 ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']이 됩니다. 깊이를 제공하면 중첩된 배열이 평면화되는 수준 수를 지정할 수 있습니다.

`flip()`

flip 메서드는 컬렉션의 키를 해당 값으로 바꿉니다.

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
 
$flipped = $collection->flip();
 
$flipped->all();
 
// ['taylor' => 'name', 'laravel' => 'framework']

`forget()`

forget 메서드는 컬렉션에서 해당 키로 항목을 제거합니다.

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
 
// 단일 키 삭제...
$collection->forget('name');
 
// ['framework' => 'laravel']
 
// 여러 키 삭제...
$collection->forget(['name', 'framework']);
 
// []

다른 대부분의 컬렉션 메서드와 달리 forget은 새 수정된 컬렉션을 반환하지 않습니다. 호출된 컬렉션을 수정하고 반환합니다.

`forPage()`

forPage 메서드는 주어진 페이지 번호에 표시될 항목이 포함된 새 컬렉션을 반환합니다. 이 메서드는 페이지 번호를 첫 번째 인수로, 페이지당 표시할 항목 수를 두 번째 인수로 사용합니다.

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
 
$chunk = $collection->forPage(2, 3);
 
$chunk->all();
 
// [4, 5, 6]

`get()`

get 메서드는 주어진 키에서 항목을 반환합니다. 키가 존재하지 않으면 null이 반환됩니다.

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

선택적으로 두 번째 인수로 기본값을 전달할 수 있습니다.

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
 
$value = $collection->get('age', 34);
 
// 34

메서드의 기본값으로 콜백을 전달할 수도 있습니다. 지정된 키가 존재하지 않으면 콜백의 결과가 반환됩니다.

$collection->get('email', function () {
    return '[email protected]';
});
 
// [email protected]

`groupBy()`

groupBy 메서드는 주어진 키로 컬렉션의 항목을 그룹화합니다.

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

문자열 key를 전달하는 대신 콜백을 전달할 수 있습니다. 콜백은 그룹화하려는 키 값을 반환해야 합니다.

$grouped = $collection->groupBy(function (array $item, int $key) {
    return substr($item['account_id'], -3);
});
 
$grouped->all();
 
/*
    [
        'x10' => [
            ['account_id' => 'account-x10', 'product' => 'Chair'],
            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
        ],
        'x11' => [
            ['account_id' => 'account-x11', 'product' => 'Desk'],
        ],
    ]
*/

여러 그룹화 기준을 배열로 전달할 수 있습니다. 각 배열 요소는 다차원 배열 내의 해당 수준에 적용됩니다.

$data = new Collection([
    10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
    20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
    30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
    40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
]);
 
$result = $data->groupBy(['skill', function (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']],
        ],
    ],
    2 => [
        'Role_1' => [
            30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
        ],
        'Role_2' => [
            40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
        ],
    ],
];
*/

`has()`

has 메서드는 컬렉션에 주어진 키가 있는지 확인합니다.

$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
 
$collection->has('product');
 
// true
 
$collection->has(['product', 'amount']);
 
// true
 
$collection->has(['amount', 'price']);
 
// false

`hasAny()`

hasAny 메서드는 컬렉션에 주어진 키 중 하나라도 있는지 확인합니다.

$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
 
$collection->hasAny(['product', 'price']);
 
// true
 
$collection->hasAny(['name', 'price']);
 
// false

`implode()`

implode 메서드는 컬렉션의 항목을 조인합니다. 해당 인수는 컬렉션의 항목 유형에 따라 다릅니다. 컬렉션에 배열 또는 객체가 포함된 경우 조인하려는 속성의 키와 값 사이에 배치하려는 "접착제" 문자열을 전달해야 합니다.

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

컬렉션에 단순 문자열 또는 숫자 값이 포함된 경우 메서드에 유일한 인수로 "접착제"를 전달해야 합니다.

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

값을 조인할 때 형식을 지정하려는 경우 implode 메서드에 클로저를 전달할 수 있습니다.

$collection->implode(function (array $item, int $key) {
    return strtoupper($item['product']);
}, ', ');
 
// DESK, CHAIR

`intersect()`

intersect 메서드는 주어진 array 또는 컬렉션에 없는 원본 컬렉션의 모든 값을 제거합니다. 결과 컬렉션은 원본 컬렉션의 키를 유지합니다.

$collection = collect(['Desk', 'Sofa', 'Chair']);
 
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
 
$intersect->all();
 
// [0 => 'Desk', 2 => 'Chair']

이 메서드의 동작은 Eloquent 컬렉션을 사용할 때 수정됩니다.

`intersectAssoc()`

intersectAssoc 메서드는 원본 컬렉션을 다른 컬렉션 또는 array와 비교하여 주어진 모든 컬렉션에 있는```php $users = collect([ ['name' => 'User #1', 'email' => '[email protected]'], ['name' => 'User #2', 'email' => '[email protected]'], ])->multiply(3);

/* [ ['name' => 'User #1', 'email' => '[email protected]'], ['name' => 'User #2', 'email' => '[email protected]'], ['name' => 'User #1', 'email' => '[email protected]'], ['name' => 'User #2', 'email' => '[email protected]'], ['name' => 'User #1', 'email' => '[email protected]'], ['name' => 'User #2', 'email' => '[email protected]'], ] */

 
위 코드는 다음과 같이 작동합니다. `collect()` 함수를 사용하여 사용자 데이터를 담은 배열을 컬렉션으로 만듭니다. 그런 다음 `multiply(3)` 메소드를 사용하여 컬렉션의 내용을 3배로 복제합니다. 결과적으로, 원래 컬렉션의 모든 요소가 3번 반복되어 새로운 컬렉션이 생성됩니다. 주석으로 표시된 배열은 `multiply(3)` 메소드를 적용한 후의 결과입니다. 즉, `User #1`과 `User #2`의 정보가 각각 세 번씩 반복되어 나타납니다.
<a name="method-nth"></a>
#### `nth()` {.collection-method}
 
`nth` 메서드는 n번째 요소마다 새로운 컬렉션을 생성합니다.
 
    $collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
 
    $collection->nth(4);
 
    // ['a', 'e']
 
선택적으로 두 번째 인수로 시작 오프셋을 전달할 수 있습니다.
 
    $collection->nth(4, 1);
 
    // ['b', 'f']
 
<a name="method-only"></a>
#### `only()` {.collection-method}
 
`only` 메서드는 지정된 키를 가진 컬렉션의 항목을 반환합니다.
 
    $collection = collect([
        'product_id' => 1,
        'name' => 'Desk',
        'price' => 100,
        'discount' => false
    ]);
 
    $filtered = $collection->only(['product_id', 'name']);
 
    $filtered->all();
 
    // ['product_id' => 1, 'name' => 'Desk']
 
`only`의 반대는 [except](#method-except) 메서드를 참조하십시오.
 
> [!NOTE]
> 이 메서드의 동작은 [Eloquent 컬렉션](/docs/{{version}}/eloquent-collections#method-only)을 사용할 때 수정됩니다.
 
<a name="method-pad"></a>
#### `pad()` {.collection-method}
 
`pad` 메서드는 배열이 지정된 크기에 도달할 때까지 주어진 값으로 배열을 채웁니다. 이 메서드는 PHP 함수 [array_pad](https://secure.php.net/manual/en/function.array-pad.php)와 유사하게 작동합니다.
 
왼쪽으로 패딩하려면 음수 크기를 지정해야 합니다. 주어진 크기의 절대값이 배열 길이보다 작거나 같으면 패딩이 적용되지 않습니다.
 
    $collection = collect(['A', 'B', 'C']);
 
    $filtered = $collection->pad(5, 0);
 
    $filtered->all();
 
    // ['A', 'B', 'C', 0, 0]
 
    $filtered = $collection->pad(-5, 0);
 
    $filtered->all();
 
    // [0, 0, 'A', 'B', 'C']
 
<a name="method-partition"></a>
#### `partition()` {.collection-method}
 
`partition` 메서드는 PHP 배열 구조 분해와 결합하여 주어진 진실 테스트를 통과하는 요소와 그렇지 않은 요소를 분리할 수 있습니다.
 
    $collection = collect([1, 2, 3, 4, 5, 6]);
 
    [$underThree, $equalOrAboveThree] = $collection->partition(function (int $i) {
        return $i < 3;
    });
 
    $underThree->all();
 
    // [1, 2]
 
    $equalOrAboveThree->all();
 
    // [3, 4, 5, 6]
 
<a name="method-percentage"></a>
#### `percentage()` {.collection-method}
 
`percentage` 메서드는 주어진 진실 테스트를 통과하는 컬렉션 항목의 백분율을 빠르게 결정하는 데 사용할 수 있습니다.
```php
$collection = collect([1, 1, 2, 2, 2, 3]);
 
$percentage = $collection->percentage(fn ($value) => $value === 1);
 
// 33.33

기본적으로 백분율은 소수점 두 자리로 반올림됩니다. 그러나 메서드에 두 번째 인수를 제공하여 이 동작을 사용자 정의할 수 있습니다.

$percentage = $collection->percentage(fn ($value) => $value === 1, precision: 3);
 
// 33.333

`pipe()`

pipe 메서드는 컬렉션을 주어진 클로저에 전달하고 실행된 클로저의 결과를 반환합니다.

$collection = collect([1, 2, 3]);
 
$piped = $collection->pipe(function (Collection $collection) {
    return $collection->sum();
});
 
// 6

`pipeInto()`

pipeInto 메서드는 주어진 클래스의 새 인스턴스를 생성하고 컬렉션을 생성자에 전달합니다.

class ResourceCollection
{
    /**
     * 새로운 ResourceCollection 인스턴스를 생성합니다.
     */
    public function __construct(
        public Collection $collection,
    ) {}
}
 
$collection = collect([1, 2, 3]);
 
$resource = $collection->pipeInto(ResourceCollection::class);
 
$resource->collection->all();
 
// [1, 2, 3]

`pipeThrough()`

pipeThrough 메서드는 컬렉션을 주어진 클로저 배열에 전달하고 실행된 클로저의 결과를 반환합니다.

use Illuminate\Support\Collection;
 
$collection = collect([1, 2, 3]);
 
$result = $collection->pipeThrough([
    function (Collection $collection) {
        return $collection->merge([4, 5]);
    },
    function (Collection $collection) {
        return $collection->sum();
    },
]);
 
// 15

`pluck()`

pluck 메서드는 주어진 키에 대한 모든 값을 검색합니다.

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

결과 컬렉션의 키를 지정할 수도 있습니다.

$plucked = $collection->pluck('name', 'product_id');
 
$plucked->all();
 
// ['prod-100' => 'Desk', 'prod-200' => 'Chair']

pluck 메서드는 "점(.)" 표기법을 사용하여 중첩된 값을 검색하는 것도 지원합니다.

$collection = collect([
    [
        'name' => 'Laracon',
        'speakers' => [
            'first_day' => ['Rosa', 'Judith'],
        ],
    ],
    [
        'name' => 'VueConf',
        'speakers' => [
            'first_day' => ['Abigail', 'Joey'],
        ],
    ],
]);
 
$plucked = $collection->pluck('speakers.first_day');
 
$plucked->all();
 
// [['Rosa', 'Judith'], ['Abigail', 'Joey']]

중복된 키가 존재하는 경우, 마지막으로 일치하는 요소가 추출된 컬렉션에 삽입됩니다.

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

`pop()`

pop 메서드는 컬렉션에서 마지막 항목을 제거하고 반환합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->pop();
 
// 5
 
$collection->all();
 
// [1, 2, 3, 4]

정수를 pop 메서드에 전달하여 컬렉션 끝에서 여러 항목을 제거하고 반환할 수 있습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->pop(3);
 
// collect([5, 4, 3])
 
$collection->all();
 
// [1, 2]

`prepend()`

prepend 메서드는 컬렉션의 시작 부분에 항목을 추가합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->prepend(0);
 
$collection->all();
 
// [0, 1, 2, 3, 4, 5]

두 번째 인수를 전달하여 prepended된 항목의 키를 지정할 수도 있습니다.

$collection = collect(['one' => 1, 'two' => 2]);
 
$collection->prepend(0, 'zero');
 
$collection->all();
 
// ['zero' => 0, 'one' => 1, 'two' => 2]

`pull()`

pull 메서드는 키를 기준으로 컬렉션에서 항목을 제거하고 반환합니다.

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

`push()`

push 메서드는 컬렉션의 끝에 항목을 추가합니다.

$collection = collect([1, 2, 3, 4]);
 
$collection->push(5);
 
$collection->all();
 
// [1, 2, 3, 4, 5]

`put()`

put 메서드는 컬렉션에서 주어진 키와 값을 설정합니다.

$collection = collect(['product_id' => 1, 'name' => 'Desk']);
 
$collection->put('price', 100);
 
$collection->all();
 
// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]

`random()`

random 메서드는 컬렉션에서 임의의 항목을 반환합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->random();
 
// 4 - (임의로 검색됨)

random에 정수를 전달하여 무작위로 검색하려는 항목 수를 지정할 수 있습니다. 검색하려는 항목 수를 명시적으로 전달하면 항목 컬렉션이 항상 반환됩니다.

$random = $collection->random(3);
 
$random->all();
 
// [2, 4, 5] - (임의로 검색됨)

컬렉션 인스턴스에 요청된 항목보다 적은 항목이 있는 경우 random 메서드는 InvalidArgumentException을 throw합니다.

random 메서드는 현재 컬렉션 인스턴스를 받는 클로저도 허용합니다.

use Illuminate\Support\Collection;
 
$random = $collection->random(fn (Collection $items) => min(10, count($items)));
 
$random->all();
 
// [1, 2, 3, 4, 5] - (임의로 검색됨)

`range()`

range 메서드는 지정된 범위 사이의 정수를 포함하는 컬렉션을 반환합니다.

$collection = collect()->range(3, 6);
 
$collection->all();
 
// [3, 4, 5, 6]

`reduce()`

reduce 메서드는 컬렉션을 단일 값으로 줄이고 각 반복의 결과를 후속 반복으로 전달합니다.

$collection = collect([1, 2, 3]);
 
$total = $collection->reduce(function (?int $carry, int $item) {
    return $carry + $item;
});
 
// 6

첫 번째 반복에서 $carry의 값은 null입니다. 그러나 reduce에 두 번째 인수를 전달하여 초기 값을 지정할 수 있습니다.

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

reduce 메서드는 연관 컬렉션의 배열 키도 주어진 콜백으로 전달합니다.

$collection = collect([
    'usd' => 1400,
    'gbp' => 1200,
    'eur' => 1000,
]);
 
$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]);
});
 
// 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);
 
            $creditsRemaining -= $image->creditsRequired();
        }
 
        return [$creditsRemaining, $batch];
    }, $creditsAvailable, collect());

`reject()`

reject 메서드는 주어진 클로저를 사용하여 컬렉션을 필터링합니다. 항목을 결과 컬렉션에서 제거해야 하는 경우 클로저는 true를 반환해야 합니다.

$collection = collect([1, 2, 3, 4]);
 
$filtered = $collection->reject(function (int $value, int $key) {
    return $value > 2;
});
 
$filtered->all();
 
// [1, 2]

reject 메서드의 반대 기능은 filter 메서드를 참조하십시오.

`replace()`

replace 메서드는 merge와 유사하게 동작합니다. 그러나 문자열 키를 가진 일치하는 항목을 덮어쓰는 것 외에도 replace 메서드는 일치하는 숫자 키를 가진 컬렉션의 항목도 덮어씁니다.

$collection = collect(['Taylor', 'Abigail', 'James']);
 
$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);
 
$replaced->all();
 
// ['Taylor', 'Victoria', 'James', 'Finn']

`replaceRecursive()`

이 메서드는 replace와 같이 작동하지만 배열로 재귀하여 내부 값에 동일한 교체 프로세스를 적용합니다.

$collection = collect([
    'Taylor',
    'Abigail',
    [
        'James',
        'Victoria',
        'Finn'
    ]
]);
 
$replaced = $collection->replaceRecursive([
    'Charlie',
    2 => [1 => 'King']
]);
 
$replaced->all();
 
// ['Charlie', 'Abigail', ['James', 'King', 'Finn']]

`reverse()`

reverse 메서드는 컬렉션 항목의 순서를 반대로 바꾸고 원래 키를 보존합니다.

$collection = collect(['a', 'b', 'c', 'd', 'e']);
 
$reversed = $collection->reverse();
 
$reversed->all();
 
/*
    [
        4 => 'e',
        3 => 'd',
        2 => 'c',
        1 => 'b',
        0 => 'a',
    ]
*/

`search()`

search 메서드는 컬렉션에서 주어진 값을 검색하고 찾은 경우 해당 키를 반환합니다. 항목을 찾지 못하면 false가 반환됩니다.

$collection = collect([2, 4, 6, 8]);
 
$collection->search(4);
 
// 1

검색은 "느슨한" 비교를 사용하여 수행됩니다. 즉, 정수 값을 가진 문자열은 동일한 값의 정수와 같은 것으로 간주됩니다. "엄격한" 비교를 사용하려면 메서드에 두 번째 인수로 true를 전달합니다.

collect([2, 4, 6, 8])->search('4', strict: true);
 
// false

또는 주어진 참 테스트를 통과하는 첫 번째 항목을 검색하기 위해 사용자 정의 클로저를 제공할 수 있습니다.

collect([2, 4, 6, 8])->search(function (int $item, int $key) {
    return $item > 5;
});
 
// 2

`select()`

select 메서드는 SQL SELECT 문과 유사하게 컬렉션에서 주어진 키를 선택합니다.

$users = collect([
    ['name' => 'Taylor Otwell', 'role' => 'Developer', 'status' => 'active'],
    ['name' => 'Victoria Faith', 'role' => 'Researcher', 'status' => 'active'],
]);
 
$users->select(['name', 'role']);
 
/*
    [
        ['name' => 'Taylor Otwell', 'role' => 'Developer'],
        ['name' => 'Victoria Faith', 'role' => 'Researcher'],
    ],
*/

$users 컬렉션은 다음의 배열을 포함합니다:

[
    ['name' => 'Taylor Otwell', 'role' => 'Developer', 'status' => 'active'],
    ['name' => 'Victoria Faith', 'role' => 'Researcher', 'status' => 'active'],
]

$users->select(['name', 'role'])은 각 배열에서 'name'과 'role' 키만 선택합니다. 결과는 다음과 같습니다:

[
    ['name' => 'Taylor Otwell', 'role' => 'Developer'],
    ['name' => 'Victoria Faith', 'role' => 'Researcher'],
],

`shift()`

shift 메서드는 컬렉션에서 첫 번째 항목을 제거하고 반환합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->shift();
 
// 1
 
$collection->all();
 
// [2, 3, 4, 5]

컬렉션의 시작 부분에서 여러 항목을 제거하고 반환하기 위해 shift 메서드에 정수를 전달할 수 있습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->shift(3);
 
// collect([1, 2, 3])
 
$collection->all();
 
// [4, 5]

`shuffle()`

shuffle 메서드는 컬렉션의 항목들을 무작위로 섞습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$shuffled = $collection->shuffle();
 
$shuffled->all();
 
// [3, 2, 5, 1, 4] - (무작위로 생성됨)

`skip()`

skip 메서드는 컬렉션의 시작 부분에서 주어진 수의 요소를 제거한 새로운 컬렉션을 반환합니다.

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

`skipUntil()`

skipUntil 메서드는 주어진 콜백이 false를 반환하는 동안 컬렉션의 항목을 건너뜁니다. 콜백이 true를 반환하면 컬렉션의 나머지 모든 항목이 새로운 컬렉션으로 반환됩니다.

$collection = collect([1, 2, 3, 4]);
 
$subset = $collection->skipUntil(function (int $item) {
    return $item >= 3;
});
 
$subset->all();
 
// [3, 4]

주어진 값이 발견될 때까지 모든 항목을 건너뛰도록 skipUntil 메서드에 단순 값을 전달할 수도 있습니다.

$collection = collect([1, 2, 3, 4]);
 
$subset = $collection->skipUntil(3);
 
$subset->all();
 
// [3, 4]

주어진 값이 없거나 콜백이 true를 반환하지 않으면, skipUntil 메서드는 빈 컬렉션을 반환합니다.

`skipWhile()`

skipWhile 메서드는 주어진 콜백이 true를 반환하는 동안 컬렉션의 항목을 건너뜁니다. 콜백이 false를 반환하면 컬렉션의 나머지 모든 항목이 새로운 컬렉션으로 반환됩니다.

$collection = collect([1, 2, 3, 4]);
 
$subset = $collection->skipWhile(function (int $item) {
    return $item <= 3;
});
 
$subset->all();
 
// [4]

콜백이 false를 반환하지 않으면 skipWhile 메서드는 빈 컬렉션을 반환합니다.

`slice()`

slice 메서드는 주어진 인덱스에서 시작하는 컬렉션의 슬라이스를 반환합니다.

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

반환된 슬라이스의 크기를 제한하려면 메서드의 두 번째 인수로 원하는 크기를 전달합니다.

$slice = $collection->slice(4, 2);
 
$slice->all();
 
// [5, 6]

반환된 슬라이스는 기본적으로 키를 유지합니다. 원본 키를 유지하지 않으려면 values 메서드를 사용하여 키의 인덱스를 재설정할 수 있습니다.

`sliding()`

sliding 메서드는 컬렉션의 항목에 대한 "슬라이딩 윈도우" 뷰를 나타내는 새로운 청크 컬렉션을 반환합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$chunks = $collection->sliding(2);
 
$chunks->toArray();
 
// [[1, 2], [2, 3], [3, 4], [4, 5]]

이것은 eachSpread 메서드와 함께 사용하면 특히 유용합니다.

$transactions->sliding(2)->eachSpread(function (Collection $previous, Collection $current) {
    $current->total = $previous->total + $current->amount;
});

선택적으로 두 번째 "단계" 값을 전달할 수 있으며, 이는 각 청크의 첫 번째 항목 사이의 거리를 결정합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$chunks = $collection->sliding(3, step: 2);
 
$chunks->toArray();
 
// [[1, 2, 3], [3, 4, 5]]

`sole()`

sole 메서드는 주어진 진실성 테스트를 통과하는 컬렉션의 첫 번째 요소를 반환하지만 진실성 테스트가 정확히 하나의 요소와 일치하는 경우에만 해당됩니다.

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

sole 메서드에 키/값 쌍을 전달할 수도 있습니다. 그러면 주어진 쌍과 일치하는 컬렉션의 첫 번째 요소가 반환되지만 정확히 하나의 요소와 일치하는 경우에만 해당됩니다.

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

또는 컬렉션에 하나의 요소만 있는 경우 인수를 사용하지 않고 sole 메서드를 호출하여 컬렉션의 첫 번째 요소를 가져올 수도 있습니다.

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
]);
 
$collection->sole();
 
// ['product' => 'Desk', 'price' => 200]

sole 메서드에서 반환해야 하는 컬렉션에 요소가 없으면 \Illuminate\Collections\ItemNotFoundException 예외가 발생합니다. 반환해야 하는 요소가 둘 이상이면 \Illuminate\Collections\MultipleItemsFoundException이 발생합니다.

`some()`

contains 메서드의 별칭입니다.

`sort()`

sort 메서드는 컬렉션을 정렬합니다. 정렬된 컬렉션은 원래 배열 키를 유지하므로 다음 예에서는 values 메서드를 사용하여 키를 연속 번호가 매겨진 인덱스로 재설정합니다.

$collection = collect([5, 3, 1, 2, 4]);
 
$sorted = $collection->sort();
 
$sorted->values()->all();
 
// [1, 2, 3, 4, 5]

정렬 요구 사항이 더 고급인 경우 사용자 고유의 알고리즘으로 sort에 콜백을 전달할 수 있습니다. 컬렉션의 sort 메서드가 내부적으로 호출하는 uasort에 대한 PHP 문서를 참조하십시오.

중첩된 배열 또는 객체 컬렉션을 정렬해야 하는 경우 sortBy 및 sortByDesc 메서드를 참조하십시오.

`sortBy()`

sortBy 메서드는 주어진 키로 컬렉션을 정렬합니다. 정렬된 컬렉션은 원래 배열 키를 유지하므로 다음 예에서는 values 메서드를 사용하여 키를 연속 번호가 매겨진 인덱스로 재설정합니다.

$collection = collect([
    ['name' => 'Desk', 'price' => 200],
    ['name' => 'Chair', 'price' => 100],
    ['name' => 'Bookcase', 'price' => 150],
]);
 
$sorted = $collection->sortBy('price');
 
$sorted->values()->all();
 
/*
    [
        ['name' => 'Chair', 'price' => 100],
        ['name' => 'Bookcase', 'price' => 150],
        ['name' => 'Desk', 'price' => 200],
    ]
*/

sortBy 메서드는 두 번째 인수로 정렬 플래그를 허용합니다.

$collection = collect([
    ['title' => 'Item 1'],
    ['title' => 'Item 12'],
    ['title' => 'Item 3'],
]);
 
$sorted = $collection->sortBy('title', SORT_NATURAL);
 
$sorted->values()->all();
 
/*
    [
        ['title' => 'Item 1'],
        ['title' => 'Item 3'],
        ['title' => 'Item 12'],
    ]
*/

또는 컬렉션 값을 정렬하는 방법을 결정하기 위해 자체 클로저를 전달할 수 있습니다.

$collection = collect([
    ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
    ['name' => 'Chair', 'colors' => ['Black']],
    ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);
 
$sorted = $collection->sortBy(function (array $product, int $key) {
    return count($product['colors']);
});
 
$sorted->values()->all();
 
/*
    [
        ['name' => 'Chair', 'colors' => ['Black']],
        ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
        ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
    ]
*/

여러 속성으로 컬렉션을 정렬하려면 정렬 작업 배열을 sortBy 메서드에 전달할 수 있습니다. 각 정렬 작업은 정렬하려는 속성과 원하는 정렬 방향으로 구성된 배열이어야 합니다.

$collection = collect([
    ['name' => 'Taylor Otwell', 'age' => 34],
    ['name' => 'Abigail Otwell', 'age' => 30],
    ['name' => 'Taylor Otwell', 'age' => 36],
    ['name' => 'Abigail Otwell', 'age' => 32],
]);
 
$sorted = $collection->sortBy([
    ['name', 'asc'],
    ['age', 'desc'],
]);
 
$sorted->values()->all();
 
/*
    [
        ['name' => 'Abigail Otwell', 'age' => 32],
        ['name' => 'Abigail Otwell', 'age' => 30],
        ['name' => 'Taylor Otwell', 'age' => 36],
        ['name' => 'Taylor Otwell', 'age' => 34],
    ]
*/

여러 속성으로 컬렉션을 정렬할 때 각 정렬 작업을 정의하는 클로저를 제공할 수도 있습니다.

$collection = collect([
    ['name' => 'Taylor Otwell', 'age' => 34],
    ['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],
    ]
*/

`sortByDesc()`

이 메서드는 sortBy 메서드와 동일한 시그니처를 갖지만 컬렉션을 반대 순서로 정렬합니다.

`sortDesc()`

이 메서드는 컬렉션을 sort 메서드와 반대 순서로 정렬합니다.

$collection = collect([5, 3, 1, 2, 4]);
 
$sorted = $collection->sortDesc();
 
$sorted->values()->all();
 
// [5, 4, 3, 2, 1]

sort와 달리 sortDesc에 클로저를 전달할 수 없습니다. 대신 sort 메서드를 사용하고 비교를 반전해야 합니다.

`sortKeys()`

sortKeys 메서드는 기본 연결 배열의 키를 기준으로 컬렉션을 정렬합니다.

$collection = collect([
    'id' => 22345,
    'first' => 'John',
    'last' => 'Doe',
]);
 
$sorted = $collection->sortKeys();
 
$sorted->all();
 
/*
    [
        'first' => 'John',
        'id' => 22345,
        'last' => 'Doe',
    ]
*/

`sortKeysDesc()`

이 메서드는 sortKeys 메서드와 동일한 시그니처를 갖지만 컬렉션을 반대 순서로 정렬합니다.

`sortKeysUsing()`

sortKeysUsing 메서드는 콜백을 사용하여 기본 연결 배열의 키를 기준으로 컬렉션을 정렬합니다.

$collection = collect([
    'ID' => 22345,
    'first' => 'John',
    'last' => 'Doe',
]);
 
$sorted = $collection->sortKeysUsing('strnatcasecmp');
 
$sorted->all();
 
/*
    [
        'first' => 'John',
        'ID' => 22345,
        'last' => 'Doe',
    ]
*/

콜백은 0보다 작거나, 같거나, 큰 정수를 반환하는 비교 함수여야 합니다. 자세한 내용은 sortKeysUsing 메서드가 내부적으로 사용하는 PHP 함수인 uksort에 대한 PHP 문서를 참조하십시오.

`splice()`

splice 메서드는 지정된 인덱스에서 시작하는 항목의 슬라이스를 제거하고 반환합니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$chunk = $collection->splice(2);
 
$chunk->all();
 
// [3, 4, 5]
 
$collection->all();
 
// [1, 2]

두 번째 인수를 전달하여 결과 컬렉션의 크기를 제한할 수 있습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$chunk = $collection->splice(2, 1);
 
$chunk->all();
 
// [3]
 
$collection->all();
 
// [1, 2, 4, 5]

또한 세 번째 인수에 컬렉션에서 제거된 항목을 대체할 새 항목을 포함하여 전달할 수도 있습니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$chunk = $collection->splice(2, 1, [10, 11]);
 
$chunk->all();
 
// [3]
 
$collection->all();
 
// [1, 2, 10, 11, 4, 5]

`split()`

split 메서드는 컬렉션을 주어진 그룹 수로 나눕니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$groups = $collection->split(3);
 
$groups->all();
 
// [[1, 2], [3, 4], [5]]

`splitIn()`

splitIn 메서드는 컬렉션을 주어진 그룹 수로 나누고, 최종 그룹에 나머지를 할당하기 전에 비 최종 그룹을 완전히 채웁니다.

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
$groups = $collection->splitIn(3);
 
$groups->all();
 
// [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]

`sum()`

sum 메서드는 컬렉션의 모든 항목의 합계를 반환합니다.

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

컬렉션에 중첩된 배열 또는 객체가 포함된 경우 합계할 값을 결정하는 데 사용될 키를 전달해야 합니다.

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

또한 컬렉션에서 합계할 값을 결정하기 위해 자체 클로저를 전달할 수도 있습니다.

$collection = collect([
    ['name' => 'Chair', 'colors' => ['Black']],
    ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
    ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);
 
$collection->sum(function (array $product) {
    return count($product['colors']);
});
 
// 6

`take()`

take 메서드는 지정된 수의 항목으로 새 컬렉션을 반환합니다.

$collection = collect([0, 1, 2, 3, 4, 5]);
 
$chunk = $collection->take(3);
 
$chunk->all();
 
// [0, 1, 2]

음수를 전달하여 컬렉션의 끝에서 지정된 수의 항목을 가져올 수도 있습니다.

$collection = collect([0, 1, 2, 3, 4, 5]);
 
$chunk = $collection->take(-2);
 
$chunk->all();
 
// [4, 5]

`takeUntil()`

takeUntil 메서드는 주어진 콜백이 true를 반환할 때까지 컬렉션의 항목을 반환합니다.

$collection = collect([1, 2, 3, 4]);
 
$subset = $collection->takeUntil(function (int $item) {
    return $item >= 3;
});
 
$subset->all();
 
// [1, 2]

주어진 값을 찾을 때까지 항목을 가져오기 위해 takeUntil 메서드에 단순 값을 전달할 수도 있습니다.

$collection = collect([1, 2, 3, 4]);
 
$subset = $collection->takeUntil(3);
 
$subset->all();
 
// [1, 2]

주어진 값을 찾을 수 없거나 콜백이 true를 반환하지 않으면 takeUntil 메서드는 컬렉션의 모든 항목을 반환합니다.

`takeWhile()`

takeWhile 메서드는 주어진 콜백이 false를 반환할 때까지 컬렉션의 항목을 반환합니다.

$collection = collect([1, 2, 3, 4]);
 
$subset = $collection->takeWhile(function (int $item) {
    return $item < 3;
});
 
$subset->all();
 
// [1, 2]

콜백이 false를 반환하지 않으면 takeWhile 메서드는 컬렉션의 모든 항목을 반환합니다.

`tap()`

tap 메서드는 컬렉션을 주어진 콜백에 전달하여 특정 시점에서 컬렉션을 "탭"하고 컬렉션 자체에 영향을 주지 않고 항목에 대해 작업을 수행할 수 있도록 합니다. 그런 다음 컬렉션은 tap 메서드에 의해 반환됩니다.

collect([2, 4, 3, 1, 5])
    ->sort()
    ->tap(function (Collection $collection) {
        Log::debug('정렬 후 값', $collection->values()->all());
    })
    ->shift();
 
// 1

`times()`

정적 times 메서드는 주어진 클로저를 지정된 횟수만큼 호출하여 새 컬렉션을 만듭니다.

$collection = Collection::times(10, function (int $number) {
    return $number * 9;
});
 
$collection->all();
 
// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]

`toArray()`

toArray 메서드는 컬렉션을 일반 PHP array로 변환합니다. 컬렉션의 값이 Eloquent 모델인 경우 모델도 배열로 변환됩니다.

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

toArray는 Arrayable의 인스턴스인 컬렉션의 모든 중첩된 객체를 배열로 변환합니다. 컬렉션의 기본 원시 배열을 가져오려면 대신 all 메서드를 사용하십시오.

`toJson()`

toJson 메서드는 컬렉션을 JSON 직렬화된 문자열로 변환합니다.

$collection = collect(['name' => 'Desk', 'price' => 200]);
 
$collection->toJson();
 
// '{"name":"Desk", "price":200}'

`transform()`

transform 메서드는 컬렉션을 반복하고 컬렉션의 각 항목과 함께 주어진 콜백을 호출합니다. 컬렉션의 항목은 콜백에서 반환된 값으로 대체됩니다.

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->transform(function (int $item, int $key) {
    return $item * 2;
});
 
$collection->all();
 
// [2, 4, 6, 8, 10]

다른 대부분의 컬렉션 메서드와 달리 transform은 컬렉션 자체를 수정합니다. 대신 새 컬렉션을 만들려면 map 메서드를 사용하십시오.

`undot()`

undot 메서드는 "점" 표기법을 사용하는 1차원 컬렉션을 다차원 컬렉션으로 확장합니다.

$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->toArray();
 
/*
    [
        "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']]);
 
$union = $collection->union([3 => ['c'], 1 => ['d']]);
 
$union->all();
 
// [1 => ['a'], 2 => ['b'], 3 => ['c']]

`unique()`

unique 메서드는 컬렉션의 모든 고유한 항목을 반환합니다. 반환된 컬렉션은 원래 배열 키를 유지하므로 다음 예에서는 values 메서드를 사용하여 키를 연속 번호가 매겨진 인덱스로 재설정합니다.

$collection = collect([1, 1, 2, 2, 3, 4, 2]);
 
$unique = $collection->unique();
 
$unique->values()->all();
 
// [1, 2, 3, 4]

중첩된 배열 또는 객체를 처리할 때 고유성을 결정하는 데 사용되는 키를 지정할 수 있습니다.

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

마지막으로 고유성을 결정해야 하는 값을 지정하기 위해 자체 클로저를 unique 메서드에 전달할 수도 있습니다.

$unique = $collection->unique(function (array $item) {
    return $item['brand'].$item['type'];
});
 
$unique->values()->all();
 
/*
    [
        ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
        ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
        ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
        ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
    ]
*/

unique 메서드는 항목 값을 확인할 때 "느슨한" 비교를 사용합니다. 즉, 정수 값을 가진 문자열은 같은 값의 정수와 동일한 것으로 간주됩니다. "엄격한" 비교를 사용하여 필터링하려면 uniqueStrict 메서드를 사용하십시오.

이 메서드의 동작은 Eloquent 컬렉션을 사용할 때 수정됩니다.

`uniqueStrict()`

이 메서드는 unique 메서드와 동일한 시그니처를 갖지만 모든 값은 "엄격한" 비교를 사용하여 비교됩니다.

`unless()`

unless 메서드는 메서드에 제공된 첫 번째 인수가 true로 평가되지 않는 한 주어진 콜백을 실행합니다.

$collection = collect([1, 2, 3]);
 
$collection->unless(true, function (Collection $collection) {
    return $collection->push(4);
});
 
$collection->unless(false, function (Collection $collection) {
    return $collection->push(5);
});
 
$collection->all();
 
// [1, 2, 3, 5]

두 번째 콜백을 unless 메서드에 전달할 수 있습니다. unless 메서드에 제공된 첫 번째 인수가 true로 평가될 때 두 번째 콜백이 실행됩니다.

$collection = collect([1, 2, 3]);
 
$collection->unless(true, function (Collection $collection) {
    return $collection->push(4);
}, function (Collection $collection) {
    return $collection->push(5);
});
 
$collection->all();
 
// [1, 2, 3, 5]

unless의 반대는 when 메서드를 참조하십시오.

`unlessEmpty()`

whenNotEmpty 메서드의 별칭입니다.

`unlessNotEmpty()`

whenEmpty 메서드의 별칭입니다.

`unwrap()`

정적 unwrap 메서드는 해당되는 경우 주어진 값에서 컬렉션의 기본 항목을 반환합니다.

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

`value()`

value 메서드는 컬렉션의 첫 번째 요소에서 주어진 값을 검색합니다.

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Speaker', 'price' => 400],
]);
 
$value = $collection->value('price');
 
// 200

`values()`

values 메서드는 키가 연속적인 정수로 재설정된 새로운 컬렉션을 반환합니다.

$collection = collect([
    10 => ['product' => 'Desk', 'price' => 200],
    11 => ['product' => 'Desk', 'price' => 200],
]);
 
$values = $collection->values();
 
$values->all();
 
/*
    [
        0 => ['product' => 'Desk', 'price' => 200],
        1 => ['product' => 'Desk', 'price' => 200],
    ]
*/

`when()`

when 메서드는 메서드에 제공된 첫 번째 인수가 true로 평가될 때 주어진 콜백을 실행합니다. 컬렉션 인스턴스와 when 메서드에 제공된 첫 번째 인수가 클로저에 제공됩니다.

$collection = collect([1, 2, 3]);
 
$collection->when(true, function (Collection $collection, int $value) {
    return $collection->push(4);
});
 
$collection->when(false, function (Collection $collection, int $value) {
    return $collection->push(5);
});
 
$collection->all();
 
// [1, 2, 3, 4]

두 번째 콜백을 when 메서드에 전달할 수 있습니다. when 메서드에 제공된 첫 번째 인수가 false로 평가될 때 두 번째 콜백이 실행됩니다.

$collection = collect([1, 2, 3]);
 
$collection->when(false, function (Collection $collection, int $value) {
    return $collection->push(4);
}, function (Collection $collection) {
    return $collection```php

use App\Models\User;

User::where('vip', true) ->cursor() ->throttle(seconds: 1) ->each(function (User $user) { // 외부 API 호출... });

 
<a name="method-remember"></a>
#### `remember()` {.collection-method}
 
`remember` 메서드는 이미 열거된 값을 기억하고 이후 컬렉션 열거 시 다시 검색하지 않는 새로운 지연 컬렉션을 반환합니다.
 
    // 아직 쿼리가 실행되지 않았습니다...
    $users = User::cursor()->remember();
 
    // 쿼리가 실행됩니다...
    // 처음 5명의 사용자가 데이터베이스에서 하이드레이트됩니다...
    $users->take(5)->all();
 
    // 처음 5명의 사용자는 컬렉션의 캐시에서 가져옵니다...
    // 나머지는 데이터베이스에서 하이드레이트됩니다...
    $users->take(20)->all();