README

此仓库不再维护。但是，你可以完全查看类似的项目 https://github.com/tightenco/collect（我将要使用它）。

这是什么？

这是Laravel的收集辅助类（PHP数组的强化版），可以从Laravel中提取出来单独使用。它不包含任何不必要的辅助函数、额外类或服务提供者。它只是收集类。此外，它不使用Illuminate命名空间。除此之外，其他一切都差不多。

$collection = collect(['taylor', 'abigail', null])->map(function ($name) {
    return strtoupper($name);
})
->reject(function ($name) {
    return empty($name);
});

安装

使用Composer安装 stillat/collection。

$ composer require stillat/collection

Composer操作完成后，你现在应该可以在项目中使用收集助手了！继续学习有关它的所有信息。

收集

注意：此文档直接来自Laravel文档存储库。一些表格已被重新格式化，以便在GitHub上看起来更美观，但仅此而已。

• 简介
• 创建收集
• 可用方法
• 何时更新此库？
• 我可以贡献改进/修复吗？
• 动机/为什么这是件事？

简介

Collection\Collection 类提供了一个流畅、便捷的包装，用于处理数据数组。例如，查看以下代码。我们将使用 collect 辅助函数从数组创建一个新的收集实例，对每个元素运行 strtoupper 函数，然后删除所有空元素。

$collection = collect(['taylor', 'abigail', null])->map(function ($name) {
    return strtoupper($name);
})
->reject(function ($name) {
    return empty($name);
});

如你所见，Collection 类允许你链式调用其方法以执行流畅的映射和减少底层数组。通常，每个 Collection 方法都会返回一个新的 Collection 实例。

创建收集

如上所述，collect 辅助函数为给定的数组返回一个新的 Collection.Collection 实例。因此，创建收集就像这样简单。

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

可用方法

在本文档的其余部分，我们将讨论 Collection 类上可用的每个方法。记住，所有这些方法都可以链式使用以流畅地操作底层数组。此外，几乎每个方法都会返回一个新的 Collection 实例，允许你在必要时保留收集的原始副本。

您可以从下表中选择任何方法，以查看其使用示例

方法列表

all()

all方法简单地返回集合表示的基础数组

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

// [1, 2, 3]

avg()

avg方法返回集合中所有项目的平均值

collect([1, 2, 3, 4, 5])->avg();

// 3

如果集合包含嵌套数组或对象，您应该传递一个键来用于确定要计算平均值的值

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

$collection->avg('pages');

// 636

chunk()

chunk方法将集合拆分为多个给定大小的更小的集合

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

$chunks = $collection->chunk(4);

$chunks->toArray();

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

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]

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 ($key, $value) {
    return $value > 5;
});

// false

count()

count方法返回集合中的项目总数

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

$collection->count();

// 4

diff()

diff方法将集合与另一个集合或一个普通的PHP array进行比较

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

$diff = $collection->diff([2, 4, 6, 8]);

$diff->all();

// [1, 3, 5]

each()

each方法遍历集合中的项目，并将每个项目传递给一个给定的回调

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

从您的回调返回false以退出循环

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

every()

every方法创建一个新的集合，该集合包含每第n个元素

$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);

$collection->every(4);

// ['a', 'e']

您可以选择性地传递偏移量作为第二个参数

$collection->every(4, 1);

// ['b', 'f']

except()

except方法返回除指定键外的所有项目

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

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

$filtered->all();

// ['product_id' => 1, 'name' => 'Desk']

有关except的逆操作，请参阅only方法。

filter()

filter方法通过给定的回调过滤集合，仅保留通过给定真值测试的项目

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

$filtered = $collection->filter(function ($item) {
    return $item > 2;
});

$filtered->all();

// [3, 4]

有关filter的逆操作，请参阅reject方法。

first()

first方法返回通过给定真值测试的集合中的第一个元素

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

// 3

您也可以不带参数调用first方法来获取集合中的第一个元素。如果集合为空，则返回null。

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

// 1

flatten()

flatten 方法将多维集合扁平化为一维

$collection = collect(['name' => 'taylor', 'languages' => ['php', 'javascript']]);

$flattened = $collection->flatten();

$flattened->all();

// ['taylor', 'php', 'javascript'];

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

注意：与大多数其他集合方法不同，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'],
        ],
    ]
*/

除了传递字符串 key 之外，您还可以传递一个回调函数。该回调函数应返回您希望用作分组键的值

$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 方法确定给定键是否存在于集合中

$collection = collect(['account_id' => 1, 'product' => 'Desk']);

$collection->has('email');

// false

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 方法删除在给定的 array 或集合中不存在的任何值

$collection = collect(['Desk', 'Sofa', 'Chair']);

$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);

$intersect->all();

// [0 => 'Desk', 2 => 'Chair']

如您所见，结果集合将保留原始集合的键。

isEmpty()

isEmpty 方法如果集合为空，则返回 true；否则，返回 false

collect([])->isEmpty();

// true

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 ($key, $value) {
    return $value < 3;
});

// 2

您还可以不带参数调用last方法来获取集合中的最后一个元素。如果集合为空，则返回null

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

// 4

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]

注意：与大多数其他集合方法一样，map返回一个新的集合实例；它不会修改被调用的集合。如果您想转换原始集合，请使用transform方法。

max

max方法返回给定键的最大值

$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');

// 20

$max = collect([1, 2, 3, 4, 5])->max();

// 5

merge

merge方法将给定的数组合并到集合中。任何与集合中字符串键匹配的数组中的字符串键将覆盖集合中的值

$collection = collect(['product_id' => 1, 'name' => 'Desk']);

$merged = $collection->merge(['price' => 100, 'discount' => false]);

$merged->all();

// ['product_id' => 1, 'name' => 'Desk', 'price' => 100, '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

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方法。

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

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。如果该整数大于1，则返回一个项目集合

$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 ($item) {
    return $item > 2;
});

$filtered->all();

// [1, 2]

有关 reject 方法的逆方法，请参阅 filter 方法。

reverse()

reverse 方法反转集合中项的顺序。

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

$reversed = $collection->reverse();

$reversed->all();

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

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]

返回的切片将具有新的、数字索引的键。如果您希望保留原始键，请将 true 作为方法的第三个参数传递。

sort()

sort 方法对集合进行排序。

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

$sorted = $collection->sort();

$sorted->values()->all();

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

排序后的集合保留原始数组键。在此示例中，我们使用了 values 方法将键重置为连续编号的索引。

有关对嵌套数组或对象的集合进行排序，请参阅 sortBy 和 sortByDesc 方法。

如果您的排序需求更复杂，您可以将回调函数传递给 sort，并使用您自己的算法。请参阅 PHP 文档中关于 usort 的说明，这是集合的 sort 方法在底层调用的函数。

sortBy()

sortBy 方法按给定键对集合进行排序。

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

排序后的集合保留原始数组键。在此示例中，我们使用了 values 方法将键重置为连续编号的索引。

您还可以传递自己的回调函数来确定如何对集合值进行排序。

$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 方法具有相同的签名，但将按相反的顺序对集合进行排序。

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]

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]

toArray()

toArray 方法将集合转换为普通的 PHP array

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

$collection->toArray();

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

注意： 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]

注意： 与大多数其他集合方法不同，transform 会修改集合本身。如果您希望创建一个新的集合，请使用 map 方法。

unique()

unique 方法返回集合中所有唯一的项

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

$unique = $collection->unique();

$unique->values()->all();

// [1, 2, 3, 4]

返回的集合保留原始数组键。在这个例子中，我们使用了 values 方法将键重置为连续编号的索引。

处理嵌套数组或对象时，您可以指定用于确定唯一性的键

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

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

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 方法在检查项值时使用严格比较。使用 whereLoose 方法进行“宽松”比较。

whereLoose()

此方法与 where 方法具有相同的签名；然而，所有值都使用“宽松”比较进行对比。

zip()

zip 方法将给定数组中的值与集合在相应索引处的值合并在一起

$collection = collect(['Chair', 'Desk']);

$zipped = $collection->zip([100, 200]);

$zipped->all();

// [['Chair', 100], ['Desk', 200]]

何时进行更新？

当 Laravel 的集合类进行了重大更改时，将更新此存储库。认为应该更新？请提交一个问题。

我能贡献改进/修复吗？

这个仓库是自动生成的，使用了一个涉及大量黑魔法/巫术的脚本。这个脚本从Laravel仓库中拉取集合代码并“重写”它，以便可以自己使用。因此，对这个仓库中代码的任何修改都会在脚本运行时被覆盖。如果你仍然有兴趣贡献，可以考虑直接向Laravel贡献。

动机/为什么会有这件事？

Collection辅助类非常实用，几乎可以成为一个独立的Composer包（因为为什么不呢？）。但主要这是一个实验，看看我是否可以创建一个小脚本，从Laravel仓库中的代码自动生成这个仓库中看到的代码。

然而，因为Collection辅助类非常实用，我相信有人会从这个小程序库中找到价值。