Qu'est-ce qu'Eloquent et comment utiliser les modèles ?

Question

Accepted Answer

**Eloquent** est l'ORM (Object-Relational Mapper) de Laravel — il utilise le pattern **Active Record**, où chaque table de base de données possède une classe **Model** correspondante, et les instances de modèles représentent des lignes. Il fournit une façon élégante et expressive de interroger et manipuler la base de données sans écrire de SQL.

## Définir un modèle

```php
<?php
class User extends Model {
    // by convention, the User model maps to the "users" table automatically
    protected $fillable = ['name', 'email'];   // mass-assignable fields (security)
}
// generate with: php artisan make:model User
```

Un modèle étend `Model` et correspond à une table par convention de nommage (`User` → `users`). La liste `$fillable` contrôle quels champs peuvent être assignés en masse (une fonctionnalité de sécurité).

## Opérations CRUD (Active Record)

```php
// CREATE
$user = User::create(['name' => 'Ann', 'email' => 'ann@x.com']);
$user = new User; $user->name = 'Bob'; $user->save();

// READ
User::all();                              // all rows
User::find(1);                            // by primary key
User::where('active', true)->get();        // query with conditions
User::where('email', $email)->first();     // first match

// UPDATE
$user->update(['name' => 'New Name']);
$user->name = 'X'; $user->save();

// DELETE
$user->delete();
User::destroy(1);
```

L'API fluide et chaînable d'Eloquent se lit presque comme de l'anglais et génère le SQL pour vous — aucune requête brute pour les opérations courantes.

## Interroger avec le fluent builder

```php
User::where('age', '>', 18)
    ->where('active', true)
    ->orderBy('name')
    ->limit(10)
    ->get();                              // chainable query building

User::where('role', 'admin')->count();
User::where('email', $e)->exists();
```

## Les modèles sont bien plus que des données

```php
class Post extends Model {
    public function author() {                          // a relationship
        return $this->belongsTo(User::class);
    }
    public function getExcerptAttribute() {              // an accessor (computed attribute)
        return Str::limit($this->body, 100);
    }
}
$post->author;       // the related User
$post->excerpt;       // computed attribute
```

## Pourquoi c'est important

Eloquent est central dans Laravel — c'est comment les applications interagissent avec la base de données, et sa conception Active Record élégante est l'une des fonctionnalités les plus célébrées du framework, donc la maîtriser est essentielle pour tout développement Laravel.

Comprendre comment définir des modèles (mappage aux tables par convention), effectuer des opérations CRUD et interroger avec le builder fluide et chaînable est une connaissance fondamentale et quotidienne puisque l'accès aux données est au cœur de la plupart des applications.

L'API expressive et lisible d'Eloquent (`User::where(...)->orderBy(...)->get()`) vous permet de travailler avec la base de données en PHP pur sans écrire de SQL, améliorant dramatiquement la productivité et la lisibilité.

Les modèles sont aussi bien plus que des conteneurs de données — ils définissent des **relations** (connectant les tables associées) et peuvent avoir des **accesseurs/mutateurs** (attributs calculés) et de la logique métier, ce qui en fait des objets de domaine riches.

Connaître la protection d'assignation en masse `$fillable` (une considération de sécurité) est également importante.

Puisqu'Eloquent est comment les applications Laravel lisent et écrivent leurs données — et qu'il apparaît partout dans virtuellement chaque application Laravel — maîtriser les modèles et l'API de requête d'Eloquent est une matière fondamentale et incontournable qui sous-tend un développement Laravel efficace.