Усе про Laravel - в одному місці

$orders = collect([
  ['status' => 'pending'],
  ['status' => 'completed'],
  ['status' => 'pending'],
  ['status' => 'cancelled'],
  ['status' => 'completed'],
  ['status' => 'completed'],
]);

$counts = $orders->countBy('status');
// ['pending' => 2, 'completed' => 3, 'cancelled' => 1]

// Callback
$users = User::all();

$byAge = $users->countBy(fn($u) => floor($u->age / 10) * 10);
// [20 => X, 30 => Y, 40 => Z]

// Email-домени
$emails = collect([
  'john@gmail.com',
  'jane@yahoo.com',
  'bob@gmail.com',
  'alice@gmail.com',
]);

$domains = $emails->countBy(
  fn($e) => explode('@', $e)[1]
);
// ['gmail.com' => 3, 'yahoo.com' => 1]

// Розподіл за довжиною рядка
$words = collect(['hello', 'world', 'php', 'laravel', 'code']);

$lengths = $words->countBy(fn($word) => strlen($word));

// Статистика для dashboard
public function stats()
{
  $orders = Order::whereDate('created_at', today())->get();

  return [
    'by_status' => $orders->countBy('status'),
    'by_payment' => $orders->countBy('payment_method'),
    'by_hour' => $orders->countBy(
      fn($o) => $o->created_at->hour
    ),
  ];
}

// Масив → колекція
$data = collect([1, 2, 3, 4, 5]);

$result = $data->filter(fn($n) => $n > 2)
  ->map(fn($n) => $n * 2)
  ->sum();

// Обробка request-даних
public function store(Request $request)
{
  $tags = collect($request->tags)
    ->filter()
    ->unique()
    ->values()
    ->toArray();

  Post::create([
    'title' => $request->title,
    'tags' => $tags,
  ]);
}

// Конфігураційні масиви
$activeModules = collect(config('modules'))
  ->filter(fn($module) => $module['enabled'])
  ->pluck('name')
  ->toArray();

// API-відповідь
$apiData = Http::get('api/users')->json();

$users = collect($apiData['users'])
  ->map(fn($user) => [
    'id' => $user['id'],
    'name' => $user['first_name'] . ' ' . $user['last_name'],
    'email' => $user['email'],
  ])
  ->filter(fn($user) => $user['email'])
  ->values();

// Робота з файлами
$lines = collect(file('data.txt'))
  ->map(fn($line) => trim($line))
  ->filter()
  ->unique();

// combine() - ключі + значення
$headers = collect(['name', 'email', 'age']);
$row = ['John', 'john@ex.com', 30];

$user = $headers->combine($row);
// ['name' => 'John', 'email' => 'john@ex.com', 'age' => 30]

// zip() - попарне склеювання
$names = collect(['John', 'Jane']);
$ages = [30, 25];

$pairs = $names->zip($ages);
// [['John', 30], ['Jane', 25]]

// zip() з нерівною довжиною - null у хвості
collect([1, 2, 3])->zip([10, 20]);
// [[1, 10], [2, 20], [3, null]]

// Кілька колекцій одночасно
$names->zip($ages, $emails);
// [['John', 30, 'john@ex.com'], ...]

// Парсинг CSV одним ланцюжком
$lines = collect(file('users.csv'));
$headers = str_getcsv($lines->shift());

$users = $lines->map(fn ($line) =>
  collect($headers)->combine(str_getcsv($line))
);
// $users[0]['email'] - асоціативний доступ

// Зіставлення двох запитів у мапу
$map = Order::pluck('id')
  ->combine(Order::pluck('total'));
// [1 => 250.00, 2 => 130.50]

$items = collect(range(1, 100));

// Пропустити 20, взяти 10
$page = $items->skip(20)->take(10);
// [21, 22, ..., 30]

// Пагінація вручну
$perPage = 10;
$page = 3;

$results = $items->skip(($page - 1) * $perPage)
  ->take($perPage);

// Коротко: forPage()
$results = $items->forPage(3, 10);

// Умовні варіанти замість числа
$items->skipUntil(fn($i) => $i > 50);
$items->skipWhile(fn($i) => $i < 20);
$items->takeUntil(fn($i) => $i > 50);
$items->takeWhile(fn($i) => $i < 20);

// API-пагінація на закешованих даних
public function index(Request $request)
{
  $all = Cache::remember(
    'products', 3600, fn () => Product::all()
  );

  $page = (int) $request->query('page', 1);
  $perPage = (int) $request->query('per_page', 15);

  return response()->json([
    'data' => $all->forPage($page, $perPage)->values(),
    'current_page' => $page,
    'per_page' => $perPage,
    'total' => $all->count(),
  ]);
}

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

// Розмір 3, крок 1
$windows = $numbers->sliding(3);
// [[1,2,3], [2,3,4], [3,4,5], [4,5,6]]

// Розмір 3, крок 2
$windows = $numbers->sliding(3, 2);
// [[1,2,3], [3,4,5]]

// Ковзне середнє
$values = collect([10, 20, 30, 40, 50]);

$movingAvg = $values->sliding(3)
  ->map(fn($window) => $window->avg());
// [20, 30, 40]

// Аналіз трендів
$prices = collect([100, 105, 103, 110, 115, 112]);

$trends = $prices->sliding(3)
  ->map(fn($w) => [
    'start' => $w->first(),
    'end' => $w->last(),
    'trend' => $w->last() > $w->first() ? 'up' : 'down',
  ]);

// Порівняння сусідніх значень
$changes = $logs->sliding(2)->map(fn($pair) =>
  $pair->last()->value - $pair->first()->value
);

// Пошук послідовностей
$data = collect([1, 2, 3, 5, 6, 7]);

$seq = $data->sliding(2)
  ->filter(fn($p) => $p->last() - $p->first() === 1);

// Масив масивів
$data = collect([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
]);

$flat = $data->collapse();
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

// Колекції у колекції
$tags = collect([
  collect(['php', 'laravel']),
  collect(['javascript', 'vue']),
  collect(['mysql', 'redis']),
]);

$allTags = $tags->collapse();
// ['php', 'laravel', 'javascript', 'vue', 'mysql', 'redis']

// Приклад: об'єднання дозволів користувача з ролей
$user->roles->map(fn($role) => $role->permissions)->collapse();

// Групування, а потім collapse
$orders = Order::all()
  ->groupBy('user_id')
  ->map(fn($userOrders) => $userOrders->pluck('items'))
  ->collapse();

// Відмінність collapse vs flatten
$nested = collect([
  [1, [2, [3, 4]]],
  [5, [6, [7, 8]]],
]);

$nested->collapse(); // [1, [2, [3, 4]], 5, [6, [7, 8]]]
$nested->flatten();  // [1, 2, 3, 4, 5, 6, 7, 8]

// Об'єднання масивів із кількох моделей
$allEmails = collect([$users, $admins, $moderators])
  ->map(fn($group) => $group->pluck('email'))
  ->collapse()
  ->unique();

// Теги з постів
$uniqueTags = Post::with('tags')->get()
  ->map(fn($p) => $p->tags)
  ->collapse()
  ->unique('id');

// Комбінування результатів пошуку
$results = collect([$localResults, $apiResults])
  ->collapse()
  ->sortByDesc('relevance');