laravel collection macros 다운로드 - laravel collection macros 소스 코드 다운로드

유용한 Laravel 컬렉션 매크로 세트

이 저장소에는 몇 가지 유용한 컬렉션 매크로가 포함되어 있습니다.

Spatie는 벨기에 앤트워프에 본사를 둔 웹 디자인 에이전시입니다. 당사 웹사이트에서 당사의 모든 오픈 소스 프로젝트에 대한 개요를 확인할 수 있습니다.

우리를 지원하세요

우리는 동급 최고의 오픈 소스 패키지를 만드는 데 많은 리소스를 투자합니다. 유료 제품 중 하나를 구매하여 우리를 지원할 수 있습니다.

귀하가 사용하고 있는 당사 패키지를 언급하면서 귀하의 고향에서 엽서를 보내주셔서 진심으로 감사드립니다. 연락처 페이지에서 주소를 확인하실 수 있습니다. 우리는 수신된 모든 엽서를 가상 엽서 월에 게시합니다.

설치

작곡가를 통해 패키지를 가져올 수 있습니다.

composer require spatie/laravel-collection-macros

패키지가 자동으로 등록됩니다.

매크로

after
at
- second
- third
- fourth
- fifth
- sixth
- seventh
- eighth
- ninth
- tenth
- getNth
before
catch
chunkBy
collectBy
containsAny
containsAll
eachCons
extract
filterMap
firstOrFail
firstOrPush
fromPairs
getCaseInsensitive
glob
groupByModel
hasCaseInsensitive
head
if
ifAny
ifEmpty
insertAfter
insertAfterKey
insertAt
insertBefore
insertBeforeKey
none
paginate
path
pluckMany
pluckManyValues
pluckToArray
prioritize
recursive
rotate
sectionBy
simplePaginate
sliceBefore
tail
try
toPairs
transpose
validate
weightedRandom
withSize

`after`

컬렉션에서 다음 항목을 가져옵니다.

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

$ currentItem = 2 ;

$ currentItem = $ collection -> after ( $ currentItem ); // return 3;
$ collection -> after ( $ currentItem ); // return null;

$ currentItem = $ collection -> after ( function ( $ item ) {
    return $ item > 1 ;
}); // return 3;

대체 매개변수로 사용할 두 번째 매개변수를 전달할 수도 있습니다.

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

$ currentItem = 3 ;

$ collection -> after ( $ currentItem , $ collection -> first ()); // return 1;

`at`

인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 ]);

$ data -> at ( 0 ); // 1
$ data -> at ( 1 ); // 2
$ data -> at (- 1 ); // 3

`second`

두 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> second (); // 2

`third`

세 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> third (); // 3

`fourth`

네 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> fourth (); // 4

`fifth`

다섯 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> fifth (); // 5

`sixth`

여섯 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> sixth (); // 6

`seventh`

일곱 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> seventh (); // 7

`eighth`

여덟 번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> eighth (); // 8

`ninth`

9번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> ninth (); // 9

`tenth`

10번째 인덱스에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> tenth (); // 10

`getNth`

n번째 항목에서 항목을 검색합니다.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 ]);

$ data -> getNth ( 11 ); // 11

`before`

컬렉션에서 이전 항목을 가져옵니다.

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

$ currentItem = 2 ;

$ currentItem = $ collection -> before ( $ currentItem ); // return 1;
$ collection -> before ( $ currentItem ); // return null;

$ currentItem = $ collection -> before ( function ( $ item ) {
    return $ item > 2 ;
}); // return 2;

대체 매개변수로 사용할 두 번째 매개변수를 전달할 수도 있습니다.

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

$ currentItem = 1 ;

$ collection -> before ( $ currentItem , $ collection -> last ()); // return 3;

`catch`

Try 보세요

`chunkBy`

주어진 콜백이 true인 한 컬렉션의 값을 그룹으로 묶습니다. 선택적 매개변수 $preserveKeys true 로 전달하면 원래 키가 유지됩니다.

 collect ([ ' A ' , ' A ' , ' B ' , ' A ' ])-> chunkBy ( function ( $ item ) {
    return $ item == ' A ' ;
}); // return Collection([['A', 'A'],['B'], ['A']])

`collectBy`

주어진 키에서 아이템을 얻고 수집하세요.

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

$ collection -> collectBy ( ' foo ' ); // Collection([1, 2, 3])

대체 매개변수로 사용할 두 번째 매개변수를 전달할 수도 있습니다.

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

$ collection -> collectBy ( ' baz ' , [ ' Nope ' ]); // Collection(['Nope'])

`containsAny`

주어진 값 중 하나 이상이 컬렉션에 존재하는 경우 true 반환합니다.

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

$ collection -> containsAny ([ ' b ' , ' c ' , ' d ' ]); // returns true
$ collection -> containsAny ([ ' c ' , ' d ' , ' e ' ]); // returns true
$ collection -> containsAny ([ ' d ' , ' e ' , ' f ' ]); // returns false
$ collection -> containsAny ([]); // returns false

`containsAll`

컬렉션에 주어진 모든 값이 존재하면 true 반환합니다.

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

$ collection -> containsAll ([ ' b ' , ' c ' ,]); // returns true
$ collection -> containsAll ([ ' c ' , ' d ' ]); // returns false
$ collection -> containsAll ([ ' d ' , ' e ' ]); // returns false
$ collection -> containsAll ([]); // returns true

`eachCons`

주어진 청크 크기에서 컬렉션의 다음 연속 이웃을 가져옵니다. 선택적 매개변수 $preserveKeys true 로 전달하면 원래 키가 유지됩니다.

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

`extract`

컬렉션에서 키를 추출합니다. 이는 only 와 매우 유사하지만 두 가지 주요 차이점이 있습니다.

extract 연관 배열이 아닌 값 배열을 반환합니다.
값이 존재하지 않으면 값을 생략하는 대신 null 로 채웁니다.

extract PHP 7.1 short list() 구문을 사용할 때 유용합니다.

[ $ name , $ role ] = collect ( $ user )-> extract ( ' name ' , ' role.name ' );

`filterMap`

컬렉션을 매핑하고 거짓 값을 한 번에 제거하세요.

 $ collection = collect ([ 1 , 2 , 3 , 4 , 5 , 6 ])-> filterMap ( function ( $ number ) {
    $ quotient = $ number / 3 ;

    return is_integer ( $ quotient ) ? $ quotient : null ;
});

$ collection -> toArray (); // returns [1, 2]

`firstOrFail`

첫 번째 항목을 가져옵니다. 항목을 찾을 수 없으면 SpatieCollectionMacrosExceptionsCollectionItemNotFound 가 발생합니다.

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

$ collection -> toArray (); // returns [1]

collect ([])-> firstOrFail (); // throws SpatieCollectionMacrosExceptionsCollectionItemNotFound

`firstOrPush`

첫 번째 매개변수로 주어진 콜러블을 사용하여 첫 번째 항목을 검색합니다. 값이 없으면 두 번째 매개변수의 값을 컬렉션에 푸시합니다. 두 번째 매개변수로 콜러블을 전달할 수 있습니다.

이 방법은 API 또는 계산 비용이 많이 드는 함수에서 검색한 값을 여러 번 사용하기 위해 컬렉션에 저장하려는 캐시된 클래스 속성을 처리할 때 정말 유용합니다.

 $ collection = collect ([ 1 , 2 , 3 ])-> firstOrPush ( fn ( $ item ) => $ item === 4 , 4 );

$ collection -> toArray (); // returns [1, 2, 3, 4]

경우에 따라 푸시할 대상 컬렉션을 지정하고 싶을 수도 있습니다. 이를 세 번째 매개변수로 전달할 수 있습니다.

 $ collection = collect ([ 1 , 2 , 3 ]);
$ collection -> filter ()-> firstOrPush ( fn ( $ item ) => $ item === 4 , 4 , $ collection );

$ collection -> toArray (); // returns [1, 2, 3, 4]

`fromPairs`

컬렉션을 연관 배열 형태의 컬렉션 항목으로 변환합니다.

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

$ collection -> toArray (); // returns ['a' => 'b', 'c' => 'd', 'e' => 'f']

`getCaseInsensitive`

특정 키의 값을 가져옵니다.

키가 문자열인 경우 대소문자를 구분하지 않는 비교를 사용하여 키를 검색합니다.

 $ collection = collect ([
    ' foo ' => ' bar ' ,
]);

$ collection -> getCaseInsensitive ( ' Foo ' ); // returns 'bar';

`glob`

glob() 결과의 컬렉션을 반환합니다.

Collection:: glob ( ' config/*.php ' );

`groupByModel`

groupBy 와 유사하지만 Eloquent 모델을 기준으로 컬렉션을 그룹화합니다. 키는 정수나 문자열이 아닌 객체이므로 결과는 별도의 배열로 나뉩니다.

 $ posts -> groupByModel ( ' category ' );

// [
//     [$categoryA, [/*...$posts*/]],
//     [$categoryB, [/*...$posts*/]],
// ];

전체 서명: groupByModel($callback, $preserveKeys, $modelKey, $itemsKey)

`hasCaseInsensitive`

컬렉션에 특정 이름의 키가 포함되어 있는지 확인합니다.

$key가 문자열이면 대소문자를 구분하지 않는 비교를 사용하여 키를 검색합니다.

 $ collection = collect ([
    ' foo ' => ' bar ' ,
]);

$ collection -> hasCaseInsensitive ( ' Foo ' ); // returns true;

`head`

컬렉션에서 첫 번째 항목을 검색합니다.

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

$ collection -> head (); // return 1

$ collection = collect ([]);

$ collection -> head (); // return null

`if`

if 매크로는 분기 컬렉션 체인에 도움이 될 수 있습니다. 이것은 이 매크로의 서명입니다:

 if (mixed $ if , mixed $ then = null , mixed $ else = null ): mixed

$if , $then 및 $else 모든 유형이 될 수 있습니다. 클로저가 이러한 매개변수 중 하나에 전달되면 해당 클로저가 실행되고 매크로는 그 결과를 사용합니다.

$if 실제 값을 반환하면 $then 이 반환되고, 그렇지 않으면 $else 반환됩니다.

다음은 몇 가지 예입니다.

 collect ()-> if ( true , then: true , else: false ); // returns true
collect ()-> if ( false , then: true , else: false ); // returns false

클로저가 $if , $then 또는 $else 에 전달되면 전체 컬렉션이 해당 클로저에 인수로 전달됩니다.

 // the `then` closure will be executed
// the first element of the returned collection now contains "THIS IS THE VALUE"
$ collection = collect ([ ' this is a value ' ])
    -> if (
        fn ( Collection $ collection ) => $ collection -> contains ( ' this is a value ' ),
        then: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => strtoupper ( $ item )),
        else: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => Str:: kebab ( $ item ))
    );

// the `else` closure will be executed
// the first element of the returned collection now contains "this-is-another-value"
$ collection = collect ([ ' this is another value ' ])
    -> if (
        fn ( Collection $ collection ) => $ collection -> contains ( ' this is a value ' ),
        then: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => strtoupper ( $ item )),
        else: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => Str:: kebab ( $ item ))
    );

`ifAny`

컬렉션이 비어 있지 않으면 전달된 콜러블을 실행합니다. 전체 컬렉션이 반환됩니다.

 collect ()-> ifAny ( function ( Collection $ collection ) { // empty collection so this won't get called
   echo ' Hello ' ;
});

collect ([ 1 , 2 , 3 ])-> ifAny ( function ( Collection $ collection ) { // non-empty collection so this will get called
   echo ' Hello ' ;
});

`ifEmpty`

컬렉션이 비어 있으면 전달된 콜러블을 실행합니다. 전체 컬렉션이 반환됩니다.

 collect ()-> ifEmpty ( function ( Collection $ collection ) { // empty collection so this will called
   echo ' Hello ' ;
});

collect ([ 1 , 2 , 3 ])-> ifEmpty ( function ( Collection $ collection ) { // non-empty collection so this won't get called
   echo ' Hello ' ;
});

`insertAfter`

지정된 항목이 처음 발생한 후에 항목을 삽입하고 업데이트된 Collection 인스턴스를 반환합니다. 선택적으로 키를 제공할 수 있습니다.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertAfter ( ' zero ' , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertAfter ( 0 , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

`insertAfterKey`

지정된 키 뒤에 항목을 삽입하고 업데이트된 Collection 인스턴스를 반환합니다. 선택적으로 새 항목의 키를 제공할 수 있습니다.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertAfterKey ( 0 , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertAfterKey ( ' zero ' , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

`insertAt`

지정된 인덱스에 항목을 삽입하고 업데이트된 Collection 인스턴스를 반환합니다. 선택적으로 키를 제공할 수 있습니다.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertAt ( 1 , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertAt ( 1 , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

`insertBefore`

지정된 항목이 처음 발생하기 전에 항목을 삽입하고 업데이트된 Collection 인스턴스를 반환합니다. 선택적으로 키를 제공할 수 있습니다.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertBefore ( ' two ' , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertBefore ( 2 , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

`insertBeforeKey`

지정된 키 앞에 항목을 삽입하고 업데이트된 Collection 인스턴스를 반환합니다. 선택적으로 새 항목의 키를 제공할 수 있습니다.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertBeforeKey ( 1 , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertBeforeKey ( ' two ' , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

`none`

컬렉션에 특정 항목, 키-값 쌍 또는 통과한 진실 테스트가 포함되어 있지 않은지 확인합니다. 이 함수는 contains 컬렉션 메서드와 동일한 매개변수를 허용합니다.

 collect ([ ' foo ' ])-> none ( ' bar ' ); // returns true
collect ([ ' foo ' ])-> none ( ' foo ' ); // returns false

collect ([[ ' name ' => ' foo ' ]])-> none ( ' name ' , ' bar ' ); // returns true
collect ([[ ' name ' => ' foo ' ]])-> none ( ' name ' , ' foo ' ); // returns false

collect ([ ' name ' => ' foo ' ])-> none ( function ( $ key , $ value ) {
   return $ key === ' name ' && $ value === ' bar ' ;
}); // returns true

`paginate`

컬렉션의 항목에 대한 LengthAwarePaginator 인스턴스를 만듭니다.

 collect ( $ posts )-> paginate ( 5 );

이는 페이지당 5개의 항목으로 $posts 의 내용을 페이지로 매깁니다. paginate 몇 가지 옵션을 허용합니다. 자세한 가이드는 Laravel 문서를 참조하세요.

 paginate(int $perPage = 15, string $pageName = 'page', ?int $page = null, ?int $total = null, array $options = [])

`path`

"점" 표기법을 사용하여 다차원 데이터가 포함된 컬렉션의 항목을 반환합니다. 네이티브 컬렉션의 pull 메서드와 동일한 방식으로 작동하지만 컬렉션에서 항목을 제거하지 않습니다.

 $ collection = new Collection ([
    ' foo ' => [
        ' bar ' => [
            ' baz ' => ' value ' ,
        ]
    ]
]);

$ collection -> path ( ' foo.bar.baz ' ) // 'value'

`pluckMany`

지정된 키만 포함된 컬렉션을 반환합니다.

 $ collection = collect ([
    [ ' a ' => 1 , ' b ' => 10 , ' c ' => 100 ],
    [ ' a ' => 2 , ' b ' => 20 , ' c ' => 200 ],
]);

$ collection -> pluckMany ([ ' a ' , ' b ' ]);

// returns
// collect([
//     ['a' => 1, 'b' => 10],
//     ['a' => 2, 'b' => 20],
// ]);

`pluckManyValues`

지정된 키 값만 포함된 컬렉션을 반환합니다.

 $ collection = collect ([
    [ ' a ' => 1 , ' b ' => 10 , ' c ' => 100 ],
    [ ' a ' => 2 , ' b ' => 20 , ' c ' => 200 ],
]);

$ collection -> pluckMany ([ ' a ' , ' b ' ]);

// returns
// collect([
//     [1, 10],
//     [2, 20],
// ]);

`pluckToArray`

주어진 키의 값 배열을 반환합니다.

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

$ collection -> pluckToArray ( ' a ' ); // returns [1, 2, 3]

`prioritize`

컬렉션의 시작 부분으로 요소를 이동합니다.

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

$ collection
   -> prioritize ( function ( array $ item ) {
      return $ item [ ' id ' ] === 2 ;
   })
   -> pluck ( ' id ' )
   -> toArray (); // returns [2, 1, 3]

`recursive`

재귀를 사용하여 배열과 그 하위 항목을 컬렉션으로 변환합니다.

 collect ([
  ' item ' => [
     ' children ' => []
  ]   
])-> recursive ();

// subsequent arrays are now collections

어떤 경우에는 모든 하위 항목을 컬렉션으로 전환하고 싶지 않을 수도 있습니다. 재귀적 방법에 숫자를 제공하여 특정 깊이까지만 변환할 수 있습니다.

 collect ([
  ' item ' => [
     ' children ' => [
        ' one ' => [ 1 ],
        ' two ' => [ 2 ]
     ]
  ]   
])-> recursive ( 1 ); // Collection(['item' => Collection(['children' => ['one' => [1], 'two' => [2]]])])

이는 특정 깊이에서는 필요하지 않거나 코드가 손상될 수 있다는 것을 알고 있을 때 유용할 수 있습니다.

 collect ([
  ' item ' => [
     ' children ' => [
        ' one ' => [ 1 ],
        ' two ' => [ 2 ]
     ]
  ]   
])
  -> recursive ( 1 )
  -> map ( function ( $ item ) {
    return $ item -> map ( function ( $ children ) {
      return $ children -> mapInto (Model::class);
    });
  }); // Collection(['item' => Collection(['children' => ['one' => Model(), 'two' => Model()]])])

// If we do not pass a max depth we will get the error "Argument #1 ($attributes) must be of type array"

`rotate`

주어진 오프셋으로 컬렉션의 항목을 회전합니다.

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

$ rotate = $ collection -> rotate ( 1 );

$ rotate -> toArray ();

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

`sectionBy`

컬렉션을 특정 키로 그룹화된 섹션으로 분할합니다. groupBy 와 유사하지만 컬렉션의 항목 순서를 존중하고 기존 키를 재사용합니다.

 $ collection = collect ([
    [ ' name ' => ' Lesson 1 ' , ' module ' => ' Basics ' ],
    [ ' name ' => ' Lesson 2 ' , ' module ' => ' Basics ' ],
    [ ' name ' => ' Lesson 3 ' , ' module ' => ' Advanced ' ],
    [ ' name ' => ' Lesson 4 ' , ' module ' => ' Advanced ' ],
    [ ' name ' => ' Lesson 5 ' , ' module ' => ' Basics ' ],
]);

$ collection -> sectionBy ( ' module ' );

// [
//     ['Basics', [
//         ['name' => 'Lesson 1', 'module' => 'Basics'],
//         ['name' => 'Lesson 2', 'module' => 'Basics'],
//     ]],
//     ['Advanced', [
//         ['name' => 'Lesson 3', 'module' => 'Advanced'],
//         ['name' => 'Lesson 4', 'module' => 'Advanced'],
//     ]],
//     ['Basics', [
//         ['name' => 'Lesson 5', 'module' => 'Basics'],
//     ]],
// ];

전체 서명: sectionBy($callback, $preserveKeys, $sectionKey, $itemsKey)

`simplePaginate`

컬렉션의 항목에 대한 Paginator 인스턴스를 만듭니다.

 collect ( $ posts )-> simplePaginate ( 5 );

이는 페이지당 5개의 항목으로 $posts 의 내용을 페이지로 매깁니다. simplePaginate 꽤 많은 옵션을 허용합니다. 자세한 가이드는 Laravel 문서를 참조하세요.

 simplePaginate(int $perPage = 15, string $pageName = 'page', ?int $page = null, ?int $total = null, array $options = [])

페이지 매김에 대한 심층적인 가이드는 Laravel 문서를 확인하세요.

`sliceBefore`

주어진 콜백이 true가 되기 전에 컬렉션에서 값을 잘라냅니다. 선택적 매개변수 $preserveKeys true 로 전달하면 원래 키가 유지됩니다.

 collect ([ 20 , 51 , 10 , 50 , 66 ])-> sliceBefore ( function ( $ item ) {
    return $ item > 50 ;
}); // return collect([[20],[51, 10, 50], [66])

`tail`

컬렉션에서 꼬리를 추출합니다. 따라서 첫 번째 요소를 제외한 모든 것입니다. 이는 slice(1)->values() 의 약어이지만 그럼에도 불구하고 매우 편리합니다. 선택적 매개변수인 $preserveKeys true 로 전달되면 키와 대체(fallback)가 slice(1) 로 유지됩니다.

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

`toPairs`

컬렉션을 쌍이 있는 배열로 변환합니다.

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

$ collection -> toArray (); // returns ['a', 'b'], ['c', 'd'], ['e', 'f']

`transpose`

전치의 목표는 다차원 배열을 회전하여 행을 열로, 열을 행으로 바꾸는 것입니다.

 collect ([
    [ ' Jane ' , ' Bob ' , ' Mary ' ],
    [ ' [email protected] ' , ' [email protected] ' , ' [email protected] ' ],
    [ ' Doctor ' , ' Plumber ' , ' Dentist ' ],
])-> transpose ()-> toArray ();

// [
//     ['Jane', '[email protected]', 'Doctor'],
//     ['Bob', '[email protected]', 'Plumber'],
//     ['Mary', '[email protected]', 'Dentist'],
// ]

`try`

try 와 catch 사이의 메서드 중 하나라도 예외를 발생시키는 경우 catch 에서 해당 예외를 처리할 수 있습니다.

 collect ([ ' a ' , ' b ' , ' c ' , 1 , 2 , 3 ])
    -> try ()
    -> map ( fn ( $ letter ) => strtoupper ( $ letter ))
    -> each ( function () {
        throw new Exception ( ' Explosions in the sky ' );
    })
    -> catch ( function ( Exception $ exception ) {
        // handle exception here
    })
    -> map ( function () {
        // further operations can be done, if the exception wasn't rethrow in the `catch`
    });

PHP에 익숙하도록 메서드 이름을 try / catch 로 지정했지만 컬렉션 자체는 데이터베이스 트랜잭션처럼 작동합니다. 따라서 예외가 발생하면 원래 컬렉션(시도 전)이 반환됩니다.

핸들러에 두 번째 매개변수를 추가하면 catch 내의 컬렉션에 액세스할 수 있습니다. 값을 반환하여 catch 내에서 컬렉션을 조작할 수도 있습니다.

 $ collection = collect ([ ' a ' , ' b ' , ' c ' , 1 , 2 , 3 ])
    -> try ()
    -> map ( function ( $ item ) {
        throw new Exception ();
    })
    -> catch ( function ( Exception $ exception , $ collection ) {
        return collect ([ ' d ' , ' e ' , ' f ' ]);
    })
    -> map ( function ( $ item ) {
        return strtoupper ( $ item );
    });

// ['D', 'E', 'F']

`validate`

주어진 $callback 이 모든 항목에 대해 true를 반환하면 true 반환합니다. $callback 이 문자열이거나 배열인 경우 유효성 검사 규칙으로 간주합니다.

 collect ([ ' foo ' , ' foo ' ])-> validate ( function ( $ item ) {
   return $ item === ' foo ' ;
}); // returns true


collect ([ ' [email protected] ' , ' bla ' ])-> validate ( ' email ' ); // returns false
collect ([ ' [email protected] ' , ' [email protected] ' ])-> validate ( ' email ' ); // returns true

`weightedRandom`

가중치를 기준으로 임의의 항목을 반환합니다. 이 예에서 a 있는 항목은 선택될 확률이 가장 높고 c 가 가장 적은 항목입니다.

 // pass the field name that should be used as a weight

$ randomItem = collect ([
    [ ' value ' => ' a ' , ' weight ' => 30 ],
    [ ' value ' => ' b ' , ' weight ' => 20 ],
    [ ' value ' => ' c ' , ' weight ' => 10 ],
])-> weightedRandom ( ' weight ' );

또는 콜러블을 전달하여 가중치를 가져올 수도 있습니다.

 $ randomItem = collect ([
    [ ' value ' => ' a ' , ' weight ' => 30 ],
    [ ' value ' => ' b ' , ' weight ' => 20 ],
    [ ' value ' => ' c ' , ' weight ' => 10 ],
])-> weightedRandom ( function ( array $ item ) {
   return $ item [ ' weight ' ];
});

`withSize`

지정된 양의 항목으로 새 컬렉션을 만듭니다.

Collection:: withSize ( 1 )-> toArray (); // return [1];
Collection:: withSize ( 5 )-> toArray (); // return [1,2,3,4,5];

변경 내역

최근 변경된 사항에 대한 자세한 내용은 CHANGELOG를 참조하세요.

테스트

$ composer test

기여

자세한 내용은 CONTRIBUTING을 참조하세요.

보안

보안 관련 버그를 발견한 경우 이슈 트래커를 사용하는 대신 [email protected]로 메일을 보내주세요.

크레딧

프리크 반 데르 헤르텐
세바스티안 드 데이네
모든 기여자

스파티 소개

특허

MIT 라이센스(MIT). 자세한 내용은 라이센스 파일을 참조하십시오.

확장하다