laravel collection macros

一组有用的 Laravel 集合宏

该存储库包含一些有用的集合宏。

Spatie 是一家位于比利时安特卫普的网页设计机构。您可以在我们的网站上找到所有开源项目的概述。

支持我们

我们投入了大量资源来创建一流的开源包。您可以通过购买我们的一款付费产品来支持我们。

我们非常感谢您从家乡寄给我们一张明信片，并注明您正在使用我们的哪种套餐。您可以在我们的联系页面上找到我们的地址。我们在虚拟明信片墙上发布所有收到的明信片。

安装

您可以通过composer拉入包：

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

检索第九个索引处的项目。

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

$ data -> ninth (); // 9

tenth

检索第十个索引处的项目。

 $ 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 );

这对$posts的内容进行分页，每页 5 个项目。 paginate接受相当多的选项，请访问 Laravel 文档以获得深入的指南。

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

path

使用“点”表示法从具有多维数据的集合中返回项目。工作方式与本机 Collection 的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 );

这对$posts的内容进行分页，每页 5 个项目。 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被传递，它将保留键并回退到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 ，但集合本身的行为更像是数据库事务。因此，当抛出异常时，将返回原始集合（在 try 之前）。

您可以通过向处理程序添加第二个参数来访问 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]; 

变更日志

请参阅变更日志以了解最近更改的更多信息。

测试

$ composer test 

贡献

详细信息请参阅贡献。

安全

如果您发现有关安全的错误，请发送邮件至 [email protected]，而不是使用问题跟踪器。

制作人员

• 弗里克·范德赫滕
• 塞巴斯蒂安·德·戴因
• 所有贡献者

关于斯帕蒂

Spatie 是一家位于比利时安特卫普的网页设计机构。您可以在我们的网站上找到所有开源项目的概述。

执照

麻省理工学院许可证 (MIT)。请参阅许可证文件以获取更多信息。