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

flatten を呼び出します。深さパラメータが渡されない場合、ネストされた配列は 1 次元に変換され、その後 ['iPhone 6S', 'Apple', 'Galaxy S7' 、「Samsung」] が返されます。深さパラメータを渡すと、返される配列のレベル数を制限できます。

flip

$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'],
    ]
*/

forget メソッドは、指定されたキーによってコレクションから対応するコンテンツを削除します:

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

{note} ほとんどのコレクション メソッドとは異なり、forget

forPage()

forPage メソッド指定されたページ番号のコレクション項目を含む新しいコレクション。このメソッドは、最初の引数としてページ番号を受け入れ、2 番目の引数としてページごとに表示されるアイテムの数を受け入れます:

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

get()

get メソッドは、指定されたキーを持つコレクション アイテムを返します。キーがコレクションに存在しない場合は、null

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

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

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

groupBy()

groupBy メソッドは、指定されたキーに基づいてコレクション項目をグループ化します:

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

コールバック関数を Replaces に渡すことができます文字列の キー 。このコールバック関数は、グループ化に使用するキーの値を返す必要があります。

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

複数のグループ化基準に配列を渡すことができます。各配列要素は、多次元配列内の対応するレベルに対応します:

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

#has()

has 指定されたキーがコレクションに存在するかどうかを確認するメソッド:

$data = new Collection([
    10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],    
    20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],    
    30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],    
    40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
  ]);
$result = $data->groupBy([
    'skill',    
    function ($item) {
          return $item['roles'];
              },
          ], 
        $preserveKeys = true);
/*
[
    1 => [
        'Role_1' => [
            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
        ],
        'Role_2' => [
            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
        ],
        'Role_3' => [
            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
        ],
    ],
    2 => [
        'Role_1' => [
            30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
        ],
        'Role_2' => [
            40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
        ],
    ],
];
*/

メソッドは、コレクション項目をマージするために使用されます。そのパラメータはコレクション項目のタイプによって異なります。コレクションに配列またはオブジェクトが含まれている場合は、結合したいプロパティのキーと、それらを「結合」するために値の間に入れたい文字列を渡す必要があります:

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

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

メソッドは、指定された array に存在しない値を元のコレクションから削除します。またはコレクション。生成されたコレクションは、元のコレクションのキーを保持します:

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

intersectByKeys

array またはコレクションに存在しないキーを元のコレクションから削除します:

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

コレクションが空の場合、isEmpty メソッドは

を返し、それ以外の場合は戻ります。 false：

$collection = collect([
    'serial' => 'UX301', 
    'type' => 'screen', 
    'year' => 2009
  ]);
$intersect = $collection->intersectByKeys([ 
   'reference' => 'UX404', 
   'type' => 'tab', 
   'year' => 2011
 ]);
$intersect->all();
// ['type' => 'screen', 'year' => 2009]

##isNotEmpty()

isNotEmpty メソッドは true

false を返します:

collect([])->isEmpty();
// true

##keyBy()

メソッドは、指定されたキーをコレクションのキーとして使用します。複数のコレクション項目が同じキーを持つ場合、新しいコレクションには最後のコレクション項目のみが表示されます。

collect([])->isNotEmpty();
// false

このメソッドでコールバック関数を渡すこともできます。このコールバック関数によって返された値は、コレクションのキーとして使用されます:

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

#keys()

$keyed = $collection->keyBy(function ($item) {
    return strtoupper($item['product_id']);
   });
$keyed->all();
/*
    [
        'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

last()

last このメソッドは、指定された条件テストに合格したコレクション内の最後の要素を返します。また、渡さないでください。 入力パラメータを指定して

メソッドを呼び出し、コレクション内の最後の要素を取得します。コレクションが空の場合は、null を返します:

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

staticmacro

Collection クラスにメソッドを追加できます。詳細については、Extended Collections のドキュメントを参照してください。

staticmake メソッドで A を作成できます新しいコレクションインスタンス。

」セクションを参照してください。

#map()

map メソッドはコレクションを走査しますおよびマージ 各値を指定されたコールバック関数に渡します。このコールバック関数はコレクション項目を任意に変更して返すことができ、それによって変更されたコレクション項目の新しいコレクションを生成します:

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

{note} 他のほとんどのコレクション メソッドと同様に、mapコレクション インスタンスが返されますが、元のコレクションは変更されません。元のコレクションを変更する場合は、

transform

メソッドを使用してください。

mapInto()

コレクションを反復処理し、コンストラクターに値を渡すことで指定されたクラスの新しいインスタンスを作成するメソッド:

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

mapSpread()

メソッドは、コレクション項目を走査し、ネストされた各項目の値を指定されたコールバック関数に割り当てることができます。コールバック関数はコレクション項目を自由に変更して返すことができ、それによって変更されたコレクション項目の新しいコレクションを生成します:

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

# # mapToGroups()

class Currency{    
         /**
     * Create a new currency instance.
     *
     * @param  string  $code
     * @return void
     */  
function __construct(string $code) 
   {     
      $this->code = $code;   
    }
  }
$collection = collect(['USD', 'EUR', 'GBP']);
$currencies = $collection->mapInto(Currency::class);
$currencies->all();
// [Currency('USD'), Currency('EUR'), Currency('GBP')]

mapWithKeys()

$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunks = $collection->chunk(2);
$sequence = $chunks->mapSpread(function ($even, $odd) {
    return $even + $odd;
  });
$sequence->all();
// [1, 5, 9, 13, 17]

$collection = collect([
    [   
         'name' => 'John Doe',        
         'department' => 'Sales',   
     ],   
     [    
         'name' => 'Jane Doe',        
         'department' => 'Sales',   
      ],    
      [   
           'name' => 'Johnny Doe',        
           'department' => 'Marketing',    
      ]
   ]);
$grouped = $collection->mapToGroups(function ($item, $key) {
    return [$item['department'] => $item['name']];
 });
$grouped->toArray();
/*
    [
        'Sales' => ['John Doe', 'Jane Doe'],
        'Marketing' => ['Johnny Doe'],
    ]
*/
$grouped->get('Sales')->all();
// ['John Doe', 'Jane Doe']

#

median()

median メソッドは、指定されたキーの 中央値 を返します:

$collection = collect([
    [     
       'name' => 'John',        
       'department' => 'Sales',        
       'email' => 'john@example.com'  
     ],   
    [   
         'name' => 'Jane',        
         'department' => 'Marketing',        
         'email' => 'jane@example.com'    
     ]
   ]);
$keyed = $collection->mapWithKeys(function ($item) { 
   return [$item['email'] => $item['name']];
 });
$keyed->all();
/*
    [
        'john@example.com' => 'John',
        'jane@example.com' => 'Jane',
    ]
*/

##merge()

merge メソッドは、指定された配列またはコレクションを元のコレクションにマージします。 。指定されたコレクション アイテムの文字列キーが元のコレクションの文字列キーと一致する場合、指定されたコレクション アイテムの値は元のコレクションの値を上書きします:

$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');
// 20
$max = collect([1, 2, 3, 4, 5])->max();
// 5

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

メソッドは、指定されたキーの最小値を返します:

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

mode

mode を返します:

$collection = collect(['Desk', 'Chair']);
$merged = $collection->merge(['Bookcase', 'Door']);
$merged->all();
// ['Desk', 'Chair', 'Bookcase', 'Door']

nth

$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
// 10
$min = collect([1, 2, 3, 4, 5])->min();
// 1

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

only メソッドは、コレクション内の指定されたキーを持つすべてのコレクション項目を返します。

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

と only は、

メソッドに対応します。 。

##pad()

メソッドは次の目的で使用されます。配列が指定されたサイズに達するまで、指定された値で配列を埋めます。このメソッドは、array_pad PHP 関数と同様に動作します。

左側を埋めるには、負の値を使用する必要があります。指定されたサイズの絶対値が配列の長さ以下の場合、パディングは行われません:

$collection->nth(4, 1);
// ['b', 'f']

partition( )

メソッドを PHP 関数の list と組み合わせて使用​​すると、指定された条件に合格する要素を分離し、そうでないもの:

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

pipe()

$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']

$collection = collect([1, 2, 3, 4, 5, 6]);
list($underThree, $equalOrAboveThree) = $collection->partition(function ($i) {
    return $i < 3;
   });
$underThree->all();
// [1, 2]
$equalOrAboveThree->all();
// [3, 4, 5, 6]

キーを指定してコレクションを生成することもできます2 番目のパラメータを渡すことによって:

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

重複するキーがある場合、最後に一致した要素がポップされたコレクションに挿入されます:

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

##

pop()

pop メソッドは、コレクションから最後のコレクション項目を削除して返します:

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

##prepend()

prepend メソッドは、指定された値をコレクションの先頭に追加します:

$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']

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

pull ( )

pull メソッドは、指定されたキーに対応する値をコレクションから削除し、次を返します:

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

メソッドは、指定された値をコレクション項目の末尾に追加します:

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

メソッドは、指定されたキーと値のペアをコレクション:

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

からのメソッドcollection ランダムな項目を返します:

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

に渡すことを選択できます。受け取りたい数量を明示的に渡す限り、アイテムのコレクションが返されます。

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

reduce メソッドの結果セットが 1 つの値に減らされるまで、反復の値は次の反復に渡されます。

$collection = collect([1, 2, 3, 4, 5]);
$collection->random();
// 4 - (retrieved randomly)

最初の反復の $carry の値は

です。ただし、2 番目の引数を reduce に渡すことで初期値を指定することもできます:

$random = $collection->random(3);
$random->all();
// [2, 4, 5] - (retrieved randomly)

reject メソッドは、指定されたコールバック関数を使用してコレクションをフィルターします。コールバック関数が

を返した場合、対応するコレクション項目がコレクションから削除されます。

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

filter # に対応します。 ＃＃＃＃＃ 方法。

#reverse()

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

search()

search メソッドは、コレクション内で指定された値を検索し、そのキーを返します。見つからない場合は、false が返されます。

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

検索には「緩和された」アプローチを使用します。つまり、整数値を持つ文字列は同じ値の整数と等しいと見なされます。 「厳密な」方法で検索するには、メソッドの 2 番目のパラメータとして true を渡します。

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

あるいは、コールバック関数を渡して、条件を渡す最初の文字列を検索することもできます。 test.コレクション アイテム:

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

shift()

shift メソッドは、コレクションの最初のコレクション項目を削除して返します:

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

##shuffle()

shuffle メソッドはコレクション項目をランダムにシャッフルします:

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

このメソッドは、指定されたインデックスから始まるコレクションの一部を返します。

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

$collection = collect([1, 2, 3, 4, 5]);
$shuffled = $collection->shuffle();
$shuffled->all();
// [3, 2, 5, 1, 4] - (generated randomly)

デフォルトでは、返されたコンテンツは元のキーを保持します。元のキーを保持したくない場合は、

values メソッドを使用してインデックスを再作成できます。

メソッドのエイリアス。

sort メソッドはコレクションを並べ替えます選別。並べ替えられたコレクションには元の配列のキーが保持されるため、この例では

values メソッドを使用してキーを連続番号のインデックスにリセットします。より高度な並べ替えが必要な場合は、独自のアルゴリズムを使用してコールバック関数を sort に渡すことができます。 uasort

については、PHP ドキュメントを参照してください。これは、コレクションの sort メソッドが内部で呼び出すものです。 {ヒント} ネストされた配列またはオブジェクトを並べ替える必要がある場合は、sortBy

sortByDesc #を参照してください。 ＃＃ 方法。 #

sortBy()

sortBy メソッドは、指定されたキーに基づいてコレクションを並べ替えます。並べ替えられたコレクションには元の配列のキーが保持されるため、この例では values メソッドを使用してキーを連続番号のインデックスにリセットします。独自のコールバック関数を渡して、コレクションの値を並べ替える方法を決定することもできます:

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

sortByDesc()

このメソッドは

sortBy メソッドと同じですが、コレクションを逆順に並べ替えます。

#sortKeys()

sortKeys

メソッドは、基になるassociation コレクションを並べ替える配列キー:

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

##sortKeysDesc()

メソッドsortKeys

メソッドと同じですが、コレクションを逆の順序で並べ替えます。

#splice()

splice メソッドは削除と戻り値を返します指定されたインデックスで始まるコレクション項目フラグメント:

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

2 番目のパラメーターを渡して、削除されるコンテンツのサイズを制限できます:

$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],
    ]
*/

さらに、新しいパラメーター項目を渡すこともできます3 番目のパラメーターは、コレクション内の削除されたコレクション項目を置き換えるのに使用されます:

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

##split()

split

メソッドは、指定された値に従ってコレクションを分割します:

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

##sum ( )

sum

このメソッドは、コレクション内のすべての項目の合計を返します。

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

コレクションにネストされた配列またはオブジェクトが含まれる場合は、キーを渡す必要があります。 in 合計する値を指定します:

$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]

##take()

take

メソッドは、指定された数の項目を含む新しいコレクションを返します。

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

負の整数を渡して、コレクションの最後から指定した数の項目を取得することもできます:

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

##tap()

tap

メソッドは、指定されたコールバック関数をコレクションに渡します。これにより、特定の時点でコレクションを「タップ」し、そのコレクションに対して操作を実行できるようになります。コレクション自体に影響を与えることなく、コレクション アイテムを削除します。特定の操作:

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

times()

statictimes メソッドは、コールバック関数を指定された回数呼び出すことによって新しいコレクションを作成します:

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

Useこのメソッドは、ファクトリと組み合わせて使用​​して Eloquent モデルを作成できます:

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

#toArray()

toArray メソッドは、コレクションを PHP array に変換します。コレクションの値が Eloquent モデルの場合、それも配列に変換されます。

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

{note}

toArray は、すべてのコレクションのネストされたオブジェクトも配列に変換します。元の配列を取得したい場合は、all メソッドを使用できます。

toJson()

toJson

メソッド Convertコレクションを JSON 文字列に変換します:

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

##transform()

transform メソッドはコレクションを反復処理し、コレクション項目ごとに指定されたコールバック関数を呼び出します。コレクションの内容もコールバック関数の戻り値によって置き換えられます。

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

{note} ほとんどのコレクション メソッドとは異なり、transform

はコレクション自体を変更します。新しいコレクションを作成する場合は、

map メソッドを使用できます。

union()

union メソッドの追加指定された配列をコレクションに追加します。指定された配列に元のコレクションと同じキーが含まれている場合、元のコレクションの値は変更されません:

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

#unique()

unique メソッドは、コレクション内のすべての一意のアイテムを返します。返されたコレクションには元の配列のキーが保持されているため、この例では

values

メソッドを使用してキーを連続番号のインデックスにリセットします。ネストされた配列またはオブジェクトを操作する場合、一意性を判断するために使用するキーを指定できます:

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

独自のコールバック関数を渡すことによって項目の一意性を判断することもできます:

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

unique

メソッドは、項目値をチェックするときに「リラックス」モードの比較を使用します。これは、整数値を持つ文字列が同じ値に等しい整数として扱われることを意味します。

uniqueStrict

メソッドを使用して、「厳密」モードの比較を行うことができます。

#uniqueStrict()

このメソッドは

unique と同じです

方法は同じですが、すべての値は「strict」モードを使用して比較されます。

unless()

unless 渡された最初のパラメータが true でない場合、指定されたメソッドが実行されます。 コールバック関数:

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

と unless は、when メソッドに対応します。

#空でない場合()

空でない場合#メソッドの別名。

##空でない場合()

空の場合

#メソッドの別名。

unwrap()

static

unwrap

メソッドはコレクションを返します内部で使用可能な値:

$collection = collect([1 => ['a'], 2 => ['b']]);
$union = $collection->union([3 => ['c'], 1 => ['b']]);
$union->all();
// [1 => ['a'], 2 => ['b'], 3 => ['c']]

#values()

values

メソッドは、連続した番号にリセットされたキーを持つ新しいコレクションを返します:

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

when()

when

メソッド 渡された最初のパラメーターが

true の場合、指定されたコールバック関数が実行されます:

$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'],
    ]
*/

および

when は、unless

メソッドに対応します。

whenEmpty()

whenEmpty

メソッド (コレクション時) is 空の場合、指定されたコールバック関数が実行されます。

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

と whenEmpty

は、

whenNotEmpty

メソッドに対応します。

whenNotEmpty()

whenNotEmpty

コレクションが次の場合のメソッドnot 空の場合、指定されたコールバック関数が実行されます。

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

と whenNotEmpty は、

whenEmpty メソッドに対応します。

where()

where

メソッドは指定されたキー/値ペアのフィルター コレクション:

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

where メソッドは、コレクション項目の値をチェックするときに「リラックス」モードの比較を使用します。これは、整数値を持つ文字列が同じ整数と等しいとみなされることを意味します。価値。

whereStrict

メソッドを使用して、「厳密」モードの比較を実行できます。

#whereStrict()

このメソッドは where と同じです

この方法は似ていますが、異なる点は、「厳密」モードの比較が使用されることです。

whereBetween()

whereBetween このメソッドは、指定された範囲を使用してコレクションをフィルターします:

$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],
    ]
*/

whereIn()

whereIn は、指定された配列を含むキーと値のペアに基づいてコレクションをフィルターします。

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

whereIn メソッドは、「緩和された」比較を使用してコレクション項目の値をチェックします。これは、整数値を持つ文字列が同じ値に等しい整数として扱われることを意味します。 whereInStrict メソッドを使用して、「厳密」モードの比較を実行できます。

#whereInStrict()

このメソッドは

whereIn と同じです 方法は似ていますが、比較に「strict」モードが使用される点が異なります。

whereInstanceOf()

whereInstanceOf

指定されたメソッドに基づくコレクションをフィルターするクラス:

$collection = collect(['michael', 'tom']);
$collection->whenEmpty(function ($collection) {
    return $collection->push('adam');
  });
$collection->all();
// ['michael', 'tom']
$collection = collect();$collection->whenEmpty(function ($collection) {
    return $collection->push('adam');
  });
$collection->all();
 // ['adam']
$collection = collect(['michael', 'tom']);
$collection->whenEmpty(function($collection) {
    return $collection->push('adam');}, function($collection) {
        return $collection->push('taylor');
      });
$collection->all();
   // ['michael', 'tom', 'taylor']

whereNotBetween()

whereNotBetween

指定された範囲内でコレクションをフィルタリングするメソッド:

 $collection = collect(['michael', 'tom']);
 $collection->whenNotEmpty(function ($collection) {
    return $collection->push('adam');
   });
 $collection->all();
    // ['michael', 'tom', 'adam']
 $collection = collect();
 $collection->whenNotEmpty(function ($collection) {
     return $collection->push('adam');
   });
  $collection->all();
  // []
  $collection = collect();
  $collection->whenNotEmpty(function($collection) {
      return $collection->push('adam');
    }, 
  function($collection) {
        return $collection->push('taylor');
       });
   $collection->all();
 // ['taylor']

#whereNotIn()

whereNotIn このメソッドは、指定されたキーと、指定された配列を含まない値に基づいてコレクションをフィルターします。

$collection = collect([
    ['product' => 'Desk', 'price' => 200],    
    ['product' => 'Chair', 'price' => 100],    
    ['product' => 'Bookcase', 'price' => 150],    
    ['product' => 'Door', 'price' => 100],
  ]);
$filtered = $collection->where('price', 100);$filtered->all();
/*
    [
        ['product' => 'Chair', 'price' => 100],
        ['product' => 'Door', 'price' => 100],
    ]
*/

whereNotIn メソッドは「relaxed」を使用します。チェックするモード比較 コレクション項目の値。整数値を持つ文字列が同じ値に等しい整数として扱われることを意味します。

whereNotInStrict メソッドを使用して、「厳密」モードの比較を行うことができます。

whereNotInStrict()

このメソッドは

と同じですwhereNotIn

メソッドは似ていますが、比較に「strict」モードが使用される点が異なります。

wrap()

static

wrap メソッド (必要に応じて)次の場合、指定された値をコレクションに入れます:

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

##zip()

zip

メソッドは、指定された配列の値を、対応するインデックスにある元のコレクションの値とマージします:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],    
    ['product' => 'Chair', 'price' => 100],    
    ['product' => 'Bookcase', 'price' => 150],    
    ['product' => 'Door', 'price' => 100],
  ]);
$filtered = $collection->whereIn('price', [150, 200]);
$filtered->all();
/*
    [
        ['product' => 'Bookcase', 'price' => 150],
        ['product' => 'Desk', 'price' => 200],
    ]
*/

# #

高レベル メッセージング

コレクションは、一般的な操作のショートカットのコレクションである「高レベル メッセージング」のサポートも提供します。高次のメッセージングをサポートする収集メソッドは次のとおりです: average、avg、contains、それぞれの、すべての、フィルター、 first、フラットマップ、groupBy、keyBy、 マップ、max、min、パーティション、拒否、some、sortBy、sortByDesc、sum、および unique。

各高次メッセージ受け渡しには、コレクション インスタンスの動的プロパティとしてアクセスできます。たとえば、each 高次メッセージングを使用して、コレクション内の各オブジェクトのメソッドを呼び出します。

$collection = collect([
    new User,    
    new User,    
    new Post,
 ]);
return $collection->whereInstanceOf(User::class);

同様に、sum 高次メッセージングを使用して、次のことができます。ユーザー コレクション内の「投票」の合計数を収集します。

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

この記事は、LearnKu.com Web サイトで最初に公開されました。