# Questions d'entretien PHP Laravel 2026 : Guide complet de préparation

> Les questions d'entretien pour développeur PHP Laravel évaluent à la fois la maîtrise du framework et les principes de conception logicielle. Avec Laravel 13 sorti en mars 2026, les recruteurs attendent des candidats une connaissance des fonctionnalités actuelles et des fondamentaux.

- Published: 2026-09-07
- Updated: 2026-09-07
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

Les questions d'entretien pour développeur PHP Laravel évaluent à la fois la maîtrise du framework et les principes de conception logicielle. Avec Laravel 13 sorti en mars 2026 intégrant le SDK IA, les PHP Attributes et l'authentification Passkey, les recruteurs attendent des candidats une connaissance des fonctionnalités actuelles en plus des fondamentaux du framework.

> **Domaines clés en entretien**
>
> Les entretiens Laravel couvrent généralement cinq piliers : les relations Eloquent ORM et la performance, le Service Container et l'injection de dépendances, les patterns d'authentification et d'autorisation, la gestion des queues et jobs, ainsi que les stratégies de test. Les postes seniors ajoutent les décisions d'architecture et la connaissance de l'écosystème de packages.

## Eloquent ORM et questions sur les bases de données

Eloquent reste le sujet le plus abordé en entretien Laravel. Les recruteurs évaluent si les candidats comprennent le lazy loading vs eager loading, les types de relations et l'optimisation des requêtes.

**Q : Qu'est-ce que le problème N+1 et comment Laravel le résout-il ?**

Le problème N+1 survient lorsque le code exécute une requête pour récupérer une collection, puis N requêtes supplémentaires pour charger les données associées de chaque élément. Laravel fournit l'eager loading via `with()` pour résoudre ce problème.

```php
// app/Http/Controllers/PostController.php
// Problème N+1 : 1 requête pour les posts + N requêtes pour les auteurs
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Déclenche une requête par post
}

// Solution : Eager load avec with()
$posts = Post::with('author')->get(); // 2 requêtes au total
foreach ($posts as $post) {
    echo $post->author->name; // Aucune requête supplémentaire
}
```

Laravel 13 maintient le mode strict en développement, qui lève une exception lors du lazy loading, aidant à détecter les problèmes N+1 rapidement.

**Q : Expliquez la différence entre `hasOne`, `hasMany`, `belongsTo` et `belongsToMany`.**

| Relation | Emplacement de la clé étrangère | Exemple |
|----------|--------------------------------|----------|
| hasOne | Sur le modèle associé | User hasOne Profile (profiles.user_id) |
| hasMany | Sur le modèle associé | User hasMany Posts (posts.user_id) |
| belongsTo | Sur le modèle courant | Post belongsTo User (posts.user_id) |
| belongsToMany | Table pivot | User belongsToMany Roles (table role_user) |

**Q : Comment gérer les soft deletes et quelles sont les implications ?**

```php
// app/Models/Post.php
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Les enregistrements soft-deleted sont exclus par défaut
    // Pour les inclure :
    // Post::withTrashed()->get();
    // Pour n'obtenir que les supprimés :
    // Post::onlyTrashed()->get();
}
```

Les soft deletes ajoutent une colonne `deleted_at`. Les requêtes excluent automatiquement les enregistrements soft-deleted sauf demande explicite. Cela affecte les contraintes d'unicité et nécessite des index composés incluant `deleted_at` pour des performances optimales.

## Service Container et injection de dépendances

Le [Service Container](https://laravel.com/docs/13.x/container) est le cœur de Laravel. Comprendre le binding, la résolution et l'injection contextuelle distingue les candidats juniors des seniors.

**Q : Qu'est-ce que le Service Container et pourquoi est-il important ?**

Le Service Container gère les dépendances des classes et effectue l'injection de dépendances. Il résout automatiquement les classes, permettant un couplage faible et une meilleure testabilité.

```php
// app/Providers/AppServiceProvider.php
public function register(): void
{
    // Binding d'interface
    $this->app->bind(
        PaymentGatewayInterface::class,
        StripePaymentGateway::class
    );
    
    // Singleton : même instance à chaque fois
    $this->app->singleton(ReportGenerator::class, function ($app) {
        return new ReportGenerator($app->make(Cache::class));
    });
}
```

**Q : Quelle est la différence entre `bind()`, `singleton()` et `instance()` ?**

- `bind()` : Crée une nouvelle instance à chaque résolution de la classe
- `singleton()` : Crée une instance et retourne la même instance lors des résolutions suivantes
- `instance()` : Lie une instance d'objet existante au container

```php
// app/Providers/AppServiceProvider.php
// bind : nouvelle instance à chaque fois
$this->app->bind(Service::class, fn() => new Service());

// singleton : une instance pour tout le cycle de vie de la requête
$this->app->singleton(Cache::class, fn() => new RedisCache());

// instance : lier un objet déjà instancié
$config = new Config(['debug' => true]);
$this->app->instance(Config::class, $config);
```

Pour s'entraîner sur les concepts du Service Container, consultez le [module Service Container & DI](/technologies/laravel/interview-questions/service-container-di).

## Patterns d'authentification et d'autorisation

Laravel 13 a introduit l'authentification Passkey aux côtés des méthodes existantes. Les recruteurs attendent une connaissance de Sanctum, Passport, des policies et des gates.

**Q : Quand utiliser Sanctum vs Passport ?**

| Fonctionnalité | Sanctum | Passport |
|----------------|---------|----------|
| Cas d'usage | SPA, apps mobiles, tokens API simples | Serveur OAuth2, accès tiers |
| Type de token | Tokens API simples, basé sur session | Tokens d'accès OAuth2, refresh tokens |
| Complexité | Configuration minimale | Implémentation OAuth2 complète |
| Scopes de token | Abilities (plus simple) | Scopes OAuth |

Sanctum convient à la plupart des applications. Passport est nécessaire lorsque l'application doit agir comme fournisseur OAuth2 pour des clients tiers. Voir la comparaison détaillée dans [Laravel Sanctum vs Passport](/blog/laravel/laravel-sanctum-vs-passport-api-authentication).

**Q : En quoi les policies diffèrent-elles des gates ?**

Les gates sont des vérifications d'autorisation basées sur des closures. Les policies sont des classes qui regroupent la logique d'autorisation pour un modèle spécifique.

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

// Utilisation dans le contrôleur
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post); // Utilise PostPolicy
    // ... logique de mise à jour
}
```

Le [module Autorisation & Policies](/technologies/laravel/interview-questions/authorization-policies) couvre les patterns d'autorisation avancés.

## Queues et traitement des jobs

Les queues sont essentielles pour les applications Laravel évolutives. Les recruteurs sondent la compréhension de la conception des jobs, la gestion des échecs et les drivers de queue.

**Q : Comment gérer les jobs en échec dans Laravel ?**

```php
// app/Jobs/ProcessPodcast.php
class ProcessPodcast implements ShouldQueue
{
    use Queueable;
    
    public int $tries = 3;
    public int $backoff = 60; // secondes entre les tentatives
    public int $timeout = 120;
    
    public function handle(): void
    {
        // Logique du job
    }
    
    public function failed(Throwable $exception): void
    {
        // Notifier l'admin, logger vers un service externe
        Log::error('Échec du traitement podcast', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage()
        ]);
    }
}
```

Les jobs en échec sont stockés dans la table `failed_jobs`. Utilisez `php artisan queue:retry` pour réessayer des jobs spécifiques ou `queue:retry all` pour une relance en lot.

**Q : Quelle est la différence entre `dispatch()` et `dispatchSync()` ?**

- `dispatch()` : Pousse le job dans la queue pour un traitement asynchrone
- `dispatchSync()` : Exécute le job immédiatement dans le processus courant, contournant la queue

`dispatchSync()` est utile pour les tests ou lorsque le résultat est nécessaire immédiatement. En production, la plupart des jobs devraient utiliser `dispatch()` pour éviter de bloquer la requête.

## Tests Laravel avec Pest

Laravel 13 intègre [Pest](https://pestphp.com/) comme framework de test par défaut. Les recruteurs évaluent la compréhension des tests de fonctionnalité, tests unitaires, mocking et stratégies de test de base de données.

**Q : Comment tester un contrôleur qui dépend d'une API externe ?**

```php
// tests/Feature/PaymentTest.php
use App\Services\PaymentGateway;
use App\Services\FakePaymentGateway;

test('le paiement est traité avec succès', function () {
    // Lier une fausse implémentation pour les tests
    $this->app->bind(
        PaymentGateway::class,
        FakePaymentGateway::class
    );
    
    $response = $this->postJson('/api/payments', [
        'amount' => 1000,
        'currency' => 'usd'
    ]);
    
    $response->assertStatus(200)
        ->assertJson(['status' => 'completed']);
});

test('le paiement gère les erreurs de passerelle', function () {
    $mock = Mockery::mock(PaymentGateway::class);
    $mock->shouldReceive('charge')
        ->once()
        ->andThrow(new PaymentFailedException('Carte refusée'));
    
    $this->app->instance(PaymentGateway::class, $mock);
    
    $response = $this->postJson('/api/payments', [
        'amount' => 1000,
        'currency' => 'usd'
    ]);
    
    $response->assertStatus(422);
});
```

**Q : Quelle est la différence entre `RefreshDatabase` et `DatabaseTransactions` ?**

- `RefreshDatabase` : Migre la base de données une fois par classe de test, encapsule chaque test dans une transaction
- `DatabaseTransactions` : Suppose que la base de données est déjà migrée, encapsule chaque test dans une transaction

`RefreshDatabase` est plus sûr pour les pipelines CI/CD. `DatabaseTransactions` est plus rapide pour le développement local lorsque le schéma est stable.

Pour les bonnes pratiques de test, consultez [Tests Laravel avec Pest](/blog/laravel/laravel-testing-pest-mocking-best-practices).

## Questions spécifiques à Laravel 13

Les recruteurs posent de plus en plus de questions sur les fonctionnalités de Laravel 13 annoncées lors de [Laracon EU 2026](https://laraveldaily.com/post/laravel-13-laracon-eu-taylor-otwell).

**Q : Qu'est-ce que le SDK IA Laravel et quand l'utiliser ?**

Le [SDK IA Laravel](https://laravel.com/docs/13.x/ai) fournit une API unifiée pour les opérations IA : génération de texte, embeddings, agents avec appel d'outils, audio et génération d'images. Il abstrait les différences entre fournisseurs comme OpenAI, Anthropic et autres.

```php
// config/ai.php définit le fournisseur par défaut
// Utilisation dans le code applicatif
use Illuminate\Support\Facades\AI;

$response = AI::text('Résume cet article pour un public de développeurs')
    ->withContext($articleContent)
    ->generate();

// Embeddings pour la recherche sémantique
$embedding = AI::embeddings($searchQuery)->generate();
$results = Post::query()
    ->nearestNeighbors('embedding', $embedding, 10)
    ->get();
```

Le SDK est approprié pour les applications nécessitant des fonctionnalités IA sans gérer plusieurs SDKs de fournisseurs.

**Q : Comment fonctionnent les PHP Attributes dans Laravel 13 ?**

Laravel 13 a introduit les PHP 8 Attributes comme alternative aux propriétés de classe pour la configuration des composants. C'est non-breaking : la configuration basée sur les propriétés continue de fonctionner.

```php
// Approche traditionnelle
class SendWelcomeEmail implements ShouldQueue
{
    public $queue = 'emails';
    public $tries = 3;
}

// Laravel 13 avec Attributes
use Illuminate\Contracts\Queue\Attributes\Queue;
use Illuminate\Contracts\Queue\Attributes\Tries;

#[Queue('emails')]
#[Tries(3)]
class SendWelcomeEmail implements ShouldQueue
{
    // Corps de classe plus propre
}
```

Les Attributes offrent un meilleur support IDE et gardent la configuration visible au niveau de la définition de la classe.

## Points clés pour les entretiens Laravel en 2026

- Maîtriser l'eager loading Eloquent avec `with()` et comprendre le mode strict qui détecte les requêtes N+1 en développement
- Expliquer les bindings du Service Container : `bind()` pour transitoire, `singleton()` pour instances partagées, binding contextuel pour la résolution d'interfaces
- Savoir quand utiliser Sanctum vs Passport : Sanctum pour les apps first-party, Passport pour les scénarios de fournisseur OAuth2
- Démontrer la gestion des échecs de queue avec `$tries`, `$backoff` et la méthode `failed()`
- Écrire des tests avec Pest, utiliser des mocks pour les dépendances externes et comprendre la différence entre `RefreshDatabase` et `DatabaseTransactions`
- Être familier avec les fonctionnalités de Laravel 13 : SDK IA pour les opérations IA unifiées, PHP Attributes pour une configuration de composants plus propre, et authentification Passkey
- S'entraîner à expliquer les compromis, pas seulement les implémentations : les recruteurs valorisent le raisonnement plutôt que la mémorisation

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/fr/blog/laravel/php-laravel-developer-interview-questions-2026