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

$result = $users
  ->where('active', true)
  ->tap(fn($c) => logger("Active: {$c->count()}"))
  ->where('role', 'admin')
  ->tap(fn($c) => logger("Admins: {$c->count()}"))
  ->get();

// Порівняння
$collection->pipe(fn($c) => $c->count()); // повертає число
$collection->tap(fn($c) => $c->count()); // повертає колекцію

$result = $users
  ->where('active', true)
  ->pipe(fn($c) => $c->sortBy('last_login')->take(10))
  ->values();

// Умовне сортування
$posts = Post::all()->pipe(function ($posts) use ($request) {
  return $request->sort === 'popular'
    ? $posts->sortByDesc('views')
    : $posts->sortByDesc('created_at');
});

// Дебаг
$result = $users
  ->where('active', true)
  ->pipe(fn($c) => tap($c, fn($c) => logger($c->count())))
  ->where('role', 'admin');

[$active, $inactive] = $users->partition(fn($u) => $u->active);

// Дві різні обробки
$active->each(fn($u) => ...);
$inactive->each(fn($u) => ...);

// Валідація
[$valid, $invalid] = $orders->partition(fn($o) =>
  $o->total > 0 && $o->email !== null
);

// Студенти
[$passed, $failed] = $students->partition(
  fn($s) => $s->score >= 60
);

// Групування за категорією
$byCategory = $posts->groupBy('category_id');

// Групування за роком
$byYear = $posts->groupBy(fn($p) => $p->created_at->year);

// Доступ до груп
foreach ($byCategory as $categoryId => $posts) {
  echo "Category {$categoryId}: {$posts->count()} posts\n";
}

// Кілька рівнів
$byYearMonth = $posts->groupBy([
  fn($p) => $p->created_at->year,
  fn($p) => $p->created_at->month,
]);

// Групування по зв'язку
$byPostTitle = $comments->groupBy('post.title');

// Практичний приклад - суми продажів
$report = $orders->groupBy('status')
  ->map(fn($group) => $group->sum('total'));

// filter() - тільки активні
$active = $users->filter(fn($u) => $u->active === true);

// reject() - видалити неактивних
$active = $users->reject(fn($u) => $u->active === false);

// filter() без callback
$values = collect([1, 2, null, 3, false, '', 4]);
$cleaned = $values->filter();
// [1, 2, 3, 4]

// where()
$admins = $users->where('role', 'admin');
$verified = $users->where('email_verified_at', '!=', null);

// whereIn()
$staff = $users->whereIn('role', ['admin', 'moderator']);

// whereBetween()
$recent = $posts->whereBetween('created_at', [
  now()->subDays(7),
  now()
]);

// Комбінування фільтрів
$result = $users
  ->where('active', true)
  ->whereIn('role', ['admin', 'editor'])
  ->filter(fn($u) => $u->posts_count > 10);

// Поділ на частини по 100
$users = User::all();
$users->chunk(100)->each(function ($batch) {
  $this->sendBatchEmail($batch);
});

// API rate limit
$products = collect($apiProducts);
$products->chunk(50)->each(function ($batch) {
  $this->syncToDatabase($batch);
  sleep(1);
});

// Прогрес
$done = 0;

$users->chunk(100)->each(function ($batch) use (&$done) {
  $batch->each(fn($u) => $this->process($u));
  $done += $batch->count();
  echo "Progress: {$done}\n";
});

// Комбінування з іншими методами
$users->chunk(100)->map(function ($chunk) {
  return $chunk->pluck('email');
});

// map() - створює нову колекцію
$users = User::all();
$names = $users->map(function ($user) {
  return strtoupper($user->name);
});

// transform() - змінює оригінал
$users = User::all();
$users->transform(function ($user) {
  $user->name = strtoupper($user->name);
  return $user;
});

// map() з короткими функціями
$prices = collect([100, 200, 300]);
$withTax = $prices->map(fn($p) => $p * 1.2);

// Повна зміна структури
$formatted = $users->map(fn($user) => [
  'id' => $user->id,
  'label' => "{$user->name} ({$user->email})"
]);

// mapWithKeys - власні ключі
$users->mapWithKeys(fn($user) =>
  [$user->email => $user->name]
);

// Погано: цикл і ручне збирання
$ids = [];
foreach ($users as $user) {
  $ids[] = $user->id;
}

// Добре: один рядок
$ids = $users->pluck('id');
// [1, 2, 3, 4, 5]

// Із ключем
$userNames = $users->pluck('name', 'id');
// [1 => 'John', 2 => 'Jane', 3 => 'Bob']

// Безпосередньо з бази - ефективніше
$emails = User::pluck('email');
$emailsById = User::pluck('email', 'id');

// Dot notation
$posts = Post::with('author')->get();
$authorNames = $posts->pluck('author.name');

// Кілька рівнів
$comments = Comment::with('post.author')->get();
$authors = $comments->pluck('post.author.name');

// Для select
$countries = Country::pluck('name', 'code');
// ['US' => 'United States', 'GB' => 'United Kingdom']

// ПОГАНО
$orders = Order::where('total', '>=', 100)
  ->where('total', '<=', 500)
  ->get();

// ДОБРЕ
$orders = Order::whereBetween('total', [100, 500])->get();

// Діапазон дат
$orders = Order::whereBetween('created_at', [
  now()->subDays(30),
  now()
])->get();

// Вік
$users = User::whereBetween('age', [18, 65])->get();

// Виключити діапазон
$products = Product::whereNotBetween('price', [100, 200])->get();