مجموعه ها

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

معرفی

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

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

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

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

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

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

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

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

مجموعه ها "macroable" هستند، که به شما امکان می دهد روش های اضافی را Collection در زمان اجرا به کلاس اضافه کنید. متد Illuminate\Support\Collection کلاس macro یک بسته را می پذیرد که با فراخوانی ماکرو شما اجرا می شود. بسته شدن ماکرو ممکن است به روش های دیگر مجموعه از طریق دسترسی پیدا کند $this ، درست مثل اینکه یک متد واقعی از کلاس مجموعه باشد. به عنوان مثال، کد زیر یک toUpper متد را به Collection کلاس اضافه می کند:

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
 
Collection::macro('toUpper', function () {
    return $this->map(function (string $value) {
        return Str::upper($value);
    });
});
 
$collection = collect(['first', 'second']);
 
$upper = $collection->toUpper();
 
// ['FIRST', 'SECOND']

به طور معمول، شما باید ماکروهای مجموعه را در boot روش ارائه دهنده خدمات اعلام کنید .

استدلال های کلان

در صورت لزوم، می توانید ماکروهایی را تعریف کنید که آرگومان های اضافی را بپذیرند:

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Lang;
 
Collection::macro('toLocale', function (string $locale) {
    return $this->map(function (string $value) use ($locale) {
        return Lang::get($value, [], $locale);
    });
});
 
$collection = collect(['first', 'second']);
 
$translated = $collection->toLocale('es');

روش های موجود

برای اکثر اسناد مجموعه باقیمانده، در مورد هر روش موجود در 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->all();
 
// [[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

chunkWhile()

این chunkWhile روش مجموعه را به مجموعه‌های چندگانه و کوچک‌تر بر اساس ارزیابی تماس داده شده تقسیم می‌کند. متغیر $chunk ارسال شده به بسته شدن ممکن است برای بازرسی عنصر قبلی استفاده شود:

$collection = collect(str_split('AABBCCCD'));
 
$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) {
    return $value === $chunk->last();
});
 
$chunks->all();
 
// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]

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]

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();
 
$collection::class;
 
// 'Illuminate\Support\Collection'
 
$collection->all();
 
// [1, 2, 3]

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

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

این concat روش به صورت عددی کلیدها را برای مواردی که به مجموعه اصلی الحاق شده اند دوباره فهرست می کند. برای نگهداری کلیدها در مجموعه های انجمنی، به روش ادغام مراجعه کنید .

contains()

این contains روش تعیین می کند که آیا مجموعه شامل یک آیتم معین است یا خیر. می‌توانید contains برای تعیین اینکه آیا عنصری در مجموعه وجود دارد که با آزمون صدق داده شده مطابقت دارد، یک بسته را به روش بفرستید :

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->contains(function (int $value, int $key) {
    return $value > 5;
});
 
// false

از طرف دیگر، می‌توانید رشته‌ای را به 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 روش هنگام بررسی مقادیر آیتم از مقایسه‌های "لست" استفاده می‌کند، به این معنی که رشته‌ای با مقدار صحیح برابر با یک عدد صحیح با همان مقدار در نظر گرفته می‌شود. از روشی برای فیلتر کردن با استفاده از مقایسه های "سخت" استفاده کنید containsStrict .

برای معکوس contains ، به روش doestContain مراجعه کنید .

containsOneItem()

این containsOneItem روش تعیین می کند که آیا مجموعه شامل یک آیتم واحد است یا خیر:

collect([])->containsOneItem();
 
// false
 
collect(['1'])->containsOneItem();
 
// true
 
collect(['1', '2'])->containsOneItem();
 
// false

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]

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

$collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);
 
$counted = $collection->countBy(function (string $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]

diffAssocUsing()

بر خلاف diffAssoc , diffAssocUsing یک تابع تماس ارائه شده توسط کاربر را برای مقایسه شاخص ها می پذیرد:

$collection = collect([
    'color' => 'orange',
    'type' => 'fruit',
    'remain' => 6,
]);
 
$diff = $collection->diffAssocUsing([
    'Color' => 'yellow',
    'Type' => 'fruit',
    'Remain' => 3,
], 'strnatcasecmp');
 
$diff->all();
 
// ['color' => 'orange', 'remain' => 6]

فراخوانی باید تابع مقایسه ای باشد که عدد صحیح کمتر، مساوی یا بزرگتر از صفر را برمی گرداند. برای اطلاعات بیشتر، به مستندات PHP در مورد مراجعه کنید array_diff_uassoc ، که تابع PHP است که diffAssocUsing متد به صورت داخلی از آن استفاده می کند.

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]

doesntContain()

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

$collection = collect([1, 2, 3, 4, 5]);
 
$collection->doesntContain(function (int $value, int $key) {
    return $value < 5;
});
 
// false

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

$collection = collect(['name' => 'Desk', 'price' => 100]);
 
$collection->doesntContain('Table');
 
// true
 
$collection->doesntContain('Desk');
 
// false

همچنین می‌توانید یک جفت کلید/مقدار را به doesntContain متد ارسال کنید، که تعیین می‌کند آیا جفت داده شده در مجموعه وجود ندارد:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
]);
 
$collection->doesntContain('product', 'Bookcase');
 
// true

این doesntContain روش هنگام بررسی مقادیر آیتم از مقایسه‌های "لست" استفاده می‌کند، به این معنی که رشته‌ای با مقدار صحیح برابر با یک عدد صحیح با همان مقدار در نظر گرفته می‌شود.

dot()

این dot روش یک مجموعه چند بعدی را به یک مجموعه سطح واحد مسطح می کند که از نماد "نقطه" برای نشان دادن عمق استفاده می کند:

$collection = collect(['products' => ['desk' => ['price' => 100]]]);
 
$flattened = $collection->dot();
 
$flattened->all();
 
// ['products.desk.price' => 100]

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 = collect([1, 2, 3, 4]);
 
$collection->each(function (int $item, int $key) {
    // ...
});

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

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

eachSpread()

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

$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
 
$collection->eachSpread(function (string $name, int $age) {
    // ...
});

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

$collection->eachSpread(function (string $name, int $age) {
    return false;
});

ensure()

این ensure روش ممکن است برای تأیید اینکه همه عناصر یک مجموعه از یک نوع معین یا لیستی از انواع هستند استفاده شود. در غیر این صورت، یک UnexpectedValueException پرتاب می شود:

return $collection->ensure(User::class);
 
return $collection->ensure([User::class, Customer::class]);

انواع ابتدایی مانند string ،،،، و نیز ممکن است مشخص شوند : int float bool array

return $collection->ensure('int');

این ensure روش تضمین نمی کند که عناصری از انواع مختلف در زمان بعدی به مجموعه اضافه نشوند.

every()

این every روش ممکن است برای تأیید اینکه همه عناصر یک مجموعه از آزمون صدق معین عبور می کنند استفاده شود:

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

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

$collection = collect([]);
 
$collection->every(function (int $value, int $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 (int $value, int $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 (int $value, int $key) {
    return $value > 2;
});
 
// 3

همچنین می توانید first متد را بدون آرگومان فراخوانی کنید تا اولین عنصر مجموعه را بدست آورید. اگر مجموعه خالی باشد، null برگردانده می شود:

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

firstOrFail()

روش firstOrFail مشابه first روش است. با این حال، اگر نتیجه ای یافت نشد، یک Illuminate\Support\ItemNotFoundException استثنا ایجاد می شود:

collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) {
    return $value > 5;
});
 
// Throws ItemNotFoundException...

همچنین می توانید firstOrFail متد را بدون آرگومان فراخوانی کنید تا اولین عنصر مجموعه را بدست آورید. اگر مجموعه خالی باشد، یک Illuminate\Support\ItemNotFoundException استثنا پرتاب می شود:

collect([])->firstOrFail();
 
// Throws ItemNotFoundException...

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

$collection = collect([
    ['name' => 'Sally'],
    ['school' => 'Arkansas'],
    ['age' => 28]
]);
 
$flattened = $collection->flatMap(function (array $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'];

در صورت لزوم، می توانید به flatten روش یک آرگومان "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('age', 34);
 
// 34

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

$collection->get('email', function () {
    return 'taylor@example.com';
});
 
// taylor@example.com

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->all();
 
/*
    [
        '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 (array $item, int $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 (array $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

hasAny()

این hasAny روش تعیین می کند که آیا هر یک از کلیدهای داده شده در مجموعه وجود دارد یا خیر:

$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
 
$collection->hasAny(['product', 'price']);
 
// true
 
$collection->hasAny(['name', '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'

implode اگر بخواهید مقادیر در حال انقباض را قالب بندی کنید، می توانید یک بسته را برای متد ارسال کنید :

$collection->implode(function (array $item, int $key) {
    return strtoupper($item['product']);
}, ', ');
 
// DESK, CHAIR

intersect()

این intersect روش هر مقداری را از مجموعه اصلی که در مجموعه داده شده array یا مجموعه وجود ندارد حذف می کند. مجموعه به دست آمده کلیدهای مجموعه اصلی را حفظ می کند:

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

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

intersectAssoc()

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

$collection = collect([
    'color' => 'red',
    'size' => 'M',
    'material' => 'cotton'
]);
 
$intersect = $collection->intersectAssoc([
    'color' => 'blue',
    'size' => 'M',
    'material' => 'polyester'
]);
 
$intersect->all();
 
// ['size' => 'M']

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 (array $item, int $key) {
    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 (int $value, int $key) {
    return $value < 3;
});
 
// 2

همچنین می توانید last متد را بدون آرگومان فراخوانی کنید تا آخرین عنصر مجموعه را بدست آورید. اگر مجموعه خالی باشد، null برگردانده می شود:

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

lazy()

این lazy روش یک نمونه جدید LazyCollection از آرایه زیرین آیتم ها را برمی گرداند:

$lazyCollection = collect([1, 2, 3, 4])->lazy();
 
$lazyCollection::class;
 
// Illuminate\Support\LazyCollection
 
$lazyCollection->all();
 
// [1, 2, 3, 4]

این به ویژه هنگامی مفید است که شما نیاز به انجام تغییرات در یک بزرگ Collection که شامل موارد زیادی است، می باشد:

$count = $hugeCollection
    ->lazy()
    ->where('country', 'FR')
    ->where('balance', '>', '100')
    ->count();

با تبدیل مجموعه به a LazyCollection ، از تخصیص یک تن حافظه اضافی اجتناب می کنیم. اگرچه مجموعه اصلی هنوز مقادیر خود را در حافظه نگه می دارد، فیلترهای بعدی این کار را نمی کنند. بنابراین، عملاً هیچ حافظه اضافی در هنگام فیلتر کردن نتایج مجموعه اختصاص نخواهد یافت.

macro()

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

make()

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

map()

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

$collection = collect([1, 2, 3, 4, 5]);
 
$multiplied = $collection->map(function (int $item, int $key) {
    return $item * 2;
});
 
$multiplied->all();
 
// [2, 4, 6, 8, 10]

مانند بسیاری از روش های جمع آوری دیگر، map یک نمونه مجموعه جدید را برمی گرداند. مجموعه ای را که فراخوانی می شود تغییر نمی دهد. اگر می خواهید مجموعه اصلی را تغییر دهید، از transform روش استفاده کنید.

mapInto()

متد mapInto() روی مجموعه تکرار می شود و با ارسال مقدار به سازنده یک نمونه جدید از کلاس داده شده ایجاد می کند:

class Currency
{
    /**
     * Create a new currency instance.
     */
    function __construct(
        public string $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 (int $even, int $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 (array $item, int $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()

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

$collection = collect([
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => 'john@example.com',
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => 'jane@example.com',
    ]
]);
 
$keyed = $collection->mapWithKeys(function (array $item, int $key) {
    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]