PHP Laravel Developer Mülakat Soruları 2026: Kapsamlı Hazırlık Rehberi

// N+1 problemi: postlar için 1 sorgu + yazarlar için N sorgu
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Her post için bir sorgu tetikler
}

// Çözüm: with() ile Eager loading
$posts = Post::with('author')->get(); // Toplam 2 sorgu
foreach ($posts as $post) {
    echo $post->author->name; // Ek sorgu yok
}

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Soft-deleted kayıtlar varsayılan olarak hariç tutulur
    // Dahil etmek için:
    // Post::withTrashed()->get();
    // Yalnızca silinen kayıtları almak için:
    // Post::onlyTrashed()->get();
}

public function register(): void
{
    // Basit binding
    $this->app->bind(PaymentGateway::class, StripeGateway::class);
    
    // Singleton - her seferinde aynı örnek
    $this->app->singleton(CacheManager::class, function ($app) {
        return new CacheManager($app['config']['cache']);
    });
    
    // Bağlamsal 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');
    }
}

// Controller'da kullanım
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post);
    // Güncelleme işlemine devam et...
}

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

// Kullanım
if (Gate::allows('access-admin')) {
    // Yönetici panelini göster
}

class ProcessPodcast implements ShouldQueue
{
    use Queueable;
    
    public int $tries = 3;
    public int $backoff = 60; // denemeler arası saniye
    public int $timeout = 300; // maksimum çalışma süresi
    
    public function __construct(
        public Podcast $podcast
    ) {}
    
    public function handle(AudioProcessor $processor): void
    {
        $processor->process($this->podcast->audio_path);
    }
    
    public function failed(Throwable $exception): void
    {
        // Başarısızlık durumunda yöneticiyi bilgilendir
        Log::error('Podcast işleme başarısız', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage()
        ]);
    }
}

// İşi gönderme
ProcessPodcast::dispatch($podcast)->onQueue('audio');

// Job batching
Bus::batch([
    new ProcessPodcast($podcast1),
    new ProcessPodcast($podcast2),
    new ProcessPodcast($podcast3),
])->then(function (Batch $batch) {
    // Tüm işler başarıyla tamamlandı
})->catch(function (Batch $batch, Throwable $e) {
    // İlk başarısızlığı yönet
})->finally(function (Batch $batch) {
    // Batch tamamlandı (başarılı veya başarısız)
})->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' => 'Benim yazım',
                'content' => 'Yazı içeriği'
            ]);
        
        $response->assertRedirect('/posts');
        $this->assertDatabaseHas('posts', [
            'title' => 'Benim yazım',
            'user_id' => $user->id
        ]);
    }
}

use Illuminate\Support\Facades\Queue;

public function test_podcast_processing_job_is_dispatched(): void
{
    Queue::fake();
    
    $podcast = Podcast::factory()->create();
    
    // İşi tetikleyen eylem
    $this->post("/podcasts/{$podcast->id}/process");
    
    // Doğrulamalar
    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;
    }
}

// Controller'da kullanım
public function store(Request $request, CreateOrder $action)
{
    $order = $action->execute(
        $request->user(),
        Cart::current()
    );
    
    return redirect()->route('orders.show', $order);
}

// AI SDK entegrasyonu
use Illuminate\AI\Facades\AI;

$response = AI::chat()
    ->model('gpt-4')
    ->system('Yardımcı bir asistansınız.')
    ->user('Laravel Service Container nedir açıklayın.')
    ->generate();

// Rotalar için PHP Attributes
#[Route('/posts', methods: ['GET'])]
#[Middleware('auth')]
public function index(): View
{
    return view('posts.index');
}

// Attributes ile doğrulama
#[Required]
#[Email]
#[Unique('users', 'email')]
public string $email;