Laravel - 集合方法 - Collection

//创建集合
collect([1, 2, 3]);

//返回全部且为数组
$collection->all();

//返回集合中所有项目的平均值, 指定键名
$collection->avg('key');

//将集合拆成多个指定大小的较小集合
$collection = collect([1, 2, 3, 4, 5, 6, 7]);
$collection->chunk(4);
$chunks->toArray();

//将多个数组组成的集合折成单一数组集合
$collection = collect([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
$collapsed = $collection->collapse();
$collapsed->all();

//用来判断该集合是否含有指定的项目
$collection = collect(['name' => 'Desk', 'price' => 100]);
$collection->contains('Desk');
--- 闭包方法也可以 ---
$collection = collect([1, 2, 3, 4, 5]);
$collection->contains(function ($value, $key) {
return $value > 5;
});

//返回该集合内的项目总数
$collection = collect([1, 2, 3, 4]);
$collection->count();

//将集合与其它集合或纯 PHP 数组 进行值的比较，返回第一个集合中存在而第二个集合中不存在的值：
$collection = collect([1, 2, 3, 4, 5]);
$diff = $collection->diff([2, 4, 6, 8]);
$diff->all();

//将集合与其它集合或纯 PHP 数组 的「键」进行比较，返回第一个集合中存在而第二个集合中不存在「键」所对应的键值对：
$collection = collect([
    'one' => 10,
    'two' => 20,
    'three' => 30,
    'four' => 40,
    'five' => 50,
]);

$diff = $collection->diffKeys([
    'two' => 2,
    'four' => 4,
    'six' => 6,
    'eight' => 8,
]);

$diff->all();

// ['one' => 10, 'three' => 30, 'five' => 50]

//遍历集合中的项目，并将之传入回调函数
$collection = $collection->each(function ($item, $key) {
    //输入return false 可以跳出循环
    //return false
});

//判断集合中每一个元素是否都符合指定条件
collect([1, 2, 3, 4])->every(function ($value, $key) {
    return $value > 2;
});

//返回集合中除了指定键以外的所有项目
$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
$filtered = $collection->except(['price', 'discount']);

//使用回调函数筛选集合，只留下那些通过判断测试的项目
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->filter(function ($value, $key) {
    return $value > 2;
});

//返回集合第一个通过指定测试的元素,你也可以不传入参数使用 first 方法以获取集合中第一个元素
collect([1, 2, 3, 4])->first(function ($value, $key) {
    return $value > 2;
});

//对集合内所有子集遍历执行回调，并在最后转为一维集合
$collection = collect([
    ['name' => 'Sally'],
    ['school' => 'Arkansas'],
    ['age' => 28]
]);

$flattened = $collection->flatMap(function ($values) {
    return array_map('strtoupper', $values);
});

$flattened->all();

// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];

//将多维集合转为一维集合,仅仅保留值,如果传入了深度,就按深度降维
$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'],
    ]
*/

//将集合中的键和对应的数值进行互换
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$flipped = $collection->flip();
$flipped->all();
// ['taylor' => 'name', 'laravel' => 'framework']

//通过集合的键来移除掉集合中的一个项目, 不返回新集合,只在原集合上处理
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$collection->forget('name');
$collection->all();
// ['framework' => 'laravel']

//返回指定键的项目。如果该键不存在，则返回 null
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('name');

//---也可以是回调用函数
$collection->get('email', function () {
    return 'default-value';
});

//根据指定的「键」为集合内的项目分组
$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'],
        ],
    ]
*/

//检查集合中是否含有指定的「键」
$collection = collect(['account_id' => 1, 'product' => 'Desk']);
$collection->has('product');

//implode 方法合并集合中的项目。它的参数依集合中的项目类型而定。假如集合含有数组或对象，你应该传入你希望连接的属性的「键」，
以及你希望放在数值之间的拼接字符串
$collection = collect([
    ['account_id' => 1, 'product' => 'Desk'],
    ['account_id' => 2, 'product' => 'Chair'],
]);

$collection->implode('product', ', ');

// Desk, Chair

//移除任何指定 数组 或集合内所没有的数值。最终集合保存着原集合的键：
$collection = collect(['Desk', 'Sofa', 'Chair']);
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
$intersect->all();
// [0 => 'Desk', 2 => 'Chair']

//如果集合是空的，isEmpty 方法会返回 true：否则返回 false
collect([])->isEmpty();

//以指定键的值作为集合项目的键。如果几个数据项有相同的键，那在新集合中只显示最后一项：
$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'],
    ]
*/

--- 你也可以传入自己的回调函数，该函数应该返回集合的键的值：

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

//返回该集合所有的键：
$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']

//返回集合中，最后一个通过指定测试的元素
collect([1, 2, 3, 4])->last(function ($value, $key) {
    return $value < 3;
});
//2

你也可以不传入参数使用 last 方法以获取集合中最后一个元素。如果集合是空的，则会返回 null：
collect([1, 2, 3, 4])->last();
//4

//遍历整个集合并将每一个数值传入回调函数。回调函数可以任意修改并返回项目，形成修改过的项目组成的新集合
$collection = collect([1, 2, 3, 4, 5]);

$multiplied = $collection->map(function ($item, $key) {
    return $item * 2;
});

$multiplied->all();

// [2, 4, 6, 8, 10]

//遍历整个集合并将每一个数值传入回调函数。回调函数返回包含一个键值对的关联数组
$collection = collect([
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => '[email protected]'
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => '[email protected]'
    ]
]);

$keyed = $collection->mapWithKeys(function ($item) {
    return [$item['email'] => $item['name']];
});

$keyed->all();

/*
    [
        '[email protected]' => 'John',
        '[email protected]' => 'Jane',
    ]
*/

//计算指定键的最大值：
$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');
//20
$max = collect([1, 2, 3, 4, 5])->max();
//5

//合并数组进集合。数组「键」对应的数值会覆盖集合「键」对应的数值：
$collection = collect(['product_id' => 1, 'price' => 100]);
$merged = $collection->merge(['price' => 200, 'discount' => false]);
$merged->all();
// ['product_id' => 1, 'price' => 200, 'discount' => false]

//计算指定「键」的最小值
$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
// 10
$min = collect([1, 2, 3, 4, 5])->min();
// 1

//由每隔第 n 个元素组成一个新的集合
$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
$collection->nth(4);
// ['a', 'e']

--- 你也可以选择传入一个偏移量作为第二个参数
$collection->nth(4, 1);

//返回集合中指定键的所有项目
$collection = collect(['product_id' => 1, 'name' => 'Desk', 'price' => 100, 'discount' => false]);
$filtered = $collection->only(['product_id', 'name']);
$filtered->all();
// ['product_id' => 1, 'name' => 'Desk']

//结合 PHP 中的 list 方法来分开符合指定条件的元素以及那些不符合指定条件的元素：
$collection = collect([1, 2, 3, 4, 5, 6]);

list($underThree, $aboveThree) = $collection->partition(function ($i) {
    return $i < 3;
});

//将集合传给回调函数并返回结果
$collection = collect([1, 2, 3]);

$piped = $collection->pipe(function ($collection) {
    return $collection->sum();
});

//获取集合中指定「键」所有对应的值
$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']

//移除并返回集合最后一个项目
$collection = collect([1, 2, 3, 4, 5]);
$collection->pop();
//5

//在集合前面增加一项数组的值
$collection = collect([1, 2, 3, 4, 5]);
$collection->prepend(0);
// [0, 1, 2, 3, 4, 5]

--- 你可以传递第二个参数来设置新增加项的键：
$collection = collect(['one' => 1, 'two' => 2]);
$collection->prepend(0, 'zero');
// ['zero' => 0, 'one' => 1, 'two' => 2]

//把「键」对应的值从集合中移除并返回
$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);
$collection->pull('name');

// ['product_id' => 'prod-100']

//在集合的后面新添加一个元素
$collection = collect([1, 2, 3, 4]);
$collection->push(5);
// [1, 2, 3, 4, 5]

//在集合内设置一个「键/值」：
$collection = collect(['product_id' => 1, 'name' => 'Desk']);
$collection->put('price', 100);

//random 方法从集合中随机返回一个项目：
$collection = collect([1, 2, 3, 4, 5]);
$collection->random();

//reject 方法以指定的回调函数筛选集合。会移除掉那些通过判断测试（即结果返回 true）的项目：
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->reject(function ($value, $key) {
    return $value > 2;
});
$filtered->all();

//reverse 方法倒转集合内项目的顺序：
$collection = collect([1, 2, 3, 4, 5]);
$reversed = $collection->reverse();
$reversed->all();

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

//search 方法在集合内搜索指定的数值并返回找到的键。假如找不到项目，则返回 false：
$collection = collect([2, 4, 6, 8]);
$collection->search(4)

//shift 方法移除并返回集合的第一个项目
$collection = collect([1, 2, 3, 4, 5]);
$collection->shift();

// [2, 3, 4, 5]

//shuffle 方法随机排序集合的项目：
$collection = collect([1, 2, 3, 4, 5]);
$shuffled = $collection->shuffle();
$shuffled->all();
// [3, 2, 5, 1, 4] // (generated randomly)

//slice 方法返回集合从指定索引开始的一部分切片, 如果你想限制返回切片的大小，就传入想要的大小为方法的第二个参数：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$slice = $collection->slice(4, 2);
$slice->all();
// [5, 6]

//对集合排序。排序后的集合保留着原始数组的键，所以在这个例子里我们用 values 方法来把键设置为连续数字的键。
$collection = collect([5, 3, 1, 2, 4]);
$sorted = $collection->sort();
$sorted->values()->all();
// [1, 2, 3, 4, 5]

//以指定的键排序集合。排序后的集合保留了原始数组键，所以在这个例子中我们用 values method 把键设置为连续数字的索引建：
$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],
    ]
*/

--- 你也可以传入自己的回调函数以决定如何排序集合数值
$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']],
    ]
*/

//sortByDesc() 与 sortBy 有着一样的形式，但是会以相反的顺序来排序集合

//将集合按指定组数分解
$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();

//如果集合包含嵌套数组或对象，你应该传入一个「键」来指定要用哪些数值来计算总和：

//此外，你可以传入自己的回调函数来决定要用哪些数值来计算总和：

//返回有着指定数量项目的集合
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(3);

//[0, 1, 2]

你也可以传入负整数以获取从集合后面来算指定数量的项目
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(-2);

// [4, 5]

//将集合转换成纯 PHP 数组。假如集合的数值是 Eloquent 模型，也会被转换成数组
$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toArray();
/*
    [
        ['name' => 'Desk', 'price' => 200],
    ]
*/

//将集合转换成 JSON
$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toJson();
// '{"name":"Desk", "price":200}'

//将给定的数组合并到集合中，如果数组中含有与集合一样的「键」，集合的键值会被保留：
$collection = collect([1 => ['a'], 2 => ['b']]);
$union = $collection->union([3 => ['c'], 1 => ['b']]);
$union->all();
// [1 => ['a'], 2 => ['b'], 3 => ['c']]