Laravel pour un développeur Symfony

// 1. Façade — pratique, testable via Cache::fake()
use Illuminate\Support\Facades\Cache;
Cache::put('stats', $data, 3600);

// 2. Helper — la même chose en fonction globale
cache()->put('stats', $data, 3600);

// 3. Injection — identique à Symfony, préférable dans un service métier
use Illuminate\Contracts\Cache\Repository as CacheContract;

public function __construct(private readonly CacheContract $cache) {}

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        $middleware->alias([
            'admin' => \App\Http\Middleware\EnsureUserIsAdmin::class,
        ]);
        $middleware->web(append: [TrackVisits::class]);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        $exceptions->render(function (NotFoundHttpException $e) {
            return response()->view('errors.404', status: 404);
        });
    })
    ->create();

php artisan tinker

>>> Article::count()
= 42

>>> Article::where('status', 'published')->latest()->first()
= App\Models\Article {#5234 id: 17, title: "Bonjour", ...}

>>> $a = Article::factory()->create(['title' => 'Test'])
>>> $a->author->email
= "amar@exemple.fr"

>>> Article::with('author')->get()->pluck('author.email')->unique()

// Voir le SQL sans l'exécuter
>>> Article::where('views', '>', 100)->toSql()
= "select * from `articles` where `views` > ?"

Route::resource('articles', ArticleController::class);

// Restreindre
Route::resource('articles', ArticleController::class)->only(['index', 'show']);
Route::resource('articles', ArticleController::class)->except(['destroy']);

// API : pas de create ni edit (ce sont des pages de formulaire)
Route::apiResource('articles', ArticleController::class);

// Imbriquée : /articles/{article}/comments
Route::resource('articles.comments', CommentController::class)->shallow();

// Groupes
Route::middleware(['auth', 'verified'])
    ->prefix('admin')
    ->name('admin.')
    ->group(function () {
        Route::resource('articles', AdminArticleController::class);
    });

// Route::get('/articles/{article}', ...)
public function show(Article $article)   // chargé par id, 404 automatique
{
    return view('articles.show', compact('article'));
}

// Par une autre colonne — deux façons
// 1. dans la route
Route::get('/articles/{article:slug}', [ArticleController::class, 'show']);

// 2. sur le modèle, pour toute l'application
public function getRouteKeyName(): string
{
    return 'slug';
}

// Avec scoping : le commentaire doit appartenir à l'article
Route::get('/articles/{article}/comments/{comment}', ...)->scopeBindings();

route('articles.show', $article);          // ≈ generateUrl()
route('articles.index', ['page' => 2]);
url('/contact');
to_route('articles.index');                // redirection depuis un contrôleur

// Blade
{{ route('articles.show', $article) }}

namespace App\Http\Controllers;

use App\Http\Requests\StoreArticleRequest;
use App\Models\Article;

class ArticleController extends Controller
{
    // L'injection par constructeur fonctionne comme en Symfony
    public function __construct(
        private readonly ArticleService $service,
    ) {}

    public function index()
    {
        $articles = Article::with('author')
            ->latest()
            ->paginate(15);

        return view('articles.index', compact('articles'));
    }

    // StoreArticleRequest valide AVANT d'entrer dans la méthode
    public function store(StoreArticleRequest $request)
    {
        $article = Article::create($request->validated());

        return to_route('articles.show', $article)
            ->with('success', 'Article publié.');
    }

    public function show(Article $article)          // liaison implicite
    {
        return view('articles.show', compact('article'));
    }

    public function destroy(Article $article)
    {
        $this->authorize('delete', $article);       // ≈ denyAccessUnlessGranted
        $article->delete();

        return to_route('articles.index');
    }
}

$request->input('title', 'défaut');    // POST ou GET, indifféremment
$request->query('page');               // GET seulement
$request->only(['title', 'body']);
$request->except(['_token']);
$request->has('tags');                 // le champ existe
$request->filled('search');            // existe ET n'est pas vide
$request->boolean('published');        // "1", "true", "on" → true
$request->date('published_at');        // instance Carbon
$request->integer('page');
$request->enum('status', Status::class);
$request->file('cover')->store('covers', 'public');
$request->user();
$request->ip();
$request->wantsJson();

class PublishArticle extends Controller
{
    public function __invoke(Article $article)
    {
        $article->update(['published_at' => now()]);

        return back()->with('success', 'Article publié.');
    }
}

// routes/web.php
Route::post('/articles/{article}/publish', PublishArticle::class);

@props(['type' => 'info', 'dismissible' => false])

<div {{ $attributes->merge(['class' => 'alert alert-'.$type]) }}>
    @if ($title ?? false)
        <strong>{{ $title }}</strong>
    @endif

    {{ $slot }}

    @if ($dismissible)
        <button type="button" data-dismiss>&times;</button>
    @endif
</div>

<x-alert type="error" dismissible>
    <x-slot:title>Échec de l'enregistrement</x-slot:title>
    Vérifiez les champs en rouge.
</x-alert>

{{-- Attribut dynamique : préfixe : --}}
<x-alert :type="$niveau" :message="$erreur" />

<form method="POST" action="{{ route('articles.update', $article) }}">
    @csrf
    @method('PUT')

    <input name="title" value="{{ old('title', $article->title) }}">
    @error('title')
        <p class="error">{{ $message }}</p>
    @enderror

    <button>Enregistrer</button>
</form>

Article::all();                              // ≈ findAll()
Article::find(1);                            // ≈ find()
Article::findOrFail(1);                      // lève un 404
Article::firstWhere('slug', $slug);          // ≈ findOneBy()
Article::where('status', 'published')->get();
Article::where('views', '>', 100)->orderByDesc('views')->take(5)->get();
Article::whereIn('user_id', [1, 2, 3])->get();
Article::whereBetween('created_at', [$debut, $fin])->get();
Article::whereNull('published_at')->get();
Article::whereRelation('author', 'active', true)->get();

// Pagination — inclut les liens, contrairement à Doctrine
$articles = Article::paginate(15);
$articles = Article::simplePaginate(15);     // sans total, plus rapide

// Agrégats
Article::count();
Article::sum('views');
Article::avg('rating');
Article::exists();
Article::pluck('title', 'id');               // ['1' => 'Bonjour', …]

// Le SQL généré, sans exécuter
Article::where('views', '>', 100)->toSql();

// Création directe — écrit immédiatement
$article = Article::create([
    'title' => 'Bonjour',
    'body'  => '…',
]);

// En deux temps
$article = new Article();
$article->title = 'Bonjour';
$article->save();

// Mise à jour
$article->update(['title' => 'Corrigé']);
$article->title = 'Corrigé';
$article->save();

// Idempotent — très pratique pour les imports
Article::updateOrCreate(
    ['slug' => $slug],                  // critères de recherche
    ['title' => $titre, 'body' => $c],  // valeurs à écrire
);
Article::firstOrCreate(['slug' => $slug]);

// Suppression
$article->delete();
Article::destroy([1, 2, 3]);
$article->restore();                    // avec SoftDeletes
$article->forceDelete();
Article::withTrashed()->get();
Article::onlyTrashed()->get();

use Illuminate\Support\Facades\DB;

DB::transaction(function () use ($data) {
    $order = Order::create($data['order']);
    $order->items()->createMany($data['items']);
    Stock::decrementFor($order);
});

// Contrôle manuel
DB::beginTransaction();
try {
    // …
    DB::commit();
} catch (\Throwable $e) {
    DB::rollBack();
    throw $e;
}

Article::chunk(200, function ($articles) {
    foreach ($articles as $article) { … }
});

// Plus sûr si vous modifiez la colonne de tri pendant le parcours
Article::chunkById(200, fn ($lot) => …);

// Générateur paresseux — syntaxe de collection, mémoire constante
Article::lazy()->each(fn ($a) => …);

// Curseur PDO — le plus économe, une seule requête
foreach (Article::cursor() as $article) { … }

class Article extends Model
{
    // ManyToOne — la clé étrangère est ici
    public function author(): BelongsTo
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    // OneToMany — la clé étrangère est en face
    public function comments(): HasMany
    {
        return $this->hasMany(Comment::class);
    }

    // ManyToMany — table pivot article_tag
    public function tags(): BelongsToMany
    {
        return $this->belongsToMany(Tag::class)
            ->withTimestamps()
            ->withPivot('position');
    }

    // OneToOne
    public function seo(): HasOne
    {
        return $this->hasOne(SeoMeta::class);
    }

    // Polymorphe — un commentaire sur n'importe quoi
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }

    // Raccourci HasManyThrough : les commentaires de tous mes articles
    public function comments(): HasManyThrough
    {
        return $this->hasManyThrough(Comment::class, Article::class);
    }
}

// ❌ 1 + 100 requêtes
$articles = Article::all();
foreach ($articles as $article) {
    echo $article->author->name;      // une requête à chaque tour
}

// ✅ 2 requêtes au total
$articles = Article::with('author')->get();

// Relations imbriquées
Article::with('comments.author')->get();

// Plusieurs relations
Article::with(['author', 'tags', 'comments' => fn ($q) => $q->latest()->limit(3)])->get();

// Compter sans charger
Article::withCount('comments')->get();     // $article->comments_count
Article::withSum('orders', 'total')->get();

// Charger après coup, sur une collection déjà en mémoire
$articles->load('tags');
$articles->loadMissing('author');          // seulement si absent

// A au moins un commentaire
Article::has('comments')->get();
Article::has('comments', '>=', 3)->get();

// Avec une condition sur la relation
Article::whereHas('tags', fn ($q) => $q->where('slug', 'php'))->get();
Article::whereRelation('author', 'active', true)->get();   // raccourci

// La négation
Article::doesntHave('comments')->get();
Article::whereDoesntHave('tags', fn ($q) => $q->where('hidden', true))->get();

// La clé étrangère est remplie automatiquement
$user->articles()->create(['title' => 'Bonjour']);
$article->comments()->createMany([...]);

// Many-to-many
$article->tags()->attach([1, 3]);
$article->tags()->attach(2, ['position' => 5]);   // avec données de pivot
$article->tags()->detach(3);
$article->tags()->detach();                        // tout retirer
$article->tags()->sync([1, 2]);                    // remplace intégralement
$article->tags()->syncWithoutDetaching([4]);       // ajoute sans retirer
$article->tags()->toggle([1, 5]);

// ManyToOne
$comment->article()->associate($article);
$comment->article()->dissociate();
$comment->save();

// Accéder aux données du pivot
foreach ($article->tags as $tag) {
    echo $tag->pivot->position;
}

use Illuminate\Database\Eloquent\Casts\Attribute;

class Article extends Model
{
    // Accesseur : $article->excerpt
    protected function excerpt(): Attribute
    {
        return Attribute::get(fn () => Str::limit(strip_tags($this->body), 140));
    }

    // Accesseur + mutateur sur une colonne existante
    protected function title(): Attribute
    {
        return Attribute::make(
            get: fn (string $value) => ucfirst($value),
            set: fn (string $value) => trim($value),
        );
    }

    // Scope local : Article::published()->get()
    public function scopePublished($query)
    {
        return $query->whereNotNull('published_at')
                     ->where('published_at', '<=', now());
    }

    // Scope paramétré : Article::ofStatus('draft')->get()
    public function scopeOfStatus($query, string $status)
    {
        return $query->where('status', $status);
    }
}

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
            $table->string('title');
            $table->string('slug')->unique();
            $table->text('body');
            $table->enum('status', ['draft', 'published'])->default('draft');
            $table->json('meta')->nullable();
            $table->decimal('price', 8, 2)->default(0);
            $table->unsignedInteger('views')->default(0);
            $table->timestamp('published_at')->nullable();
            $table->timestamps();          // created_at + updated_at
            $table->softDeletes();         // deleted_at

            $table->index(['status', 'published_at']);
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('articles');
    }
};

Schema::table('articles', function (Blueprint $table) {
    $table->string('subtitle')->nullable()->after('title');
    $table->renameColumn('body', 'content');
    $table->dropColumn('legacy_field');
    $table->dropConstrainedForeignId('category_id');
});

class ArticleFactory extends Factory
{
    public function definition(): array
    {
        return [
            'title'   => fake()->sentence(),
            'slug'    => fake()->unique()->slug(),
            'body'    => fake()->paragraphs(4, true),
            'user_id' => User::factory(),     // crée l'auteur à la volée
        ];
    }

    // État réutilisable
    public function published(): static
    {
        return $this->state(['published_at' => now()]);
    }

    public function withComments(int $n = 3): static
    {
        return $this->has(Comment::factory()->count($n));
    }
}

Article::factory()->create();
Article::factory(50)->published()->create();
Article::factory()->withComments(5)->create(['title' => 'Fixe']);
Article::factory()->make();                    // sans persister

// Relations dans les deux sens
User::factory()->has(Article::factory()->count(3))->create();
Article::factory()->for(User::factory()->state(['role' => 'admin']))->create();

public function run(): void
{
    $admin = User::factory()->create([
        'email' => 'admin@exemple.fr',
        'role'  => 'admin',
    ]);

    Article::factory(50)
        ->published()
        ->for($admin)
        ->create();

    $this->call([TagSeeder::class, SettingSeeder::class]);
}

public function store(Request $request)
{
    $data = $request->validate([
        'title'   => 'required|string|max:255',
        'slug'    => ['required', Rule::unique('articles')->ignore($article)],
        'tags'    => 'array',
        'tags.*'  => 'exists:tags,id',
        'cover'   => 'nullable|image|max:2048',
    ]);

    Article::create($data);
}

class StoreArticleRequest extends FormRequest
{
    public function rules(): array { … }

    // Messages personnalisés
    public function messages(): array
    {
        return [
            'body.min' => 'Le contenu doit faire au moins 50 caractères.',
        ];
    }

    // Renommer les champs dans les messages par défaut
    public function attributes(): array
    {
        return ['body' => 'contenu de l\'article'];
    }

    // Transformer les données AVANT validation
    protected function prepareForValidation(): void
    {
        $this->merge(['slug' => Str::slug($this->title)]);
    }

    // Validation transverse, APRÈS les règles
    public function after(): array
    {
        return [
            function (Validator $validator) {
                if ($this->published_at && ! $this->body) {
                    $validator->errors()->add('body', 'Un article publié doit avoir un contenu.');
                }
            },
        ];
    }
}

// 1. Contrôleur
$this->authorize('update', $article);          // lève 403
$request->user()->can('update', $article);     // booléen

// 2. Route
Route::put('/articles/{article}', …)->middleware('can:update,article');

// 3. Blade
@can('update', $article) … @endcan
@cannot('delete', $article) … @endcannot

// 4. Automatique sur tout un contrôleur de ressource
public function __construct()
{
    $this->authorizeResource(Article::class, 'article');
}

// Gate simple, sans modèle — l'équivalent d'un access_control
Gate::define('access-admin', fn (User $u) => $u->role === 'admin');

use Illuminate\Support\Facades\Auth;

Auth::attempt(['email' => $e, 'password' => $p], $remember);
Auth::login($user);
Auth::logout();
Auth::check();      Auth::id();      Auth::user();
auth()->user();     $request->user();

// Tokens Sanctum pour une API
$token = $user->createToken('mobile', ['articles:read'])->plainTextToken;
$user->tokens()->delete();

Route::middleware('auth:sanctum')->group(function () { … });

class ArticleResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id'         => $this->id,
            'title'      => $this->title,
            'slug'       => $this->slug,
            'excerpt'    => $this->excerpt,
            'published'  => (bool) $this->published_at,
            'publishedAt'=> $this->published_at?->toIso8601String(),

            // Inclus seulement si la relation a été chargée — évite le N+1
            'author'     => UserResource::make($this->whenLoaded('author')),
            'tags'       => TagResource::collection($this->whenLoaded('tags')),

            // Conditionnel
            'views'      => $this->when($request->user()?->isAdmin(), $this->views),

            'links'      => [
                'self' => route('api.articles.show', $this->id),
            ],
        ];
    }
}

// Un modèle
return ArticleResource::make($article);

// Une collection, avec pagination automatiquement incluse
return ArticleResource::collection(
    Article::with('author')->paginate(15)
);

// Ajouter des métadonnées
return ArticleResource::collection($articles)->additional([
    'meta' => ['version' => 'v1'],
]);

Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('articles', Api\ArticleController::class);
});

// Limitation de débit
Route::middleware('throttle:60,1')->group(function () { … });

class ArticleController extends Controller
{
    public function index(Request $request)
    {
        return ArticleResource::collection(
            Article::with('author')
                ->when($request->query('status'), fn ($q, $s) => $q->where('status', $s))
                ->latest()
                ->paginate($request->integer('per_page', 15))
        );
    }

    public function store(StoreArticleRequest $request)
    {
        $article = Article::create($request->validated());

        return ArticleResource::make($article)
            ->response()
            ->setStatusCode(201);
    }

    public function destroy(Article $article)
    {
        $this->authorize('delete', $article);
        $article->delete();

        return response()->noContent();      // 204
    }
}

$response = Http::withToken($token)
    ->timeout(10)
    ->retry(3, 200)
    ->acceptJson()
    ->post('https://api.exemple.fr/v1/items', ['name' => 'X']);

$response->successful();       // 2xx
$response->status();
$response->json('data.0.id');  // notation par points
$response->throw();            // lève une exception sur 4xx/5xx

// Requêtes concurrentes
$responses = Http::pool(fn ($pool) => [
    $pool->get('https://api.exemple.fr/a'),
    $pool->get('https://api.exemple.fr/b'),
]);

// En test
Http::fake(['api.exemple.fr/*' => Http::response(['ok' => true], 200)]);

SendInvoiceEmail::dispatch($invoice);
SendInvoiceEmail::dispatch($invoice)->delay(now()->addMinutes(10));
SendInvoiceEmail::dispatch($invoice)->onQueue('emails');
SendInvoiceEmail::dispatchIf($condition, $invoice);
SendInvoiceEmail::dispatchAfterResponse($invoice);   // ≈ kernel.terminate

// Chaîne séquentielle : le suivant démarre si le précédent réussit
Bus::chain([new ProcessPayment($o), new SendReceipt($o)])->dispatch();

// Lot parallèle avec callback de fin
Bus::batch($jobs)->then(fn () => …)->dispatch();

use Illuminate\Support\Facades\Schedule;

Schedule::command('sync:invoices')->dailyAt('03:00');
Schedule::job(new CleanTempFiles)->hourly();
Schedule::call(fn () => Cache::forget('stats'))->everyFiveMinutes();

// Garde-fous
Schedule::command('report:heavy')
    ->dailyAt('02:00')
    ->withoutOverlapping()          // pas deux exécutions simultanées
    ->onOneServer()                 // une seule machine du cluster
    ->runInBackground()
    ->emailOutputOnFailure('ops@exemple.fr');

// Événement : un simple porteur de données
class ArticlePublished
{
    use Dispatchable, SerializesModels;

    public function __construct(public Article $article) {}
}

// Listener — découvert automatiquement par le type-hint
class NotifySubscribers
{
    public function handle(ArticlePublished $event): void { … }
}

// Listener asynchrone : implémenter ShouldQueue suffit
class NotifySubscribers implements ShouldQueue { … }

// Déclenchement
ArticlePublished::dispatch($article);
event(new ArticlePublished($article));

// php artisan make:observer ArticleObserver --model=Article
class ArticleObserver
{
    public function creating(Article $article): void
    {
        $article->slug ??= Str::slug($article->title);
    }

    public function updated(Article $article): void { … }
    public function deleted(Article $article): void { … }
}

// AppServiceProvider::boot() — ou l'attribut #[ObservedBy] sur le modèle
Article::observe(ArticleObserver::class);

// Réponses
$response->assertJson(['ok' => true]);
$response->assertJsonCount(3, 'data');
$response->assertJsonStructure(['data' => [['id', 'title']]]);
$response->assertSessionHasErrors('title');

// Base de données
$this->assertDatabaseHas('articles', ['slug' => 'bonjour']);
$this->assertDatabaseMissing('articles', ['id' => 99]);
$this->assertDatabaseCount('articles', 3);
$this->assertSoftDeleted($article);

// Authentification
$this->assertAuthenticated();
$this->assertGuest();

// Doublures — désactivent réellement le service
Mail::fake();       Mail::assertSent(OrderConfirmation::class);
Queue::fake();      Queue::assertPushed(SendInvoiceEmail::class, 2);
Event::fake();      Event::assertDispatched(ArticlePublished::class);
Storage::fake('public');
Http::fake(['api.exemple.fr/*' => Http::response(['ok' => true])]);
Notification::fake();

php artisan down --secret="maintenance-2026"
git pull origin main

composer install --no-dev --optimize-autoloader
npm ci && npm run build

php artisan migrate --force
php artisan optimize            # config + routes + vues + événements
php artisan storage:link
php artisan queue:restart       # les workers gardent l'ancien code
php artisan up

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/monapp/artisan queue:work --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
user=www-data
numprocs=2
redirect_stderr=true
stdout_logfile=/var/www/monapp/storage/logs/worker.log
stopwaitsecs=3600