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

汇合是 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 实例，

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

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

获取数组的平均值：

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

获取二维数组的平均值：

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

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

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

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

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

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

将多个数组合并成一个汇合。

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

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

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

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

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

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

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

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

根本用法：

$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 办法则是应用「严格」比拟进行过滤。

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

根本应用：

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

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

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

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

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

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

根本用法：

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

返回指定汇合的可能的笛卡尔积。

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

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

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

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

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

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

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

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

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

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

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

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

$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 = 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 办法则是应用「严格」比拟进行过滤。

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

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

同样是遍历汇合，不过与 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"
    }
*/

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

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

// false

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

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

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

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

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

$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()。

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

根本用法：

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

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

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

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

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

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

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

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

$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(['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']，传入深度参数能限度设置返回数组的层数。

键值反转。

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

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

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

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

返回给定键的我的项目。

根本用法，如果该键不存在，则返回 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

依据给定的键对汇合内的我的项目进行分组。

根本用法：

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

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

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

合并汇合中的我的项目。

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'

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

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

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

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

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

判断汇合是否为空。

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

判断汇合是否不为空。

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

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

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'); // ''

以给定的键作为汇合的键。

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

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

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

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

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

通过指定回调函数对汇合进行分组，

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

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

返回指定键的最大值。

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

返回指定键的两头值。

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

将给定数组或汇合合并到原汇合。

如果给定的汇合项的字符串键与原汇合中的字符串键相匹配，则指定汇合项的值将笼罩原汇合的值：

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

返回指定键的众数值。

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

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

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

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

返回汇合中给定键的所有我的项目。

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

配合 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]

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

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

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

根本用法：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

将汇合按给定的值拆分。

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

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

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

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

将汇合转换成 PHP 数组。

将汇合转换成 JSON 字符串。

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

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

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

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

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

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

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

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

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

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

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

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

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

Laravel 的汇合 Collection
Laravel 汇合——Laravel8.x 中文文档

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

创立汇合

all

avg

chunk

chunkWhile

collapse

combine

collect

concat

contains

containsStrict

count

countBy

crossJoin

dd

diff

diffAssoc

diffKeys

duplicates

each

eachSpread

every

except

filter

first

firstWhere

firstMap

flatten

flip

forget

get

groupBy

has

implode

intersect

intersectKey

isEmpty

isNotEmpty

join

keyBy

keys

last

map

mapToGroups

mapWithKeys

max

median

merge

min

mode

nth

only

partition

pipe

pluck

pop

prepend

pull

push

put

random

reduce

reject

reverse

search

shift

shuffle

slice

sort

sortBy

sortByDesc

splice

split

sum

take

tap

times

toArray

toJson

Just My Socks（注册教程内含优惠码）