集合 | 综合话题 |《Laravel 5.6 中文文档 5.6》| Laravel China 社区
Laravel
话题列表
社区 Wiki
优质外文
招聘求职
Laravel 实战教程
社区文档
登录
注册
Laravel 5.6 中文文档
展开或关闭
前言
翻译说明
发行说明
升级说明
贡献导引
入门指南
安装
配置信息
文件夹结构
Homestead
Valet
部署
核心架构
请求周期
服务容器
服务提供者
Facades
Contracts
基础功能
路由
中间件
CSRF 保护
控制器
请求
响应
视图
URL
Session
表单验证
错误
日志
前端开发
Blade 模板
本地化
前端指南
编辑资源 Mix
安全相关
用户认证
Passport OAuth 认证
用户授权
加密解密
哈希
重置密码
综合话题
Artisan 命令行
广播系统
缓存系统
集合
事件系统
文件存储
辅助函数
邮件发送
消息通知
扩展包开发
队列
任务调度
数据库
快速入门
查询构造器
分页
数据库迁移
数据填充
Redis
Eloquent ORM
快速入门
模型关联
Eloquent 集合
修改器
API 资源
序列化
测试相关
快速入门
HTTP 测试
浏览器测试 Dusk
数据库测试
测试模拟器
官方扩展包
Cashier 交易工具包
Envoy 部署工具
Horizon
Scout 全文搜索
Socialite 社会化登录
Laravel
首页
Laravel
Go
PHP
Vue.js
Python
Java
MySQL
Rust
LK
Elasticsearch
F2E 前端
Server
程序员
Database
DevTools
Computer Science
手机开发
AdonisJS
社区
Wiki
教程
Laravel 实战教程首页
《L01 Laravel 教程 - Web 开发实战入门》
《L02 Laravel 教程 - Web 开发实战进阶》
《L03 Laravel 教程 - 实战构架 API 服务器》
《L04 Laravel 教程 - 微信小程序从零到发布》
《L05 Laravel 教程 - 电商实战》
《L06 Laravel 教程 - 电商进阶》
《LX1 Laravel / PHP 扩展包视频教程》
《LX2 PHP 扩展包实战教程 - 从入门到发布》
《L07 Laravel 教程 - Laravel TDD 测试实战》
《LX3 Laravel 性能优化入门》
《LX4 Laravel / PHP 五分钟视频》
文档
社区文档首页
《Laravel 中文文档》
《Laravel 速查表》
《PHP 代码简洁之道》
《Laravel 编码技巧》
《Dcat Admin 中文文档》
《Laravel Nova 中文文档》
《Lumen 中文文档》
《Dingo API 中文文档》
《 Laravel 项目开发规范》
《构建 Laravel 开发环境》
登录
注册
微信登录
提交改进
集合
5.6
9.x
8.5
8.x
7.x
6.x
5.8
5.7
5.6
5.5
5.4
5.3
5.2
5.1
Laravel 5.6 中文文档
未匹配的标注
本文档最新版为 9.x，旧版本可能放弃维护，推荐阅读最新版！
集合
简介
创建集合
扩展集合
可用方法
高阶消息
简介
Illuminate\Support\Collection 类提供了一个更具可读性的、更便于处理数组数据的封装。具体例子看下面的代码。我们使用了 collect 函数从数组中创建新的集合实例，对其中的每个元素运行 strtoupper 函数之后再移除所有的空元素：
$collection = collect(['taylor', 'abigail', null])->map(function ($name) {
return strtoupper($name);
})
->reject(function ($name) {
return empty($name);
});
正如你看到的，Collection 类允许你链式调用其方法，以达到在底层数组上优雅地执行 map 和 reject 操作。一般来说，集合是不可改变的，这意味着每个 Collection 方法都会返回一个全新的 Collection 实例。
创建集合
如上所述，辅助函数 collect 会为给定的数组返回一个新的 Illuminate\Support\Collection 实例。所以，创建一个集合就这么简单：
$collection = collect([1, 2, 3]);
{tip} 默认情况下，Eloquent 查询的结果返回的内容都是 Collection 实例。
扩展集合
集合是 宏观的，它允许您在运行时将其它方法添加到 集合 类。 例如，下面的代码在 Collection 类中添加一个 toUpper 方法：
use Illuminate\Support\Str;
Collection::macro('toUpper', function () {
return $this->map(function ($value) {
return Str::upper($value);
});
});
$collection = collect(['first', 'second']);
$upper = $collection->toUpper();
// ['FIRST', 'SECOND']
通常，你应该在 服务提供者 中声明集合宏。
可用方法
这个文档接下来的内容，我们会探讨 Collection 类每个可用的方法。记住，所有方法都可以以链式访问的形式优雅地操纵数组。而且，几乎所有的方法都会返回新的 Collection 实例，允许你在必要时保存集合的原始副本。
allaverageavgchunkcollapsecombineconcatcontainscontainsStrictcountcrossJoindddiffdiffAssocdiffKeysdumpeacheachSpreadeveryexceptfilterfirstfirstWhereflatMapflattenflipforgetforPagegetgroupByhasimplodeintersectintersectByKeysisEmptyisNotEmptykeyBykeyslastmacromakemapmapIntomapSpreadmapToGroupsmapWithKeysmaxmedianmergeminmodenthonlypadpartitionpipepluckpopprependpullpushputrandomreducerejectreversesearchshiftshuffleslicesortsortBysortByDescsortKeyssortKeysDescsplicesplitsumtaketaptimestoArraytoJsontransformunionuniqueuniqueStrictunlessunwrapvalueswhenwherewhereStrictwhereInwhereInStrictwhereNotInwhereNotInStrictwrapzip
方法清单
all()
all 方法返回集合表示的底层数组：
collect([1, 2, 3])->all();
// [1, 2, 3]
average()
avg 方法的别名。
avg()
avg 方法返回给定键的 平均值:
$average = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->avg('foo');
// 20
$average = collect([1, 1, 2, 4])->avg();
// 2
chunk()
chunk 方法将集合拆成多个指定大小的小集合：
$collection = collect([1, 2, 3, 4, 5, 6, 7]);
$chunks = $collection->chunk(4);
$chunks->toArray();
// [[1, 2, 3, 4], [5, 6, 7]]
这个方法特别适用在使用栅格系统时的 视图，比如 Bootstrap。想像你有一个 Eloquent 模型的集合要在栅格中显示：
@foreach ($products->chunk(3) as $chunk)
<div class="row">
@foreach ($chunk as $product)
<div class="col-xs-4">{{ $product->name }}</div>
@endforeach
</div>
@endforeach
collapse()
collapse 方法将多个数组的集合合并成一个数组的集合：
$collection = collect([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
$collapsed = $collection->collapse();
$collapsed->all();
// [1, 2, 3, 4, 5, 6, 7, 8, 9]
combine()
combine 方法可以将一个集合的值作为「键」，再将另一个数组或者集合的值作为「值」合并成一个集合：
$collection = collect(['name', 'age']);
$combined = $collection->combine(['George', 29]);
$combined->all();
// ['name' => 'George', 'age' => 29]
concat()
concat 方法将给定的 array 或集合值附加到集合的末尾：
$collection = collect(['John Doe']);
$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
$concatenated->all();
// ['John Doe', 'Jane Doe', 'Johnny Doe']
contains()
contains 方法判断集合是否包含给定的项目：
$collection = collect(['name' => 'Desk', 'price' => 100]);
$collection->contains('Desk');
// true
$collection->contains('New York');
// false
你也可以用 contains 方法匹配一对键/值，即判断给定的配对是否存在于集合中：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 100],
]);
$collection->contains('product', 'Bookcase');
// false
最后，你也可以传递一个回调到 contains 方法来执行自己的真实测试：
$collection = collect([1, 2, 3, 4, 5]);
$collection->contains(function ($value, $key) {
return $value > 5;
});
// false
contains 方法在检查项目值时使用「宽松」比较，意味着具有整数值的字符串将被视为等于相同值的整数。 相反 containsStrict 方法则是使用「严格」比较进行过滤。
containsStrict()
此方法和 contains 方法类似，但是它却是使用了「严格」比较来比较所有值。
count()
count 方法返回该集合内的项目总数：
$collection = collect([1, 2, 3, 4]);
$collection->count();
// 4
crossJoin()
crossJoin方法在给定数组或集合之间交叉集合的值，返回具有所有可能排列的笛卡尔乘积：
$collection = collect([1, 2]);
$matrix = $collection->crossJoin(['a', 'b']);
$matrix->all();
/*
[1, 'a'],
[1, 'b'],
[2, 'a'],
[2, 'b'],
*/
$collection = collect([1, 2]);
$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);
$matrix->all();
/*
[1, 'a', 'I'],
[1, 'a', 'II'],
[1, 'b', 'I'],
[1, 'b', 'II'],
[2, 'a', 'I'],
[2, 'a', 'II'],
[2, 'b', 'I'],
[2, 'b', 'II'],
*/
dd()
dd 方法转储集合的项目并结束脚本的执行：
$collection = collect(['John Doe', 'Jane Doe']);
$collection->dd();
/*
Collection {
#items: array:2 [
0 => "John Doe"
1 => "Jane Doe"
*/
如果您不想停止执行脚本，请改用 dump 方法。
diff()
diff 方法将集合与其它集合或纯 PHP 数组进行值的比较，然后返回原集合中存在而给定集合中不存在的值：
$collection = collect([1, 2, 3, 4, 5]);
$diff = $collection->diff([2, 4, 6, 8]);
$diff->all();
// [1, 3, 5]
diffAssoc()
diffAssoc 该方法与另外一个集合或基于它的键和值的 PHP 数组进行比较。这个方法会返回原集合不存在于给定集合中的键值对 ：
$collection = collect([
'color' => 'orange',
'type' => 'fruit',
'remain' => 6
]);
$diff = $collection->diffAssoc([
'color' => 'yellow',
'type' => 'fruit',
'remain' => 3,
'used' => 6
]);
$diff->all();
// ['color' => 'orange', 'remain' => 6]
diffKeys()
diffKeys 方法与另外一个集合或 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]
dump()
dump 方法将打印集合的每一项：
$collection = collect(['John Doe', 'Jane Doe']);
$collection->dump();
/*
Collection {
#items: array:2 [
0 => "John Doe"
1 => "Jane Doe"
*/
如果你想打印集合后并停止执行脚本，请改用 dd 方法代替。
each()
each 方法将迭代集合中的内容并将其传递到回调函数中：
$collection = $collection->each(function ($item, $key) {
//
});
如果你想要中断对内容的迭代，那就从回调中返回 false：
$collection = $collection->each(function ($item, $key) {
if (/* some condition */) {
return false;
});
eachSpread()
eachSpread 方法迭代集合的项目，将每个嵌套项目值传递给给定的回调：
$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
$collection->eachSpread(function ($name, $age) {
//
});
您可以通过从回调中返回 false 来停止迭代项目：
$collection->eachSpread(function ($name, $age) {
return false;
});
every()
every 方法可用于验证集合中每一个元素都通过给定的真实测试：
collect([1, 2, 3, 4])->every(function ($value, $key) {
return $value > 2;
});
// false
except()
except 方法返回集合中除了指定键以外的所有项目：
$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
$filtered = $collection->except(['price', 'discount']);
$filtered->all();
// ['product_id' => 1]
与 except 相反的方法，请查看 only 方法。
filter()
filter 方法使用给定的回调函数过滤集合的内容，只留下那些通过给定真实测试的内容：
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->filter(function ($value, $key) {
return $value > 2;
});
$filtered->all();
// [3, 4]
如果没有提供回调函数，集合中所有返回 false 的元素都会被移除：
$collection = collect([1, 2, 3, null, false, '', 0, []]);
$collection->filter()->all();
// [1, 2, 3]
与 filter 相反的方法，可以查看 reject 方法。
first()
first 方法返回集合中通过给定真实测试的第一个元素：
collect([1, 2, 3, 4])->first(function ($value, $key) {
return $value > 2;
});
// 3
你也可以不传入参数使用 first 方法以获取集合中第一个元素。如果集合是空的，则会返回 null：
collect([1, 2, 3, 4])->first();
// 1
firstWhere()
firstWhere 方法用给定的键/值对返回集合中的第一个元素：
$collection = collect([
['name' => 'Regena', 'age' => 12],
['name' => 'Linda', 'age' => 14],
['name' => 'Diego', 'age' => 23],
['name' => 'Linda', 'age' => 84],
]);
$collection->firstWhere('name', 'Linda');
// ['name' => 'Linda', 'age' => 14]
你也可以用操作符调用 firstWhere 方法：
$collection->firstWhere('age', '>=', 18);
// ['name' => 'Diego', 'age' => 23]
flatMap()
flatMap 方法遍历集合并将其中的每个值传递到给定的回调。可以通过回调修改每个值的内容再返回出来，从而形成一个新的被修改过内容的集合。然后你就可以用 all() 打印修改后的数组：
$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'];
flatten()
flatten 方法将多维集合转为一维的:
$collection = collect(['name' => 'taylor', 'languages' => ['php', 'javascript']]);
$flattened = $collection->flatten();
$flattened->all();
// ['taylor', 'php', 'javascript'];
你还可以选择性地传入「深度」参数：
$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'],
*/
在这个例子里，调用 flatten 方法时不传入深度参数的话也会将嵌套数组转成一维的，然后返回 ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']。传入深度参数能让你限制设置返回数组的层数。
flip()
flip 方法将集合中的键和对应的数值进行互换：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$flipped = $collection->flip();
$flipped->all();
// ['taylor' => 'name', 'laravel' => 'framework']
forget()
forget 方法通过给定的键来移除掉集合中对应的内容：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$collection->forget('name');
$collection->all();
// ['framework' => 'laravel']
{note} 与大多数集合的方法不同，forget 不会返回修改过后的新集合；它会直接修改原来的集合。
forPage()
forPage 方法返回给定页码上显示的项目的新集合。这个方法接受页码作为其第一个参数和每页显示的项目数作为其第二个参数。
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunk = $collection->forPage(2, 3);
$chunk->all();
// [4, 5, 6]
get()
get 方法返回给定键的项目。如果该键不存在，则返回 null：
$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
你甚至可以将回调函数当作默认值。如果指定的键不存在，就会返回回调的结果：
$collection->get('email', function () {
return 'default-value';
});
// default-value
groupBy()
groupBy 方法根据给定的键对集合内的项目进行分组：
$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'],
],
*/
多个分组标准可以作为数组传递。 每个数组元素将应用于多维数组中的相应级别：
$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']],
],
],
];
*/
has()
has 方法判断集合中是否存在给定的键：
$collection = collect(['account_id' => 1, 'product' => 'Desk']);
$collection->has('product');
// true
implode()
implode 方法合并集合中的项目。其参数取决于集合中项目的类型。如果集合包含数组或对象，你应该传入你希望连接的属性的键，以及你希望放在值之间用来「拼接」的字符串：
$collection = collect([
['account_id' => 1, 'product' => 'Desk'],
['account_id' => 2, 'product' => 'Chair'],
]);
$collection->implode('product', ', ');
// Desk, Chair
如果集合包含简单的字符串或数值，只需要传入「拼接」用的字符串作为该方法的唯一参数即可：
collect([1, 2, 3, 4, 5])->implode('-');
// '1-2-3-4-5'
intersect()
intersect 方法从原集合中删除不在给定「数组」或集合中的任何值。最终的集合会保留原集合的键：
$collection = collect(['Desk', 'Sofa', 'Chair']);
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
$intersect->all();
// [0 => 'Desk', 2 => 'Chair']
intersectByKeys()
intersectByKeys 方法删除原集合中不存在于给定「数组」或集合中的任何键：
$collection = collect([
'serial' => 'UX301', 'type' => 'screen', 'year' => 2009
]);
$intersect = $collection->intersectByKeys([
'reference' => 'UX404', 'type' => 'tab', 'year' => 2011
]);
$intersect->all();
// ['type' => 'screen', 'year' => 2009]
isEmpty()
如果集合是空的，isEmpty 方法返回 true，否则返回 false：
collect([])->isEmpty();
// true
isNotEmpty()
如果集合不是空的，isNotEmpty 方法会返回 true：否则返回 false：
collect([])->isNotEmpty();
// false
keyBy()
keyBy 方法以给定的键作为集合的键。如果多个项目具有相同的键，则只有最后一个项目会显示在新集合中：
$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'],
*/
keys()
keys 方法返回集合的所有键：
$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']
last()
last 方法返回集合中通过给定真相测试的最后一个元素：
collect([1, 2, 3, 4])->last(function ($value, $key) {
return $value < 3;
});
// 2
你也可以不传入参数调用 last 方法来获取集合中最后一个元素。如果集合是空的，返回 null：
collect([1, 2, 3, 4])->last();
// 4
macro()
静态 macro 方法允许您在运行时将方法添加到 Collection 类。 有关更多信息，请参阅 扩展集合 的文档。
make()
静态 make 方法可以创建一个新的集合实例。 请参阅 创建集合 部分。
map()
map 方法遍历集合并将每一个值传入给定的回调。该回调可以任意修改项目并返回，从而形成新的被修改过项目的集合：
$collection = collect([1, 2, 3, 4, 5]);
$multiplied = $collection->map(function ($item, $key) {
return $item * 2;
});
$multiplied->all();
// [2, 4, 6, 8, 10]
{note} 像其它的集合方法一样，map 方法会返回一个新的集合实例；它不会修改它所调用的集合。如果你想改变原集合，请使用 transform 方法。
mapInto()
mapInto() 方法可以迭代集合，通过将值传递给构造函数来创建给定类的新实例：
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')]
mapSpread()
mapSpread 方法可以迭代集合的项目，将每个嵌套项目值传递给给定的回调函数。 该回调可以自由修改该项目并将其返回，从而形成一个新的修改项目集合：
$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunks = $collection->chunk(2);
$sequence = $chunks->mapSpread(function ($odd, $even) {
return $odd + $even;
});
$sequence->all();
// [1, 5, 9, 13, 17]
mapToGroups()
mapToGroups 方法通过给定的回调对集合的项目进行分组。 该回调应该返回一个包含单个键/值对的关联数组，从而形成一个新的集合：
$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' => ['Johhny Doe'],
*/
$grouped->get('Sales')->all();
// ['John Doe', 'Jane Doe']
mapWithKeys()
mapWithKeys 方法遍历集合并将每个值传入给定的回调。回调应该返回包含一个键值对的关联数组：
$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',
*/
max()
max 方法返回给定键的最大值：
$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');
// 20
$max = collect([1, 2, 3, 4, 5])->max();
// 5
median()
median 方法返回给定键的 中值:
$median = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->median('foo');
// 15
$median = collect([1, 1, 2, 4])->median();
// 1.5
merge()
merge 方法将给定数组或集合合并到原集合。如果给定项目中的字符串键与原集合中的字符串键匹配，给定的项目的值将会覆盖原集合中的值：
$collection = collect(['product_id' => 1, 'price' => 100]);
$merged = $collection->merge(['price' => 200, 'discount' => false]);
$merged->all();
// ['product_id' => 1, 'price' => 200, 'discount' => false]
如果给定的项目的键是数字，这些值将被追加到集合的末尾：
$collection = collect(['Desk', 'Chair']);
$merged = $collection->merge(['Bookcase', 'Door']);
$merged->all();
// ['Desk', 'Chair', 'Bookcase', 'Door']
min()
min 方法返回给定键的最小值：
$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
// 10
$min = collect([1, 2, 3, 4, 5])->min();
// 1
mode()
mode 方法返回给定键的 众数:
$mode = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->mode('foo');
// [10]
$mode = collect([1, 1, 2, 4])->mode();
// [1]
nth()
nth 方法创建由每隔 n 个元素组成一个新的集合：
$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
$collection->nth(4);
// ['a', 'e']
你也可以选择传入一个偏移位置作为第二个参数
$collection->nth(4, 1);
// ['b', 'f']
only()
only 方法返回集合中给定键的所有项目：
$collection = collect(['product_id' => 1, 'name' => 'Desk', 'price' => 100, 'discount' => false]);
$filtered = $collection->only(['product_id', 'name']);
$filtered->all();
// ['product_id' => 1, 'name' => 'Desk']
与 only 相反的方法，请查看 except 方法。
pad()
pad 方法将使用给定的值填充数组，直到数组达到指定的大小。 此方法的行为与 array_pad PHP 函数功能类似。
要填充到左侧，您应指定负号。如果给定大小的绝对值小于或等于数组的长度，则不会发生填充：
$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']
partition()
partition 方法可以和 PHP 中的 list 方法结合使用，来区分开通过指定条件的元素以及那些不通过指定条件的元素：
$collection = collect([1, 2, 3, 4, 5, 6]);
list($underThree, $aboveThree) = $collection->partition(function ($i) {
return $i < 3;
});
pipe()
pipe 方法将集合传给给定的回调并返回结果：
$collection = collect([1, 2, 3]);
$piped = $collection->pipe(function ($collection) {
return $collection->sum();
});
// 6
pluck()
pluck 方法可以获取集合中给定键对应的所有值：
$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([
['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']
pop()
pop 方法移除并返回集合中的最后一个项目：
$collection = collect([1, 2, 3, 4, 5]);
$collection->pop();
// 5
$collection->all();
// [1, 2, 3, 4]
prepend()
prepend 方法将给定的值添加到集合的开头：
$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]
pull()
pull 方法把给定键对应的值从集合中移除并返回：
$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);
$collection->pull('name');
// 'Desk'
$collection->all();
// ['product_id' => 'prod-100']
push()
push 方法把给定值添加到集合的末尾：
$collection = collect([1, 2, 3, 4]);
$collection->push(5);
$collection->all();
// [1, 2, 3, 4, 5]
put()
put 方法在集合内设置给定的键值对：
$collection = collect(['product_id' => 1, 'name' => 'Desk']);
$collection->put('price', 100);
$collection->all();
// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]
random()
random 方法从集合中返回一个随机项：
$collection = collect([1, 2, 3, 4, 5]);
$collection->random();
// 4 - (retrieved randomly)
你可以选择性传入一个整数到 random 来指定要获取的随机项的数量。只要你显式传递你希望接收的数量时，则会返回项目的集合：
$random = $collection->random(3);
$random->all();
// [2, 4, 5] - (retrieved randomly)
reduce()
reduce 方法将每次迭代的结果传递给下一次迭代直到集合减少为单个值：
$collection = collect([1, 2, 3]);
$total = $collection->reduce(function ($carry, $item) {
return $carry + $item;
});
// 6
第一次迭代时 $carry 的数值为 null；你也可以通过传入第二个参数到 reduce 来指定它的初始值：
$collection->reduce(function ($carry, $item) {
return $carry + $item;
}, 4);
// 10
reject()
reject 方法使用指定的回调过滤集合。如果回调返回 true ，就会把对应的项目从集合中移除：
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->reject(function ($value, $key) {
return $value > 2;
});
$filtered->all();
// [1, 2]
与 reject 相反的方法，可以查看 filter 方法。
reverse()
reverse 方法用来倒转集合中项目的顺序:
$collection = collect(['a', 'b', 'c', 'd', 'e']);
$reversed = $collection->reverse();
$reversed->all();
/*
4 => 'e',
3 => 'd',
2 => 'c',
1 => 'b',
0 => 'a',
*/
search()
search 方法搜索给定的值并返回它的键。如果找不到，则返回 false：
$collection = collect([2, 4, 6, 8]);
$collection->search(4);
// 1
搜索使用「宽松」比较完成，这意味着具有整数值的字符串会被认为等于相同值的整数。要使用「严格」比较，就传入 true 作为该方法的第二个参数：
$collection->search('4', true);
// false
另外，你可以通过回调来搜索第一个通过真实测试的项目：
$collection->search(function ($item, $key) {
return $item > 5;
});
// 2
shift()
shift 方法移除并返回集合的第一个项目：
$collection = collect([1, 2, 3, 4, 5]);
$collection->shift();
// 1
$collection->all();
// [2, 3, 4, 5]
shuffle()
shuffle 方法随机排序集合中的项目：
$collection = collect([1, 2, 3, 4, 5]);
$shuffled = $collection->shuffle();
$shuffled->all();
// [3, 2, 5, 1, 4] - (generated randomly)
slice()
slice 方法返回集合中给定值后面的部分：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$slice = $collection->slice(4);
$slice->all();
// [5, 6, 7, 8, 9, 10]
如果你想限制返回内容的大小，就将期望的大小作为第二个参数传递给方法：
$slice = $collection->slice(4, 2);
$slice->all();
// [5, 6]
默认情况下，返回的内容将会保留原始键。假如你不希望保留原始的键，你可以使用 values 方法来重新建立索引。
sort()
sort 方法对集合进行排序。排序后的集合保留着原数组的键，所以在这个例子中我们使用 values 方法来把键重置为连续编号的索引：
$collection = collect([5, 3, 1, 2, 4]);
$sorted = $collection->sort();
$sorted->values()->all();
// [1, 2, 3, 4, 5]
如果你有更高级的排序需求，你可以传入回调来用你自己的算法进行排序。请参阅 PHP 文档的 uasort，这是集合的 sort 方法在底层所调用的
{tip} 如果要对嵌套数组或对象的集合进行排序，参考 sortBy 和 sortByDesc 方法。
sortBy()
sortBy 法以给定的键对集合进行排序。排序后的集合保留了原数组键，所以在这个例子中，我们使用 values 方法将键重置为连续编号的索引：
$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 方法一样，但是会以相反的顺序来对集合进行排序：
sortKeys()
sortKeys 方法通过底层关联数组的键来排序集合：
$collection = collect([
'id' => 22345,
'first' => 'John',
'last' => 'Doe',
]);
$sorted = $collection->sortKeys();
$sorted->all();
/*
'first' => 'John',
'id' => 22345,
'last' => 'Doe',
*/
sortKeysDesc()
这个方法的用法和 sortKeys 方法一样，区别就是返回的集合是倒序。
splice()
splice 方法删除并返回从给定值后的内容，原集合也会受到影响：
$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2);
$chunk->all();
// [3, 4, 5]
$collection->all();
// [1, 2]
你可以传入第二个参数以限制被删除内容的大小：
$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]
split()
split 方法将集合按给定的值拆分：
$collection = collect([1, 2, 3, 4, 5]);
$groups = $collection->split(3);
$groups->toArray();
// [[1, 2], [3, 4], [5]]
sum()
sum 方法返回集合内所有项目的总和：
collect([1, 2, 3, 4, 5])->sum();
// 15
如果集合包含嵌套数组或对象，则应该传入一个键来指定要进行求和的值：
$collection = collect([
['name' => 'JavaScript: The Good Parts', 'pages' => 176],
['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
]);
$collection->sum('pages');
// 1272
另外，你也可以传入回调来决定要用集合中的哪些值进行求和：
$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
take()
take 方法返回给定数量项目的新集合：
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(3);
$chunk->all();
// [0, 1, 2]
你也可以传入负整数从集合末尾开始获取指定数量的项目：
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(-2);
$chunk->all();
// [4, 5]
tap()
tap 方法将集合传递给回调，在特定点「tap」集合。此举能让你对集合中的项目执行某些操作，而不影响集合本身：
collect([2, 4, 3, 1, 5])
->sort()
->tap(function ($collection) {
Log::debug('Values after sorting', $collection->values()->toArray());
})
->shift();
// 1
times()
静态 times 方法通过回调在给定次数内创建一个新的集合：
$collection = Collection::times(10, function ($number) {
return $number * 9;
});
$collection->all();
// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
使用这个方法可以与工厂结合使用创建出 Eloquent 模型：
$categories = Collection::times(3, function ($number) {
return factory(Category::class)->create(['name' => 'Category #'.$number]);
});
$categories->all();
/*
['id' => 1, 'name' => 'Category #1'],
['id' => 2, 'name' => 'Category #2'],
['id' => 3, 'name' => 'Category #3'],
*/
toArray()
toArray 方法将集合转换成 PHP 数组。如果集合的值是 Eloquent 模型，那也会被转换成数组：
$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toArray();
/*
['name' => 'Desk', 'price' => 200],
*/
{note} toArray 也会将所有集合的嵌套对象转换为数组。如果你想获取原数组，就改用 all 方法。
toJson()
toJson 方法将集合转换成 JSON 字符串：
$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toJson();
// '{"name":"Desk", "price":200}'
transform()
transform 方法迭代集合并对集合内的每个项目调用给定的回调。而集合的内容也会被回调返回的值取代：
$collection = collect([1, 2, 3, 4, 5]);
$collection->transform(function ($item, $key) {
return $item * 2;
});
$collection->all();
// [2, 4, 6, 8, 10]
{note} 与大多数集合的方法不同，transform 会修改集合本身。如果你想创建新的集合，就改用 map 方法。
union()
union 方法将给定的数组添加到集合中。如果给定的数组中含有与原集合一样的键，则原集合的值不会被改变：
$collection = collect([1 => ['a'], 2 => ['b']]);
$union = $collection->union([3 => ['c'], 1 => ['b']]);
$union->all();
// [1 => ['a'], 2 => ['b'], 3 => ['c']]
unique()
unique 方法返回集合中所有唯一的项目。返回的集合保留着原数组的键，所以在这个例子中，我们使用 values 方法来把键重置为连续编号的索引：
$collection = collect([1, 1, 2, 2, 3, 4, 2]);
$unique = $collection->unique();
$unique->values()->all();
// [1, 2, 3, 4]
处理嵌套数组或对象时，你可以指定用来决定唯一性的键：
$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'],
*/
你也可以传入自己的回调来确定项目的唯一性：
$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'],
*/
在检查项目值时 unique 方法使用的是「宽松」比较，意味着具有整数值的字符串将被视为等于相同值的整数。使用 uniqueStrict 方法可以进行「严格」比较 。
uniqueStrict()
这个方法的使用和 unique 方法类似，只是使用了「严格」比较来过滤。
unless()
unless 方法当传入的第一个参数不为 true 的时候，将执行给定的回调：
$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]
和 unless 方法相反，参考 when 方法。
unwrap()
静态 unwrap 方法返回集合内部的可用值：
Collection::unwrap(collect('John Doe'));
// ['John Doe']
Collection::unwrap(['John Doe']);
// ['John Doe']
Collection::unwrap('John Doe');
// 'John Doe'
values()
values 方法返回键被重置为连续编号的新集合：
$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],
*/
when()
when 方法当传入的第一个参数为 true 的时候，将执行给定的回调：
$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]
和 when 方法相反，参考 unless 方法。
where()
where 方法通过给定的键值过滤集合：
$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],
*/
比较数值的时候，where 方法使用「宽松」比较，意味着具有整数值的字符串将被认为等于相同值的整数。使用 whereStrict 方法来进行「严格」比较过滤。
whereStrict()
这个方法与 where 方法一样；但是会以「严格」比较来匹配所有值：
whereIn()
whereIn 方法通过给定的键值数组来过滤集合：
$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],
*/
whereIn 方法在检查项目值时使用「宽松」比较，意味着具有整数值的字符串将被视为等于相同值的整数。你可以使用 whereInStrict 做「严格」比较。
whereInStrict()
此方法的使用和 whereIn 方法类似，只是使用了「严格」比较来匹配所有值。
whereNotIn()
whereNotIn 通过集合中不包含的给定键值对进行过滤：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 100],
['product' => 'Bookcase', 'price' => 150],
['product' => 'Door', 'price' => 100],
]);
$filtered = $collection->whereNotIn('price', [150, 200]);
$filtered->all();
/*
['product' => 'Chair', 'price' => 100],
['product' => 'Door', 'price' => 100],
*/
whereNotIn 方法在检查项目值时使用「宽松」比较，意味着具有整数值的字符串将被视为等于相同值的整数。你可以使用 whereNotInStrict 做比较「严格」的匹配。
whereNotInStrict()
此方法的使用和 whereNotIn 方法类似，只是使用了「严格」比较来匹配所有值。
wrap()
静态 wrap 方法将可用的给定值包装在集合中：
$collection = Collection::wrap('John Doe');
$collection->all();
// ['John Doe']
$collection = Collection::wrap(['John Doe']);
$collection->all();
// ['John Doe']
$collection = Collection::wrap(collect('John Doe'));
$collection->all();
// ['John Doe']
zip()
zip 方法将给定数组的值与相应索引处的原集合的值合并在一起：
$collection = collect(['Chair', 'Desk']);
$zipped = $collection->zip([100, 200]);
$zipped->all();
// [['Chair', 100], ['Desk', 200]]
高阶消息传递
集合也提供对「高阶消息传递」的支持，即对集合执行常见操作的快捷方式。支持高阶消息传递的集合方法有：average， avg， contains， each， every， filter， first， flatMap， map， partition， reject， sortBy， sortByDesc ，sum 和 unique。
每个高阶消息都能作为集合实例的动态属性来访问。例如，使用 each 高阶消息传递在集合中的每个对象上调用一个方法：
$users = User::where('votes', '>', 500)->get();
$users->each->markAsVip();
同样，我们可以使用 sum 高阶消息来收集集合中「投票」总数：
$users = User::where('group', 'Development')->get();
return $users->sum->votes;
本文章首发在 LearnKu.com 网站上。
本译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 CC 协议，如果我们的工作有侵犯到您的权益，请及时联系我们。
原文地址：https://learnku.com/docs/laravel/5.6/col...
译文地址：https://learnku.com/docs/laravel/5.6/col...
上一篇
下一篇
Markdown 文本
纠错改进
《L05 电商实战》
从零开发一个电商项目，功能包括电商后台、商品 & SKU 管理、购物车、订单管理、支付宝支付、微信支付、订单退款流程、优惠券等
《G01 Go 实战入门》
从零开始带你一步步开发一个 Go 博客项目，让你在最短的时间内学会使用 Go 进行编码。项目结构很大程度上参考了 Laravel。
贡献者：6
推荐文章：
更多推荐...
博客
基于 GD 库和 phpqrcode 的海报生成插件
62
34
1年前
博客
Laravel livewire 学习资源集合
15
2年前
翻译
方便的 Bash 终端技巧大集合
68
3年前
翻译
分享 10 个有用的 Laravel 5.8 集合辅助方法
15
3年前
博客
Laravel 5.8 集合 vue-element-admin 踩坑记
25
26
3年前
博客
Leetcode 二叉树题目集合 (看完这个面试不会做二叉树题,辣条给你！！！！！)
21
3年前
讨论数量: 6
发起讨论
只看当前版本
panco
4年前
这个还挺厉害的
个点赞 | 0 个回复 |
问答
| 课程版本 5.7
Rxy-development
3年前
对数组使用 collect ()->sortByDesc ()->sortByDesc ()
个点赞 | 7 个回复 |
问答
| 课程版本 5.5
xingchen
4年前
这方法也忒多了，这如何记得住啊?
个点赞 | 4 个回复 |
问答
| 课程版本 5.6
MouseSoft
3年前
集合的 nth (4) 这个怎么理解呢?
个点赞 | 3 个回复 |
问答
| 课程版本 5.8
陈伯乐
3年前
最后的高阶消息传递看的不是太懂
个点赞 | 2 个回复 |
问答
| 课程版本 5.8
BaldwinLynn
3年前
这些函数是不是相当与把原生 PHP 的 array 函数完全给取代了？
个点赞 | 1 个回复 |
问答
| 课程版本 5.5
社区赞助商
成为赞助商
关于 LearnKu
LearnKu 是终身编程者的修道场
做最专业、严肃的技术论坛
LearnKu 诞生的故事
资源推荐
《社区使用指南》
《文档撰写指南》
《LearnKu 社区规范》
《提问的智慧》
服务提供商
其他信息
成为版主
所有测验
联系站长（反馈建议）
粤ICP备18099781号-6
粤公网安备 44030502004330号
违法和不良信息举报
由 Summer 设计和编码 ❤
请登录
提交
忘记密码?
or
注册
第三方账号登录
微信登录
GitHub 登录
内容举报
匿名举报，为防止滥用，仅管理员可见举报者。
我要举报该，理由是：
垃圾广告：恶意灌水、广告、推广等内容
无意义内容：测试、灌水、文不对题、消极内容、文章品质太差等
违规内容：色情、暴利、血腥、敏感信息等
不友善内容：人身攻击、挑衅辱骂、恶意行为
科学上网：翻墙、VPN、Shadowsocks，政策风险，会被关站！
不懂提问：提问太随意，需要再做一遍《提问的智慧》测验
随意提问：提问没有发布在社区问答分类下
排版混乱：没有合理使用 Markdown 编写文章，未使用代码高亮
内容结构混乱：逻辑不清晰，内容混乱，难以阅读
标题随意：标题党、标题不释义
尊重版权：分享付费课程、破解软件（付费），侵犯作者劳动成果
其他理由：请补充说明
举报
取消