اغلب اوقات در زندگی هر توسعه‌دهنده‌ای نقطه‌ای وجود دارد که باید با یک پایگاه داده تعامل داشته باشید. اینجا جایی است که Eloquent، لاراول object-relational mapper (ORM)، فرآیند تعامل با جداول پایگاه داده شما را بصری و طبیعی می‌کند.

این جایی است که به عنوان یک حرفه ای، شش نوع رابطه کلیدی را بشناسید و درک کنید که ما آنها را مرور و بررسی خواهیم کرد.

در لاراول، مدل‌ها به عنوان نمایندگانی از جداول دیتابیس عمل می‌کنند و یک پل ارتباطی بین دیتابیس و کدهای PHP ما هستند.

روابط در Eloquent چیست؟

هنگام کار با جداول در یک پایگاه داده رابطه ای، می توانیم روابط را به عنوان اتصالات بین جداول مشخص کنیم. این به شما کمک می‌کند تا داده‌ها را بدون زحمت سازماندهی و ساختار دهید تا خوانایی و مدیریت داده‌ها عالی باشد. سه نوع روابط پایگاه داده در عمل وجود دارد:

یک به یک (one-to-one) - یک رکورد در یک جدول با یک و فقط یک در جدول دیگر مرتبط است. مثلا یک نفر و یک شماره کد ملی.
یک به چند (one-to-many)- یک رکورد با چندین رکورد در جدول دیگر مرتبط است. به عنوان مثال، یک نویسنده و وبلاگ های آنها.
چندین به چند (many-to-many)- چندین رکورد در یک جدول با چندین رکورد در جدول دیگر مرتبط است. یعنی دانشجویان و دوره هایی که در آن ثبت نام می کنند.

لاراول تعامل و مدیریت روابط پایگاه داده را با استفاده از سینتکس شی گرا در Eloquent یکپارچه می کند.

لاراول در کنار این تعاریف، روابط بیشتری را معرفی می کند که عبارتند از:

Has Many Through
Polymorphic Relations
Many-to-many Polymorphic

به عنوان مثال، فروشگاهی را در نظر بگیرید که موجودی آن حاوی مقالات مختلفی است که هر کدام در دسته بندی خاص خود قرار دارند. بنابراین، تقسیم پایگاه داده به جداول متعدد از نقطه نظر تجاری منطقی است. این با مسائل خاص خود همراه است، زیرا شما نمی خواهید تک تک جدول ها را کوئری بزنید.

ما به راحتی می‌توانیم یک رابطه ساده یک به چند در لاراول ایجاد کنیم تا به ما کمک کند، مثلاً زمانی که نیاز به کوئری از محصولات داریم، می‌توانیم آن را با استفاده از مدل Product انجام دهیم.

رابطه یک به یک One-To-One

به عنوان اولین رابطه پایه ای که لاراول ارائه می دهد، آنها دو جدول را به گونه ای مرتبط می کنند که یک ردیف از جدول اول تنها با یک ردیف از جدول دیگر همبستگی دارد.

برای مشاهده عملی این موضوع، باید دو مدل Rent و Tenant ایجاد کنیم:

php artisan make:model Tenant 
Php artisan make:model Rent

در این مرحله، ما دو مدل داریم، یکی مستأجر و دیگری اجاره آنها است.

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Tenant extends Model
{
    /**
    * Get the rent of a Tenant
    */
    public function rent() 
    {
        return $this->hasOne(Rent::class);
    }
}

از آنجایی که eloquent رابطه کلید خارجی را بر اساس نام مدل پرنت تعیین می کند (در این مورد مستاجر)، مدل Rent فرض می کند که یک کلید خارجی tenant_id وجود دارد.

ما به راحتی می توانیم آن را مانند یک آرگومان اضافی به متد hasOne بازنویسی کنیم:

return $this- >hasOne(Rent::class, "custom_key");

Eloquent همچنین فرض می کند که بین کلید خارجی تعریف شده و کلید اصلی پرنت تطابق وجود دارد (مدل مستاجر). به‌طور پیش‌فرض، به نظر می‌رسد که tenant_id با کلید id رکورد مستأجر مطابقت دارد. ما می توانیم این را با یک آرگومان سوم در متد hasOne بازنویسی کنیم، به طوری که با کلید دیگری مطابقت داشته باشد:

return $this->hasOne(Rent::class, "custom_key", "other_key");

اکنون که رابطه یک به یک بین مدل ها را تعریف کرده ایم، می توانیم به راحتی از آن استفاده کنیم، مانند زیر:

$rent = Tenant::find(10)->rent;

با این خط کد، اجاره مستاجر را با id برابر 10 در صورت وجود دریافت می کنیم.

رابطه یک به چند One-To-Many

مانند رابطه قبلی، این رابطه بین یک مدل تک پرنت و مدل های چند فرزند را تعریف می کند. بعید است که مستاجر ما فقط یک قبض اجاره داشته باشد زیرا این یک پرداخت مکرر است، بنابراین چندین پرداخت خواهد داشت.

در این مورد، رابطه قبلی ما دارای نقص هایی است و می توانیم آنها را برطرف کنیم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Tenant extends Model
{
    /**
    * Get the rents of a Tenant
    */
    public function rent() 
    {
        return $this->hasMany(Rent::class);
    }
}

قبل از اینکه متد را برای دریافت اجاره فراخوانی کنیم، یک چیز خوب که بدانیم این است که روابط به عنوان سازندگان کوئری عمل می کنند، بنابراین می توانیم محدودیت هایی (مانند اجاره بین تاریخ، حداقل پرداخت، و غیره) اضافه کنیم و آنها را زنجیره ای کنیم تا نتیجه دلخواه خود را به دست آوریم. :

$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();

و مانند رابطه قبلی، می‌توانیم کلیدهای خارجی و محلی را با ارسال آرگومان‌های اضافی بازنویسی کنیم:

return $this->hasMany(Rent::class, "foreign_key");


return $this->hasMany(Rent::class, "foreign_key", "local_key");

حالا ما تمام اجاره یک مستاجر را داریم، اما وقتی اجاره را می دانیم و می خواهیم بفهمیم متعلق به چه کسی است، چه کار کنیم؟ ما می توانیم از ویژگی belongsTo استفاده کنیم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Rent extends Model
{
    /**
    * Return the tenant for the rent
    */
    public function tenant() 
    {
        return $this->belongsTo(Tenant::class);
    }
}

و اکنون می توانیم به راحتی مستاجر را دریافت کنیم:

$tenant = Rent::find(1)->tenant;

برای متد belongsTo نیز می‌توانیم کلیدهای خارجی و محلی را مانند قبل بازنویسی کنیم.

رابطه Has-One-Of-Many

از آنجایی که مدل مستاجر ما می‌تواند با بسیاری از مدل‌های اجاره مرتبط باشد، می‌خواهیم به راحتی آخرین یا قدیمی‌ترین مدل مرتبط روابط را بازیابی کنیم.

یک راه راحت برای انجام این کار، ترکیب روش های hasOne و ofMany است:

public function latestRent() {
    return $this->hasOne(Rent::class)->latestOfMany();
}

public function oldestRent() {
    return $this->hasOne(Rent::class)->oldestOfMany();
}

به‌طور پیش‌فرض، داده‌ها را بر اساس کلید اصلی دریافت می‌کنیم که قابل مرتب‌سازی است، اما می‌توانیم فیلترهای خود را برای متد ofMany ایجاد کنیم:

return $this->hasOne(Rent::class)->ofMany('price', 'min');

روابط HasOneThrough و HasManyThrough

متد های Through- نشان می‌دهد که مدل‌های ما باید مدل دیگری را برای برقراری رابطه با مدل مورد نظر طی کنند. به عنوان مثال، ما می توانیم اجاره را با مالک مرتبط کنیم، اما اجاره ابتدا باید از طریق مستاجر عبور کند تا به صاحبخانه برسد.

کلیدهای جداول لازم برای این کار به شکل زیر است:

rent
    id - integer
    name - string
    value - double

tenants
    id - integer
    name - string
    rent_id - integer

landlord
    id - integer
    name - string
    tenant_id - integer

پس از تجسم ظاهر جداول ما، می توانیم مدل ها را بسازیم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Rent extends Model
{
    /**
    * Return the rents' landlord
    */
    public function rentLandlord() 
    {
        return $this->hasOneThrough(Landlord::class, Tenant::class);
    }
}

آرگومان اول متد hasOneThrough مدلی است که می خواهید به آن دسترسی داشته باشید و آرگومان دوم مدلی است که از آن عبور خواهید کرد.

و درست مثل قبل، می توانید کلیدهای خارجی و محلی را بازنویسی کنید. اکنون که دو مدل داریم، دو مدل از هر کدام را داریم که باید به ترتیب زیر بنویسیم:

public function rentLandlord() 
{
    return $this->hasOneThrough(
        Landlord::class,
        Tenant::class,
        "rent_id",    // Foreign key on the tenant table
        "tenant_id",  // Foreign key on the landlord table
        "id",         // Local key on the tenant class
        "id"          // Local key on the tenant table
    );
}

به طور مشابه، رابطه "Has Many Through" در Laravel Eloquent زمانی مفید است که بخواهید از طریق یک جدول میانی به رکوردهای یک جدول دوردست دسترسی پیدا کنید.

بیایید یک مثال با سه جدول در نظر بگیریم:

کشور
کاربران
بازی ها

هر کشوری کاربران زیادی دارد و هر کاربر بازی های زیادی دارد. ما می خواهیم تمام بازی های متعلق به یک کشور را از طریق جدول کاربر بازیابی کنیم.

شما جداول را اینگونه تعریف می کنید:

country
    id - integer
    name - string

user
    id - integer
    country_id - integer
    name - string

games
    id - integer
    user_id - integer
    title - string

حال باید مدل Eloquent را برای هر جدول تعریف کنید:

در مدل کشور داریم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Country extends Model
{
    protected $fillable = ['name'];

    public function users()
    {
        return $this->hasMany(User::class);
    }

    public function games()
    {
        return $this->hasManyThrough(Games::class, User::class);
    }
}

در مدل کاربرها داریم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $fillable = [article_id, 'name'];

    public function country()
    {
        return $this->belongsTo(Country::class);
    }

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

در مدل بازی داریم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Game extends Model
{
    protected $fillable = ['user_id', 'title'];

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

اکنون می‌توانیم متد ()games مدل Country را فراخوانی کنیم تا همه بازی‌ها را دریافت کنیم، زیرا ما رابطه «Has Many Through» را بین Country و Game از طریق مدل User برقرار کردیم.

<?php

$country = Country::find(159);
            
// Retrieve all games for the country
$games = $country->games;

رابطه چند به چند Many-To-Many

رابطه چند به چند پیچیده تر است. یک مثال خوب کارمندی است که چندین نقش دارد. همچنین می توان یک نقش را به چندین کارمند اختصاص داد. این اساس رابطه چند به چند است.

برای این کار باید جداول کارمندان، نقش ها و role_employees را داشته باشیم.

ساختار جدول پایگاه داده ما به شکل زیر خواهد بود:

employees
    id - integer
    name - string

roles 
    id - integer
    name - string

role_employees
    user_id - integer
    role_id - integer

با دانستن ساختار جداول رابطه، می‌توانیم به راحتی مدل Employee خود را به Model ToMany Role تعریف کنیم.

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Employee extends Model
{
    public function roles() 
    {
        return $this- >belongsToMany(Role::class);
    }
}

وقتی این را تعریف کردیم، می توانیم به تمام نقش های یک کارمند دسترسی داشته باشیم و حتی آنها را فیلتر کنیم:

$employee = Employee::find(1);
$employee->roles->forEach(function($role) { // });

// OR 

$employee = Employee::find(1)->roles()->orderBy('name')->where('name', 'admin')->get();

مانند همه روش‌های دیگر، می‌توانیم کلیدهای خارجی و محلی متد belongsToMany را بازنویسی کنیم.

برای تعریف رابطه معکوس متعلق به belongsToMany، ما به سادگی از روش مشابه استفاده می کنیم، اما در حال حاضر از متد فرزند، با پرنت به عنوان آرگومان استفاده می کنیم.

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Role extends Model
{
    public function employees() 
    {
        return $this->belongsToMany(Employee::class);
    }
}

موارد استفاده از جدول میانی

همانطور که ممکن است متوجه شده باشیم، وقتی از رابطه چند به چند استفاده می کنیم، همیشه قرار است یک جدول میانی داشته باشیم. در این حالت از جدول role_employees استفاده می کنیم.

به طور پیش فرض، جدول محوری ما فقط دارای ویژگی های id خواهد بود. اگر خصوصیات دیگری می خواهیم، باید آنها را به این صورت مشخص کنیم:

return $this->belongsToMany(Employee::class)->withPivot("active", "created_at");

اگر بخواهیم pivot را برای Timestamps میانبر داشته باشیم، می توانیم این کار را انجام دهیم:

return $this->belongsToMany(Employee::class)->withTimestamps();

یکی از ترفندهایی که باید بدانید این است که ما می‌توانیم نام "pivot" را به هر چیزی که مناسب تر برنامه ما باشد سفارشی کنیم:

return $this->belongsToMany(Employee::class)->as('subscription')->withPivot("active", "created_by");

فیلتر کردن نتایج یک کوئری الکونت ها گویا برای هر توسعه دهنده ای که می خواهد بازی خود را تقویت کند و برنامه های لاراول خود را بهینه کند، باید بداند.

بنابراین لاراول یک ویژگی فوق‌العاده از Pivot را ارائه می‌کند که می‌توان از آن برای فیلتر کردن داده‌هایی که می‌خواهیم جمع‌آوری کنیم استفاده کرد. بنابراین به جای استفاده از سایر ویژگی‌ها مانند تراکنش‌های پایگاه داده برای دریافت داده‌های خود به صورت تکه‌ای، می‌توانیم آن‌ها را با روش‌های مفیدی مانند WherePivot، WherePivotIn، WherePivotNotIn، WherePivotBetween، WherePivotNotBetween، WherePivotNull، WherePivotNotNull فیلتر کنیم و می‌توانیم در هنگام تعریف روابط بین جداول از آنها استفاده کنیم!

return $this->belongsToMany(Employee::class)->wherePivot('promoted', 1);
return $this->belongsToMany(Employee::class)->wherePivotIn('level', [1, 2]);
return $this->belongsToMany(Employee::class)->wherePivotNotIn('level', [2, 3]);
return $this->belongsToMany(Employee::class)->wherePivotBetween('posted_at', ['2023-01-01 00:00:00', '2023-01-02 00:00:00']);
return $this->belongsToMany(Employee::class)->wherePivotNull('expired_at');
return $this->belongsToMany(Employee::class)->wherePivotNotNull('posted_at');

آخرین ویژگی شگفت‌انگیز این است که می‌توانیم براساس Pivot سفارش دهیم:

return $this->belongsToMany(Employee::class)
        ->where('promoted', true)
        ->orderByPivot('hired_at', 'desc');

روابط چند شکلی Polymorphic

کلمه Polymorphic از یونانی گرفته شده است و به معنای "شکل های متعدد" است. مانند این، یک مدل در برنامه ما می تواند اشکال مختلفی داشته باشد، به این معنی که می تواند بیش از یک ارتباط داشته باشد. تصور کنید ما در حال ساخت یک برنامه با وبلاگ ها، ویدئوها، نظرسنجی ها و غیره هستیم. کاربر می تواند برای هر یک از این موارد نظر ایجاد کند. بنابراین، یک مدل نظر ممکن است متعلق به مدل‌های وبلاگ‌ها، ویدیوها و نظرسنجی‌ها باشد.

چند شکلی یک به یک Polymorphic One To One

این نوع رابطه مشابه یک رابطه استاندارد یک به یک است. تنها تفاوت این است که مدل فرزند می تواند به بیش از یک نوع مدل با یک ارتباط واحد تعلق داشته باشد.

به عنوان مثال، یک مدل مستاجر و صاحبخانه را در نظر بگیرید، ممکن است یک رابطه چند شکلی با یک مدل WaterBill مشترک داشته باشد.

ساختار جدول می تواند به صورت زیر باشد:

tenants
    id – integer
    name – string

landlords
    id – integer
    name – string

waterbills
    id – integer
    amount – double
    waterbillable_id
    waterbillable_type

ما از waterbillable_id برای شناسه صاحبخانه یا مستاجر استفاده می کنیم، در حالی که waterbillable_type حاوی نام کلاس مدل پرنت است. ستون نوع توسط eloquent استفاده می شود تا بفهمد چه مدل پرنت را باید برگرداند.

تعریف مدل برای چنین رابطه ای به صورت زیر خواهد بود:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class WaterBill extends Model
{
    public function billable()
    {
        return $this->morphTo();
    }
}

class Tenant extends Model
{
    public function waterBill()    
    {
        return $this->morphOne(WaterBill::class, 'billable');
    }
}

class Landlord extends Model
{
    public function waterBill()    
    {
        return $this->morphOne(WaterBill::class, 'billable');
    }
}

هنگامی که همه اینها را در اختیار داریم، می‌توانیم به داده‌های هر دو مدل مالک و مستاجر دسترسی داشته باشیم:

<?php

$tenant = Tenant::find(1)->waterBill;
$landlord = Landlord::find(1)->waterBill;

چند شکلی یک به چند Polymorphic One To Many

این شبیه به یک رابطه معمولی یک به چند است، تنها تفاوت اصلی این است که مدل فرزند می‌تواند به بیش از یک نوع مدل، با استفاده از یک ارتباط واحد تعلق داشته باشد.

در برنامه‌ای مانند فیس‌بوک، کاربران می‌توانند روی پست‌ها، ویدئوها، نظرسنجی‌ها، لایو و غیره نظر بدهند. با یک چند شکلی به چند شکل، می‌توانیم از یک جدول نظرات برای ذخیره نظرات برای همه دسته‌هایی که داریم استفاده کنیم. ساختار جداول ما چیزی شبیه به این خواهد بود:

posts 
    id – integer
    title – string
    body – text

videos
    id – integer
    title – string
    url – string

polls
    id – integer
    title – string

comments 
    id – integer
    body – text
    commentable_id – integer
    commentable_type – string

commentable_id شناسه رکورد است و commentable_type نوع کلاس است، بنابراین eloquent می داند به دنبال چه چیزی باشد. در مورد ساختار مدل، بسیار شبیه به چند شکلی یک به یک است:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Comment extends Model 
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

class Poll extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Live extends Model
{
    public function comments()
    {
        return $this->morphMany(Comments::class, 'commentable');
    }
}

اکنون برای بازیابی نظرات یک Live، به سادگی می‌توانیم متد find را با id فراخوانی کنیم و اکنون به کلاس تکراری comments دسترسی داریم:

<?php

use App\Models\Live;

$live = Live::find(1);

foreach ($live->comments as $comment) { }

// OR

Live::find(1)->comments()->each(function($comment) { // });
Live::find(1)->comments()->map(function($comment) { // });
Live::find(1)->comments()->filter(function($comment) { // });

// etc.

و اگر کامنت را داشته باشیم و بخواهیم بدانیم که به چه کسی تعلق دارد، به متد commentable دسترسی پیدا می کنیم:

<?php

use App\Models\Comment;

$comment = Comment::find(10);
$commentable = $comment->commentable;

// commentable – type of Post, Video, Poll, Live

Polymorphic One of Many

در بسیاری از برنامه های کاربردی که مقیاس می شوند، ما یک راه آسان برای تعامل با مدل ها و بین آنها می خواهیم. ممکن است اولین یا آخرین پست کاربر را بخواهیم، که می تواند با ترکیبی از متد های morphOne و ofMany انجام شود:

<?php

public function latestPost()
{
    return $this->morphOne(Post::class, 'postable')->latestOfMany();
}

public function oldestPost()
{
    return $this->morphOne(Post::class, 'postable')->oldestOfMany();
}

متد های latestOfMany و oldestOfMany آخرین یا قدیمی‌ترین مدل را بر اساس کلید اصلی مدل، که شرط قابل مرتب‌سازی آن بود، بازیابی می‌کنند.

در برخی موارد نمی‌خواهیم بر اساس شناسه مرتب‌سازی کنیم، شاید تاریخ انتشار برخی از پست‌ها را تغییر داده‌ایم و آنها را به آن ترتیب می‌خواهیم، نه با شناسه آنها.

این را می توان با ارسال 2 پارامتر به متد ofMany انجام داد تا به این امر کمک کند. پارامتر اول کلیدی است که می خواهیم با آن فیلتر کنیم و دومی روش مرتب سازی است:

<?php

public function latestPublishedPost()
{
    return $this->morphOne(Post::class, "postable")->ofMany("published_at", "max");
}

با این حساب می توان روابط پیشرفته تری برای این کار ساخت! تصور کنید این سناریو را داریم. از ما خواسته می شود که لیستی از تمام پست های فعلی را به ترتیبی که منتشر شده اند ایجاد کنیم. مشکل زمانی ایجاد می شود که ما 2 پست با همان مقدار published_at داشته باشیم و زمانی که قرار است پست ها در آینده پست شوند.

برای این کار می‌توانیم ترتیبی که می‌خواهیم فیلترها اعمال شوند را به متد ofMany منتقل کنیم. به این ترتیب ما توسط publish_at سفارش می دهیم و اگر آنها یکسان هستند، با id سفارش می دهیم. ثانیاً، ما می‌توانیم یک تابع query در متد ofMany اعمال کنیم تا همه پست‌هایی که برای انتشار برنامه‌ریزی شده‌اند را حذف کنیم!

<?php

public function currentPosts()
{
    return $this->hasOne(Post::class)->ofMany([
        'published_at' => 'max',
        'id' => 'max',
    ], function ($query) {
        $query->where('published_at', '<', now());
    });
}

چند شکلی چند به چند Polymorphic Many To Many

چند شکلی چند به چند کمی پیچیده تر از معمولی است. یکی از موقعیت‌های رایج این است که تگ ها برای دارایی‌های بیشتری در برنامه شما اعمال شوند. به عنوان مثال، در TikTok، تگ هایی داریم که می توان آنها را روی فیلم ها، شورت ها، داستان ها و غیره اعمال کرد.

چند شکلی چند به چند به ما این امکان را می دهد که یک جدول واحد از تگ های مرتبط با فیلم ها، شورت ها و داستان ها داشته باشیم.

ساختار جدول ساده است:

videos
    id – integer
    description – string

stories 
    id – integer
    description – string

taggables 
    tag_id – integer
    taggable_id – integer
    taggable_type – string

با آماده بودن جداول می توانیم مدل را بسازیم و از متد morphToMany استفاده کنیم. این متد نام کلاس مدل و "relationship name" را می پذیرد:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Video extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

و با این کار به راحتی می توانیم رابطه معکوس را تعریف کنیم. ما می دانیم که برای هر مدل فرزند می خواهیم متد morphedByMany را صدا کنیم:

<?php

namespace App\Models;
use Illuminate\Database\Eloquent\Model;

class Tag extends Model
{
    public function stories()
    {
        return $this->morphedByMany(Story::class, 'taggable');
    }

    public function videos()
    {
        return $this->morphedByMany(Video::class, 'taggable');
    } 
}

و اکنون، وقتی یک تگ دریافت می کنیم، می توانیم تمام ویدیوها و داستان های مربوط به آن برچسب را بازیابی کنیم!

<?php
use App\Model\Tag;

$tag = Tag::find(10);
$posts = $tag->stories;
$videos = $tag->stories;

Eloquent را برای سرعت بهینه کنید

هنگام کار با Laravel's Eloquent ORM، درک چگونگی بهینه سازی کوئریهای پایگاه داده و به حداقل رساندن زمان و حافظه مورد نیاز برای واکشی داده ها ضروری است. یکی از راه های انجام این کار، پیاده سازی کش در برنامه شما است.

لاراول یک سیستم کش انعطاف پذیر ارائه می کند که از پشتیبان های مختلف مانند Redis، Memcached و کش مبتنی بر فایل پشتیبانی می کند. با کش کردن نتایج کوئری Eloquent، می توانید تعداد کوئریهای پایگاه داده را کاهش دهید و برنامه خود را سریعتر و ارزشمندتر کنید.

علاوه بر این، می توانید از سازنده کوئری لاراول برای ایجاد کوئریهای پیچیده اضافی استفاده کنید و عملکرد برنامه خود را بیشتر بهینه کنید.

نتیجه

در نتیجه، روابط Eloquent یکی از ویژگی های قدرتمند لاراول است که به توسعه دهندگان اجازه می دهد به راحتی با داده های مرتبط کار کنند. از روابط یک به یک تا چندین به چند، Eloquent یک سینتکس ساده و شهودی برای تعریف و کوئریی این روابط ارائه می دهد.

به عنوان یک توسعه دهنده لاراول، تسلط بر روابط Eloquent می تواند گردش کار توسعه شما را تا حد زیادی افزایش دهد و کد شما را کارآمدتر و خواناتر کند. اگر علاقه مند به کسب اطلاعات بیشتر در مورد لاراول هستید، آنوفل منابع مختلفی در دسترس دارد، از جمله آموزش شروع کار با لاراول(بزودی) و مقاله ای در مورد توسعه دهندگان لاراول.

دوره های آموزشی

مسیر یادگیری

روابط در لاراول Laravel Eloquent Relationships

Mohammad Abdorrahmani