乐趣区

关于php:Laravel-中的-Collection-基本使用

jiezi

汇合是 Laravel 中提供的最弱小的性能之一，汇合实质上是由功能强大的数组组成。

把相似数组的对象利用到办法中是很有用的，通过链式编程，用极短的代码，就能够达到预期的成果。

须要留神的是汇合并不是 Laravel 中独有的，许多语言都能够在数组中应用汇合式编程，但十分遗憾，原生的 PHP 是不反对汇合式编程的，不过侥幸的是，一些勤奋的人曾经为咱们实现了艰辛的工作，并编写了一个十分不便的包——illuminate/support、Tightenco/Collect。

一般来说，汇合是不可扭转的，这意味着大部分 Collection 办法都会返回一个全新的 Collection 实例。

创立汇合

为了创立一个汇合，能够将一个数组传入汇合的结构器中，也能够创立一个空的汇合，而后把元素写到汇合中。Laravel 有 collect() 助手，这是最简略的，新建汇合的办法。

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

默认状况下，Eloquent 查问的后果返回的内容都是 Illuminate\Support\Collection 实例，如果心愿对后果进行序列化，能够应用toArray()、toJson() 办法。

在非 Laravel 我的项目中应用汇合：

装置：

composer require illuminate/support

应用：

<?php
// 引入 package
require __DIR__ . '/vendor/autoload.php';

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

记住，所有办法都能够应用链式编程的形式优雅的操纵数组。而且简直所有的办法都会返回 新的 Collection 实例，

all

返回该汇合示意的底层数组。

collect(["boo", "yumi", "mac"])->all();
// [“boo”, "yumi", "mac"]

avg

获取数组的平均值：

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

获取二维数组的平均值：

collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->avg('foo'); // 20

avg()是average() 的别名，两者的成果是一样的。

chunk

将大汇合按指定大小拆分成小汇合。

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

chunkWhile

依据指定的回调值把汇合分解成多个更小的汇合：

$collection = collect(str_split('AABBCCCD'));

$chunks = $collection->chunkWhile(function ($current, $key, $chunk) {return $current === $chunk->last();
});

$chunks->all();
// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]

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

将一个汇合的值作为「键」，再将另一个数组或者汇合的值作为「值」合并成一个汇合。

$collection = collect(['name', 'age']);
$combined = $collection->combine(['boo', 25]);
$combined->all();
// ['name' => 'boo', 'age' => 25]

collect

返回一个蕴含以后汇合所含元素的新的 Collection 实例：

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

concat

在汇合的末端附加指定的数组或汇合值：

$collection = collect(['John Doe']);
$concatenated = $collection->concat(['Boo'])->concat(['name' => 'Yumi']);
$concatenated->all();
// ['John Doe', 'Boo', 'Yumi']

contains

判断汇合是否蕴含给定的我的项目。

根本用法：

$collection = collect(['name' => 'boo', 'age' => 25]);
$collection->contains('boo');  // true
$collection->contains('yumi'); // false

也能够用 contains 办法匹配一对键 / 值，即判断给定的配对是否存在于汇合中：

$collection = collect([['name' => 'boo', 'age' => 25],
    ['name' => 'yumi', 'age' => 23],
]);

$collection->contains("name", "mac");  // false

也能够传递一个回调到 contains 办法来执行本人的实在测试：

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

// $value: 1 $key: 0
$collection->contains(function ($value, $key) {return $value > 5;}); // false

contains 办法在查看我的项目值时应用「宽松」比拟，意味着具备整数值的字符串将被视为等于雷同值的整数。相同 containsStrict 办法则是应用「严格」比拟进行过滤。

containsStrict

应用「严格模式」判断汇合是否蕴含给定的我的项目：

根本应用：

$collection = collect([['name' => 'boo', 'age' => 25],
    ['name' => 'yumi', 'age' => 23],
]);

$collection->containsStrict("age", "25");  // false

如上例所示，数组值存在，然而值类型不统一也返回 false。

count

返回该汇合内的我的项目总数。

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

countBy

统计汇合中每个元素呈现的次数。

根本用法：

$collection = collect([1, 2, 2, 2, 3, 5, 5]);
$counted = $collection->countBy();
$counted->all();
// [1 => 1, 2 => 3, 3 => 1, 5=>2]

进阶用法，自定义规定，统计元素呈现的次数：

$collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);
$counted = $collection->countBy(function ($email) {return substr(strrchr($email, "@"), 1);
});
$counted->all();
// ['gmail.com' => 2, 'yahoo.com' => 1]

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

备份文件零碎和进行零碎（dump and die）的缩写，打印汇合元素并中断脚本执行。

$collection = collect(['John Doe', 'Jane Doe']);
$collection->dd();

如果不想中断执行脚本，请应用 dump 办法代替。

diff

与给定的汇合或者数组进行比拟，基于值求差集。

将汇合与其它汇合或纯 PHP 数组进行值的比拟，而后返回原汇合中存在而给定汇合中不存在的值：

$collection = collect([1, 2, 3, 4, 5]);
$collection->diff([2, 4, 6, 8])->all();   // [1, 3, 5]

diffAssoc

与给定的汇合或者数组进行比拟，基于键值对求差集。

返回原汇合不存在于给定汇合中的键值对：

$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

与给定的汇合或者数组进行比拟，基于键求差集。

返回原汇合中存在而给定的汇合中不存在「键」所对应的键值对：

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

duplicates

从汇合中检索并返回反复的值。

根本用法：

$collection = collect(['a', 'b', 'a', 'c', 'b']);
$collection->duplicates();
// [2 => 'a', 4 => 'b']

如果汇合蕴含数组或对象，则能够传递心愿查看反复值的属性的键：

$employees = collect([['email' => 'abigail@example.com', 'position' => 'Developer'],
    ['email' => 'james@example.com', 'position' => 'Designer'],
    ['email' => 'victoria@example.com', 'position' => 'Developer'],
])

$employees->duplicates('position');
// [2 => 'Developer']

duplicates 办法在查看我的项目值时应用「宽松」比拟，相同duplicatesStrict 办法则是应用「严格」比拟进行过滤。

each

迭代汇合中的内容并将其传递到回调函数中。

$collection = $collection->each(function ($item, $key) {
    // 如果要中断对内容的迭代，那就从回调中返回 false
    if (/* some condition */) {return false;}
});

eachSpread

同样是遍历汇合，不过与 each 的区别在于，对于多维数组，能够间接拿到元素。

$collection = collect([['Boo', 25, "men"], ['Yumi', 23, "woman"]]);

$collection->eachSpread(function ($name, $age, $gender) {var_dump($name, $age, $gender);
    // Boo、25、men
    // Yumi、23、woman
});

$collection->each(function ($item, $key){
   // 同样能够在回调函数中，返回 false，终止循环
   var_dump($item, $key);
});
/*
    array(3) {[0]=>
      string(3) "Boo"
      [1]=>
      int(25)
      [2]=>
      string(3) "men"
    }
*/

every

查看汇合中的每一个元素是否通过指定条件：

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

// false

留神：如果汇合为空，every 将返回 true。

except

返回汇合中除了指定键以外的所有我的项目。

$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
$filtered = $collection->except(['price', 'discount']);
$filtered->all(); // ['product_id' => 1]

与之相同的办法是 only()。

filter

应用给定的回调函数过滤汇合的内容，只留下那些通过的元素。

$collection = collect([1, 2, 3, 4]);
$filtered = $collection->filter(function ($value, $key) {
    // 当闭包返回 true 时，保留一个条目
    return $value > 2;
});
$filtered->all(); // [3, 4]

如果没有提供回调函数，汇合中所有返回 false 的元素都会被移除：

$collection = collect([1, 2, 3, null, false, '', 0, []]);
$collection->filter()->all(); // [1, 2, 3]

与之相同的办法是 reject()。

first

返回汇合中的第一个元素。

根本用法：

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

同样能够传入回调函数，进行条件限度：

collect([1, 2, 3, 4])->first(function ($value, $key) {
    // 当闭包返回 true 时，保留一个条目
    return $value > 2;
}); // 3

如果须要返回最初一个元素能够应用last() 办法。

firstWhere

返回汇合中含有指定键 / 值对的第一个元素：

$collection = collect([['name' => 'Regena', 'age' => null],
    ['name' => 'Linda', 'age' => 14],
    ['name' => 'Diego', 'age' => 23],
    ['name' => 'Linda', 'age' => 84],
]);

// 返回 name = Linda 的第一个元素
$collection->firstWhere('name', 'Linda');
// ['name' => 'Linda', 'age' => 14]

还能够在 firstWhere 中应用算术运算符：

$collection->firstWhere('age', '>=', 18);
// ['name' => 'Diego', 'age' => 23]

和 where 办法一样，你能够将一个参数传递给 firstWhere 办法。在这种状况下，firstWhere 办法将返回指定键的值为「真」的第一个汇合项：

$collection->firstWhere('age');
// ['name' => 'Linda', 'age' => 14]

firstMap

遍历汇合并将其中的每个值传递到给定的回调。

能够通过回调批改每个值的内容再返回进去，从而造成一个新的被批改过内容的汇合：

$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

将多维汇合转为一维。

根本用法：

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

$collection->flatten()->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

键值反转。

$collection = collect(["name" => "boo", "age" => 25]);
$collection->flip()->all();  // ["boo" => "name", 25 => "age"]

forget

通过给定的键来移除掉汇合中对应的内容。

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$collection->forget('name');
$collection->all(); 
// ['framework' => 'laravel']

与大多数汇合的办法不同，forget() 不会返回批改过后的新汇合；它会间接批改原来的汇合。

get

返回给定键的我的项目。

根本用法，如果该键不存在，则返回 null：

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('name'); // taylor

能够传递第二个参数作为默认值：

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('foo', 'boo'); // boo

甚至能够将回调函数当作默认值。如果指定的键不存在，就会返回回调的后果：

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$collection->get('email', function () {return 'boo';}); // boo

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->all();

/*
    [
        '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->all();

/*
    [
        '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

判断汇合中是否存在给定的键。

$collection = collect(["name" => "boo", "age" => 25]);
$collection->has("name");  // 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

从原汇合中移除不在给定数组或汇合中的『任何值』，返回新的汇合将保留原汇合的键。

$collection = collect(['Desk', 'Sofa', 'Chair']);
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
$intersect->all();
// [0 => 'Desk', 2 => 'Chair']

intersectKey

删除原汇合中不存在于给定数组或汇合中的『任何键』，返回新的汇合将保留原汇合的键。

$collection = collect(['serial' => 'UX301', 'type' => 'screen', 'year' => 2009,]);

$intersect = $collection->intersectByKeys(['reference' => 'UX404', 'type' => 'tab', 'year' => 2011,]);
$intersect->all();
// ['type' => 'screen', 'year' => 2009]

isEmpty

判断汇合是否为空。

collect([])->isEmpty(); // true

isNotEmpty

判断汇合是否不为空。

collect([])->isEmpty(); // false

join

将汇合中的值用字符串连贯。

collect(['a', 'b', 'c'])->join(','); // 'a, b, c'
collect(['a', 'b', 'c'])->join(',', ', and'); // 'a, b, and c'
collect(['a', 'b'])->join(',', 'and'); // 'a and b'
collect(['a'])->join(',', 'and'); // 'a'
collect([])->join(',', 'and'); // ''

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

返回汇合的所有键。

$collection = collect(["name" => "boo", "age" => 25]);
$collection->keys()->all();  // ["name", "age"]

last

返回汇合中通过给定实在测试的最初一个元素，与first 办法正好相同。

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

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

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->all();

/*
    ['Sales' => ['John Doe', 'Jane Doe'],
        'Marketing' => ['Johnny Doe'],
    ]
*/

$grouped->get('Sales')->all();
// ['John Doe', 'Jane Doe']

mapWithKeys

遍历汇合并将每个值传入给定的回调。

max

返回指定键的最大值。

$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');   // 20
$max = collect([1, 2, 3, 4, 5])->max();   // 5

median

返回指定键的两头值。

$median = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->median('foo');   // 15
$median = collect([1, 1, 2, 4])->median();  // 1.5

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 = collect([1, 2, 3, 4, 5])->min();     // 1

mode

返回指定键的众数值。

collect([1, 1, 2, 4])->mode();    // [1]

nth

每隔 n 个元素取一个元素组成一个新的汇合。

$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
$collection->nth(4);    // ['a', 'e']

// 第二个参数能够作为偏移地位 
$collection->nth(4, 1); // ['b', 'f']

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

partition

配合 list()办法辨别回调函数满足和不满足的数据。

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

list($underThree, $equalOrAboveThree) = $collection->partition(function ($i) {return $i < 3;});
$underThree->all();     // [1, 2]
$equalOrAboveThree->all();    // [3, 4, 5, 6]

pipe

将汇合传给给定的回调并返回后果。

$collection = collect([1, 2, 3]);
$piped = $collection->pipe(function ($collection) {return $collection->sum();
}); // 6

pluck

获取汇合中给定键对应的所有值。

根本用法：

$collection = collect([['product_id' => 'prod-100', 'name' => 'Desk', "id" => 1],
    ['product_id' => 'prod-200', 'name' => 'Chair', "id" => 2],
]);

$plucked = $collection->pluck('name');
$plucked->all();    // ['Desk', 'Chair']

还能够传入第二个参数作为键值：

$plucked = $collection->pluck('name', "id");
$plucked->all();    // [1 => 'Desk', 2 => 'Chair']

pop

移除并返回汇合中的最初一个我的项目。

prepend

将给定的值增加到汇合的结尾。

pull

把给定键对应的值从汇合中移除并返回。

push

把给定值增加到汇合的开端。

put

在汇合内设置给定的键值对。

random

从汇合中返回一个随机项。

reduce

将每次迭代的后果传递给下一次迭代直到汇合缩小为单个值。

reject

应用指定的回调过滤汇合。

reverse

倒转汇合中我的项目的程序。

search

搜寻给定的值并返回它的键。

shift

移除并返回汇合的第一个我的项目。

shuffle

随机排序汇合中的我的项目。

slice

返回汇合中给定值前面的局部。

sort

保留原数组的键，对汇合进行排序。

sortBy

以给定的键对汇合进行排序。

sortByDesc

与 sortBy 一样，以相同的程序来对汇合进行排序。

splice

删除并返回从给定值后的内容，原汇合也会受到影响。

split

将汇合按给定的值拆分。

sum

返回汇合内所有我的项目的总和。

take

返回给定数量我的项目的新汇合。

tap

将汇合传递给回调，在特定点「tap」汇合。

times

通过回调在给定次数内创立一个新的汇合。

toArray

将汇合转换成 PHP 数组。

toJson

将汇合转换成 JSON 字符串。

transform

迭代汇合并对汇合内的每个我的项目调用给定的回调。

union

将给定的数组增加到汇合中。

unique

返回汇合中所有惟一的我的项目。

uniqueStrict

应用严格模式返回汇合中所有惟一的我的项目。

values

返回键被重置为间断编号的新汇合。

when

当传入的第一个参数为 true 的时，将执行给定的回调。

where

通过给定的键值过滤汇合。

whereStrict

应用严格模式通过给定的键值过滤汇合。

whereIn

通过给定的键值数组来过滤汇合。

whereInStrict

应用严格模式通过给定的键值数组来过滤汇合。

whereNotIn

汇合中不蕴含的给定键值对进行匹配。

whereNotInStrict

应用严格模式通过汇合中不蕴含的给定键值对进行匹配。

zip

将给定数组的值与相应索引处的原汇合的值合并在一起。

参考链接

  • Laravel 的汇合 Collection
  • Laravel 汇合——Laravel8.x 中文文档
退出移动版