How to use Eloquent in Laravel

Create models and migration: Use php artisan make:model Post -m to generate models and migration files, define table structure and run php artisan migrate; 2. Basic CRUD operations: use Post::all(), find(), create(), save() and delete() methods to query, create, update and delete data; 3. Use Eloquent association: define belongsTo and hasMany relationships in the model, and use the with() method to preload the associated data to avoid N 1 query problems; 4. Eloquent query: use query constructor to chain calls such as where, orderBy and other methods, and reuse query logic through local scopePublished; 5. Batch assignment protection: Set $fillable or $guarded in the model Attributes to prevent unexpected assignment; 6. Soft Deletion: Introduce SoftDeletes trait and add softDeletes() to the migration, use delete() and restore() to control soft deletion and recovery; 7. Accessories and modifiers: Automatically process data formats when setting or obtaining attributes through setTitleAttribute and getTitleAttribute. Eloquent interacts with the database through the model, so that developers can efficiently operate data without writing native SQL. It is recommended that each table correspond to a model, reasonably define the association relationship and make full use of the functions provided by Eloquent to complete data operations, and ultimately achieve a clear and maintainable code structure.

Eloquent is Laravel's built-in ORM (Object-Relational Mapper) that makes it easy to interact with your database using PHP syntax instead of writing raw SQL. It's powerful, expressive, and beginner-friendly once you understand the basics. Here's how to use Eloquent effectively in Laravel.

1. Creating Models and Migrations

Every database table has a corresponding Eloquent model. To create a model along with a migration, run:

 php artisan make:model Post -m

This creates:

• app/Models/Post.php (the model)
• database/migrations/xxxx_xx_xx_create_posts_table.php (the migration)

In the migration file, define your table structure:

 Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->foreignId('user_id')->constrained();
    $table->timestamps();
});

Run the migration:

 php artisan migrate

Now you can use the Post model to interact with the posts table.

Note: If your model is in a folder like Models , make sure to reference it correctly or update the default namespace in config/auth.php if needed.

2. Basic CRUD Operations

Once your model is set up, you can perform basic operations.

Retrieve All Records

 $posts = Post::all();

Find a Record by ID

 $post = Post::find(1);
// or throw an exception if not found
$post = Post::findOrFail(1);

Create a New Record

 Post::create([
    'title' => 'My First Post',
    'content' => 'Hello World',
    'user_id' => 1,
]);

Or manually:

 $post = new Post();
$post->title = 'Another Post';
$post->content = 'More content';
$post->user_id = 1;
$post->save();

Update a Record

 $post = Post::find(1);
$post->title = 'Updated Title';
$post->save();

Or use mass update:

 Post::where('id', 1)->update(['title' => 'Updated']);

Delete a Record

 $post = Post::find(1);
$post->delete();

// or delete directly
Post::destroy(1);

3. Using Eloquent Relationships

Eloquent makes defining relationships between models simple.

Define a Relationship (eg, Post belongs to User)

In the Post model:

 public function user()
{
    return $this->belongsTo(User::class);
}

In the User model:

 public function posts()
{
    return $this->hasMany(Post::class);
}

Now you can access related data:

 $post = Post::with('user')->find(1);
echo $post->user->name; // Access the author

$user = User::find(1);
foreach ($user->posts as $post) {
    echo $post->title;
}

Use with() to eager load relationships and avoid N 1 query problems.

4. Querying with Eloquent

Eloquent models extend the query builder, so you can chain methods:

 $publishedPosts = Post::where('status', 'published')
    ->where('created_at', '>', now()->subDays(7))
    ->orderBy('created_at', 'desc')
    ->get();

Scopes (Reusable Queries)

Define a local scope in your model:

 public function scopePublished($query)
{
    return $query->where('status', 'published');
}

Use it:

 $posts = Post::published()->get();

5. Mass Assignment Protection

To use create() or update() safely, define fillable or guarded fields.

In your model:

 protected $fillable = ['title', 'content', 'user_id'];

Or, alternatively:

 protected $guarded = []; // allows all, but less secure

6. Soft Deletes (Optional)

To "delete" records without removing them from the database:

• Add use Illuminate\Database\Eloquent\SoftDeletes; to your model.
• Add $table->softDeletes(); in your migration.
• Then use ->delete() — it sets deleted_at instead of removing the row.

Restore a soft-deleted record:

 $post = Post::withTrashed()->find(1);
$post->restore();

7. Accessors and Mutators

Modify data when getting or setting attributes.

Mutator (set)

 public function setTitleAttribute($value)
{
    $this->attributes['title'] = ucfirst($value);
}

Accessor (get)

 public function getTitleAttribute($value)
{
    return ucfirst($value);
}

Now every time you get or set title , it's capitalized.

Eloquent makes working with databases in Laravel intuitive and clean. Start with models and basic queries, then gradually use relationships, scopes, and accessors as your app grows. Most of the time, you won't need raw SQL.

Basically, just remember: one model per table, definition relationships, and let Eloquent do the heavy lifting.

The above is the detailed content of How to use Eloquent in Laravel. For more information, please follow other related articles on the PHP Chinese website!