Laravel之集合(Collection)总结

集合为处理数组数据提供了流式、方便的封装。

all()

all 方法简单返回集合表示的底层数组

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

toArray()

toArray 方法将集合转化为一个原生的 PHP 数组。如果集合的值是 Eloquent 模型,该模型也会被转化为数组:

1
2
3
4
5
6
7
8
9
$collection = collect(['name' => 'Desk', 'price' => 200]);

$collection->toArray();

/*
[
['name' => 'Desk', 'price' => 200],
]
*/

注:toArray 还会将所有 Arrayable 实例嵌套对象集合转化为数组。如果你想要获取底层数组,使用 all 方法。

values()

values 方法通过将集合键重置为连续整型数字的方式返回新的集合:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$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],
]
*/

every()

every 方法可以用于验证集合的所有元素能够通过给定的真理测试:

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

// false

如果集合为空,every 方法将返回 true

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

$collection->every(function($value, $key) {
return $value > 2;
});

// true

except()

except 方法返回集合中除了指定键的所有集合项:

1
2
3
4
5
6
7
$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);

$filtered = $collection->except(['price', 'discount']);

$filtered->all();

// ['product_id' => 1]

except 相对的是 only 方法。

注:该方法的行为在使用 Eloquent 集合时会发生改变。

each()

each 方法迭代集合中的数据项并传递每个数据项到给定回调:

1
2
3
$collection = $collection->each(function ($item, $key) {
//
});

如果你想要终止对数据项的迭代,可以从回调返回 false

1
2
3
4
5
$collection = $collection->each(function ($item, $key) {
if (/* some condition */) {
return false;
}
});

filter()

filter 方法通过给定回调过滤集合,只有通过给定真理测试的数据项才会保留下来:

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

$filtered = $collection->filter(function ($value, $key) {
return $value > 2;
});

$filtered->all();
// [3, 4]

如果没有提供回调,那么集合中所有等价于 false 的项都会被移除:

1
2
3
4
5
$collection = collect([1, 2, 3, null, false, '', 0, []]);

$collection->filter()->all();

// [1, 2, 3]

filter 相对的方法是 reject

reject()

reject 方法使用给定回调过滤集合,该回调应该为所有它想要从结果集合中移除的数据项返回 true

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

$filtered->all();
// [1, 2]

replace()

replace 方法和 merge 方法有点像,不过,除了通过字符串键覆盖匹配项之外,replace 方法还会覆盖集合中匹配的数字键:

1
2
3
4
5
6
7
$collection = collect(['Taylor', 'Abigail', 'James']);

$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);

$replaced->all();

// ['Taylor', 'Victoria', 'James', 'Finn']

replaceRecursive()

该方法和 replace 方法类似,但是它会递归数组并应用同样的替换逻辑到内部值:

1
2
3
4
5
6
7
$collection = collect(['Taylor', 'Abigail', ['James', 'Victoria', 'Finn']]);

$replaced = $collection->replaceRecursive(['Charlie', 2 => [1 => 'King']]);

$replaced->all();

// ['Charlie', 'Abigail', ['James', 'King', 'Finn']]

reverse()

reverse 方法将集合数据项的顺序颠倒:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$collection = collect(['a', 'b', 'c', 'd', 'e']);

$reversed = $collection->reverse();

$reversed->all();

/*
[
4 => 'e',
3 => 'd',
2 => 'c',
1 => 'b',
0 => 'a',
]
*/

keyBy()

keyBy 方法将指定键的值作为集合的键,如果多个数据项拥有同一个键,只有最后一个会出现在新集合里面:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$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'],
]
*/

你还可以传递自己的回调到该方法,该回调将会返回经过处理的键的值作为新的集合键:

1
2
3
4
5
6
7
8
9
10
11
12
$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'],
]
*/

reject 方法相对的方法是 filter 方法。

map()

map 方法遍历集合并传递每个值给给定回调。该回调可以修改数据项并返回,从而生成一个新的经过修改的集合:

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

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

$multiplied->all();

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

注:和大多数集合方法一样,map 返回新的集合实例;它并不修改所调用的实例。如果你想要改变原来的集合,使用 transform 方法。

transform()

transform 方法迭代集合并对集合中每个数据项调用给定回调。集合中的数据项将会被替代成从回调中返回的值:

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

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

$collection->all();

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

mapWithKeys()

mapWithKeys 方法对集合进行迭代并传递每个值到给定回调,该回调会返回包含键值对的关联数组:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$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',
]
*/

pluck()

pluck 方法为给定键获取所有集合值:

1
2
3
4
5
6
7
8
9
10
$collection = collect([
['product_id' => 'prod-100', 'name' => 'Desk'],
['product_id' => 'prod-200', 'name' => 'Chair'],
]);

$plucked = $collection->pluck('name');

$plucked->all();

// ['Desk', 'Chair']

还可以指定你想要结果集合如何设置键:

1
2
3
4
5
$plucked = $collection->pluck('name', 'product_id');

$plucked->all();

// ['prod-100' => 'Desk', 'prod-200' => 'Chair']

如果存在重复键,最后一个匹配的元素将会插入集合:

1
2
3
4
5
6
7
8
9
10
11
12
$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']

random()

random 方法从集合中返回随机数据项:

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

$collection->random();

// 4 - (retrieved randomly)

你可以传递一个整型数据到 random 函数来指定返回的数据数目,如果该整型数值大于1,将会返回一个集合:

1
2
3
4
5
$random = $collection->random(3);

$random->all();

// [2, 4, 5] - (retrieved randomly)

如果集合中的元素个数小于请求的随机数,该方法会抛出 InvalidArgumentException

chunk()

chunk 方法将一个集合分割成多个小尺寸的小集合:

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

flip()

flip 方法将集合的键值做交换:

1
2
3
4
5
6
7
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$flipped = $collection->flip();

$flipped->all();

// ['taylor' => 'name', 'laravel' => 'framework']

get()

get 方法返回给定键的数据项,如果对应键不存在,返回null

1
2
3
4
5
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$value = $collection->get('name');

// taylor

你可以选择传递默认值作为第二个参数:

1
2
3
4
5
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$value = $collection->get('foo', 'default-value');

// default-value

你甚至可以传递回调作为默认值,如果给定键不存在的话回调的结果将会返回:

1
2
3
4
5
$collection->get('email', function () {
return 'default-value';
});

// default-value

dump()

dump 打印集合的方法。 它可用于在任何位置的调试和查找集合内的内容。

1
2
3
$collection->whereIn('user_id', [1, 2])
->dump()
->where('user_id', 1);

有用就打赏一下作者吧!