مجموعه ها

• معرفی
  • ایجاد مجموعه ها
  • گسترش مجموعه ها
• روش های موجود
• پیام های سفارش بالاتر
• مجموعه های تنبل
  • معرفی
  • ایجاد مجموعه های تنبل
  • قرارداد قابل شمارش
  • روش های مجموعه تنبل

معرفی

این Illuminate\Support\Collection کلاس یک پوشش روان و راحت برای کار با آرایه های داده ارائه می دهد. برای مثال کد زیر را بررسی کنید. ما از collect کمک کننده برای ایجاد یک نمونه مجموعه جدید از آرایه استفاده می کنیم، strtoupper تابع را روی هر عنصر اجرا می کنیم و سپس همه عناصر خالی را حذف می کنیم:

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

همانطور که می بینید، Collection کلاس به شما اجازه می دهد تا متدهای خود را برای انجام نگاشت روان و کاهش آرایه زیرین زنجیره بزنید. به طور کلی، مجموعه ها تغییر ناپذیر هستند، به این معنی که هر Collection روش یک نمونه کاملاً جدید را برمی گرداند Collection .

ایجاد مجموعه ها

همانطور که در بالا ذکر شد، collect کمک کننده یک نمونه جدید Illuminate\Support\Collection برای آرایه داده شده برمی گرداند. بنابراین، ایجاد یک مجموعه به همین سادگی است:

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

نتایج جستجوهای Eloquent همیشه به عنوان Collection نمونه برگردانده می شوند.

گسترش مجموعه ها

مجموعه ها "macroable" هستند، که به شما امکان می دهد روش های اضافی را Collection در زمان اجرا به کلاس اضافه کنید. به عنوان مثال، کد زیر یک toUpper متد را به Collection کلاس اضافه می کند:

use Illuminate\Support\Collection;
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 نمونه جدید را برمی گرداند و به شما امکان می دهد در صورت لزوم نسخه اصلی مجموعه را حفظ کنید:

فهرست روش

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]

collect()

این collect روش یک نمونه جدید را Collection با مواردی که در حال حاضر در مجموعه هستند برمی گرداند:

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

این collect روش در درجه اول برای تبدیل مجموعه های تنبل به نمونه های استاندارد مفید است Collection :

$lazyCollection = LazyCollection::make(function () {
    yield 1;
    yield 2;
    yield 3;
});
 
$collection = $lazyCollection->collect();
 
get_class($collection);
 
// 'Illuminate\Support\Collection'
 
$collection->all();
 
// [1, 2, 3]

این collect روش مخصوصاً زمانی مفید است که شما یک نمونه از Enumerable مجموعه غیر تنبل دارید و نیاز دارید. از آنجایی که collect() بخشی از Enumerable قرارداد است، می توانید با خیال راحت از آن برای دریافت Collection نمونه استفاده کنید.

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 روش است. با این حال، تمام مقادیر با استفاده از مقایسه "سخت" مقایسه می شوند.

رفتار این روش هنگام استفاده از Eloquent Collections اصلاح می شود .

count()

این count روش تعداد کل آیتم های مجموعه را برمی گرداند:

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

countBy()

این countBy روش تعداد مقادیر در مجموعه را شمارش می کند. به‌طور پیش‌فرض، این متد وقوع هر عنصر را شمارش می‌کند:

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

با این حال، شما یک callback به countBy روش ارسال می کنید تا همه موارد را با یک مقدار سفارشی شمارش کنید:

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

متد 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 ساده array بر اساس مقادیر آن مقایسه می کند. این متد مقادیر موجود در مجموعه اصلی را که در مجموعه داده شده وجود ندارد برمی گرداند:

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

رفتار این روش هنگام استفاده از Eloquent Collections اصلاح می شود .

diffAssoc()

این diffAssoc روش مجموعه را با یک مجموعه دیگر یا یک PHP ساده array بر اساس کلیدها و مقادیر آن مقایسه می کند. این روش جفت‌های کلید/مقدار را در مجموعه اصلی که در مجموعه داده‌شده وجود ندارد، برمی‌گرداند:

$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 ساده array بر اساس کلیدهای آن مقایسه می کند. این روش جفت‌های کلید/مقدار را در مجموعه اصلی که در مجموعه داده‌شده وجود ندارد، برمی‌گرداند:

$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 به جای آن از روش استفاده کنید.

duplicates()

متد 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']

duplicatesStrict()

این روش دارای امضای مشابه duplicates روش است. با این حال، تمام مقادیر با استفاده از مقایسه "سخت" مقایسه می شوند.

each()

متد each روی آیتم های مجموعه تکرار می شود و هر آیتم را به یک فراخوان ارسال می کند:

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

اگر می‌خواهید تکرار موارد را متوقف کنید، می‌توانید false از پاسخ به تماس خود بازگردید:

$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

اگر مجموعه خالی باشد، every true برمی گردد:

$collection = collect([]);
 
$collection->every(function ($value, $key) {
    return $value > 2;
});
 
// true

except()

متد except تمام موارد موجود در مجموعه را به جز مواردی که دارای کلیدهای مشخص شده هستند برمی گرداند:

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

برای معکوس except ، تنها روش را ببینید.

رفتار این روش هنگام استفاده از Eloquent Collections اصلاح می شود .

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 ، روش رد را ببینید .

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' => null],
    ['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]

مانند متد Where ، می‌توانید یک آرگومان را به firstWhere متد ارسال کنید. در این سناریو، firstWhere متد اولین مورد را برمی‌گرداند که در آن مقدار کلید مورد داده‌شده «درست» است:

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

flatMap()

متد flatMap از طریق مجموعه تکرار می شود و هر مقدار را به callback داده شده ارسال می کند. بازخوانی برای اصلاح آیتم و بازگرداندن آن آزاد است، بنابراین مجموعه جدیدی از آیتم های اصلاح شده تشکیل می شود. سپس، آرایه با یک سطح صاف می شود:

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

شما می توانید به صورت اختیاری تابع را آرگومان "depth" ارسال کنید:

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

برخلاف اکثر روش‌های جمع‌آوری دیگر، 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

حتی ممکن است یک callback را به عنوان مقدار پیش فرض ارسال کنید. اگر کلید مشخص شده وجود نداشته باشد، نتیجه تماس برگشتی برگردانده خواهد شد:

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

معیارهای گروه بندی چندگانه ممکن است به عنوان یک آرایه ارسال شوند. هر عنصر آرایه به سطح مربوطه در یک آرایه چند بعدی اعمال می شود:

$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', 'amount' => 5]);
 
$collection->has('product');
 
// true
 
$collection->has(['product', 'amount']);
 
// true
 
$collection->has(['amount', 'price']);
 
// 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']

رفتار این روش هنگام استفاده از Eloquent Collections اصلاح می شود .

intersectByKeys()

این intersectByKeys روش کلیدهایی را از مجموعه اصلی که در مجموعه داده شده array یا مجموعه وجود ندارد حذف می کند:

$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

join()

این 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()

متد 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()

متد static به شما امکان می دهد در زمان اجرا macro متدهایی را به کلاس اضافه کنید . برای اطلاعات بیشتر Collection به اسناد گسترش مجموعه ها مراجعه کنید.

make()

روش استاتیک make یک نمونه مجموعه جدید ایجاد می کند. به بخش ایجاد مجموعه ها مراجعه کنید .

map()

متد map از طریق مجموعه تکرار می شود و هر مقدار را به callback داده شده ارسال می کند. پاسخ به تماس برای اصلاح مورد و بازگرداندن آن آزاد است، بنابراین مجموعه جدیدی از موارد اصلاح شده تشکیل می شود:

$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 روش استفاده کنید.

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 ($even, $odd) {
    return $even + $odd;
});
 
$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' => ['Johnny Doe'],
    ]
*/
 
$grouped->get('Sales')->all();
 
// ['John Doe', 'Jane Doe']

mapWithKeys()

متد mapWithKeys از طریق مجموعه تکرار می شود و هر مقدار را به callback داده شده ارسال می کند. تماس برگشتی باید یک آرایه انجمنی حاوی یک جفت کلید / مقدار را برگرداند:

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

mergeRecursive()

این mergeRecursive روش آرایه یا مجموعه داده شده را به صورت بازگشتی با مجموعه اصلی ادغام می کند. اگر یک کلید رشته ای در آیتم های داده شده با کلید رشته ای در مجموعه اصلی مطابقت داشته باشد، آنگاه مقادیر این کلیدها با هم در یک آرایه ادغام می شوند و این به صورت بازگشتی انجام می شود:

$collection = collect(['product_id' => 1, 'price' => 100]);
 
$merged = $collection->mergeRecursive(['product_id' => 2, 'price' => 200, 'discount' => false]);
 
$merged->all();
 
// ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]

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

شما می توانید به صورت اختیاری یک offset را به عنوان آرگومان دوم ارسال کنید:

$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 ، به روش استثنا مراجعه کنید .

رفتار این روش هنگام استفاده از Eloquent Collections اصلاح می شود .

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

pipe()

متد pipe مجموعه را به callback داده شده ارسال می کند و نتیجه را برمی گرداند:

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

این pluck روش همچنین از بازیابی مقادیر تو در تو با استفاده از نماد "نقطه" پشتیبانی می کند:

$collection = collect([
    [
        'speakers' => [
            'first_day' => ['Rosa', 'Judith'],
            'second_day' => ['Angela', 'Kathleen'],
        ],
    ],
]);
 
$plucked = $collection->pluck('speakers.first_day');
 
$plucked->all();
 
// ['Rosa', 'Judith']

اگر کلیدهای تکراری وجود داشته باشد، آخرین عنصر منطبق در مجموعه برداشته شده درج می شود:

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