Питання на співбесіду PHP Laravel Developer 2026: Повний посібник з підготовки

// Проблема N+1: 1 запит для постів + N запитів для авторів
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Викликає запит для кожного поста
}

// Рішення: Eager loading з with()
$posts = Post::with('author')->get(); // Всього 2 запити
foreach ($posts as $post) {
    echo $post->author->name; // Жодних додаткових запитів
}

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Soft-deleted записи виключаються за замовчуванням
    // Щоб включити їх:
    // Post::withTrashed()->get();
    // Щоб отримати лише видалені:
    // Post::onlyTrashed()->get();
}

public function register(): void
{
    // Простий binding
    $this->app->bind(PaymentGateway::class, StripeGateway::class);
    
    // Singleton - той самий екземпляр кожного разу
    $this->app->singleton(CacheManager::class, function ($app) {
        return new CacheManager($app['config']['cache']);
    });
    
    // Контекстний binding
    $this->app->when(PhotoController::class)
              ->needs(Filesystem::class)
              ->give(function () {
                  return Storage::disk('photos');
              });
}

class PostPolicy
{
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id 
            || $user->hasRole('editor');
    }
    
    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id 
            || $user->hasRole('admin');
    }
}

// Використання в контролері
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post);
    // Продовжуємо оновлення...
}

Gate::define('access-admin', function (User $user) {
    return $user->is_admin || $user->hasRole('super-admin');
});

// Використання
if (Gate::allows('access-admin')) {
    // Показати адмін панель
}

class ProcessPodcast implements ShouldQueue
{
    use Queueable;
    
    public int $tries = 3;
    public int $backoff = 60; // секунди між спробами
    public int $timeout = 300; // максимальний час виконання
    
    public function __construct(
        public Podcast $podcast
    ) {}
    
    public function handle(AudioProcessor $processor): void
    {
        $processor->process($this->podcast->audio_path);
    }
    
    public function failed(Throwable $exception): void
    {
        // Повідомити адміністратора про невдачу
        Log::error('Обробка подкасту невдала', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage()
        ]);
    }
}

// Відправка завдання
ProcessPodcast::dispatch($podcast)->onQueue('audio');

// Job batching
Bus::batch([
    new ProcessPodcast($podcast1),
    new ProcessPodcast($podcast2),
    new ProcessPodcast($podcast3),
])->then(function (Batch $batch) {
    // Всі завдання успішно завершені
})->catch(function (Batch $batch, Throwable $e) {
    // Обробка першої невдачі
})->finally(function (Batch $batch) {
    // Batch завершено (успішно або з помилкою)
})->dispatch();

// Job chaining
Bus::chain([
    new DownloadPodcast($url),
    new ProcessAudio($podcast),
    new PublishPodcast($podcast),
])->dispatch();

class PricingServiceTest extends TestCase
{
    public function test_calculates_discount_correctly(): void
    {
        $service = new PricingService();
        
        $result = $service->calculateDiscount(100, 0.2);
        
        $this->assertEquals(80, $result);
    }
}

// tests/Feature/Http/Controllers/PostControllerTest.php
class PostControllerTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_user_can_create_post(): void
    {
        $user = User::factory()->create();
        
        $response = $this->actingAs($user)
            ->post('/posts', [
                'title' => 'Мій пост',
                'content' => 'Вміст посту'
            ]);
        
        $response->assertRedirect('/posts');
        $this->assertDatabaseHas('posts', [
            'title' => 'Мій пост',
            'user_id' => $user->id
        ]);
    }
}

use Illuminate\Support\Facades\Queue;

public function test_podcast_processing_job_is_dispatched(): void
{
    Queue::fake();
    
    $podcast = Podcast::factory()->create();
    
    // Дія, що викликає завдання
    $this->post("/podcasts/{$podcast->id}/process");
    
    // Assertions
    Queue::assertPushed(ProcessPodcast::class, function ($job) use ($podcast) {
        return $job->podcast->id === $podcast->id;
    });
    
    Queue::assertPushedOn('audio', ProcessPodcast::class);
}

interface PostRepositoryInterface
{
    public function findPublished(): Collection;
    public function findByAuthor(User $author): Collection;
}

class EloquentPostRepository implements PostRepositoryInterface
{
    public function findPublished(): Collection
    {
        return Post::where('status', 'published')
            ->with('author')
            ->orderByDesc('published_at')
            ->get();
    }
    
    public function findByAuthor(User $author): Collection
    {
        return Post::where('user_id', $author->id)
            ->with('tags')
            ->get();
    }
}

class CreateOrder
{
    public function __construct(
        private PaymentGateway $gateway,
        private OrderRepository $orders
    ) {}
    
    public function execute(User $user, Cart $cart): Order
    {
        $payment = $this->gateway->charge(
            $user,
            $cart->total()
        );
        
        $order = $this->orders->create([
            'user_id' => $user->id,
            'payment_id' => $payment->id,
            'items' => $cart->items(),
            'total' => $cart->total()
        ]);
        
        OrderCreated::dispatch($order);
        
        return $order;
    }
}

// Використання в контролері
public function store(Request $request, CreateOrder $action)
{
    $order = $action->execute(
        $request->user(),
        Cart::current()
    );
    
    return redirect()->route('orders.show', $order);
}

// Інтеграція AI SDK
use Illuminate\AI\Facades\AI;

$response = AI::chat()
    ->model('gpt-4')
    ->system('Ви корисний асистент.')
    ->user('Поясніть Service Container в Laravel.')
    ->generate();

// PHP Attributes для маршрутів
#[Route('/posts', methods: ['GET'])]
#[Middleware('auth')]
public function index(): View
{
    return view('posts.index');
}

// Валідація з Attributes
#[Required]
#[Email]
#[Unique('users', 'email')]
public string $email;