Comment éviter la recherche de table foreach dans Laravel

L'utilisation du mappage relationnel dans Laravel peut éviter le problème de l'utilisation de foreach pour rechercher des tables. Le mappage relationnel est l'une des puissantes fonctionnalités ORM (Mapping objet-relationnel) de Laravel, qui peut établir automatiquement des relations entre les tables du modèle.

Dans Laravel, il existe trois mappages de relations : un-à-un, un-à-plusieurs et plusieurs-à-plusieurs. Ces mappages de relations peuvent être définis et établis via des modèles Eloquent. Ci-dessous, nous présenterons en détail l'utilisation et la mise en œuvre de ces trois mappages de relations, en nous basant sur la pratique.

Mappage de relations un-à-un

Le mappage de relations un-à-un est souvent utilisé lorsque deux tables partagent la même clé primaire et qu'une ligne de données dans une table ne peut correspondre qu'à une ligne de données dans l'autre table. . Par exemple, la table Commandes et la table Clients. Chaque commande appartient à un seul client, et chaque client n'a qu'une seule commande. Dans ce cas, la colonne ID client de la table des commandes est la colonne de clé primaire de la table des clients.

Dans Eloquent, nous pouvons définir deux modèles : le modèle de commande et le modèle client, et établir une cartographie de relation biunivoque entre les deux modèles :

// 订单模型
class Order extends Model
{
    public function customer()
    {
        return $this->hasOne(Customer::class);
    }
}

// 客户模型
class Customer extends Model
{
    public function order()
    {
        return $this->belongsTo(Order::class);
    }
}

Dans le code ci-dessus, nous sommes dans les modèles Commande et Client respectivement Une méthode de relation est définie dans , à savoir client et commande. Les deux méthodes de relation utilisent les méthodes hasOne et appartientTo dans le modèle Eloquent pour établir un mappage de relation un-à-un entre les deux modèles.

Lorsque nous avons besoin de trouver des informations client pour une commande, il nous suffit d'utiliser la méthode $order->customer :

$order = Order::find($id);
$customer = $order->customer;

Cartographie des relations un-à-plusieurs

La cartographie des relations un-à-plusieurs est souvent utilisée dans une table Une ligne de données peut correspondre à des lignes de données dans plusieurs tables. Par exemple, un utilisateur possède plusieurs articles ou un service compte plusieurs employés. Dans ce cas, nous devons utiliser les méthodes hasMany et appartiennentTo dans le modèle Eloquent concerné pour établir un mappage de relation un-à-plusieurs.

En prenant la table user et la table article comme exemple, nous devons établir un mappage de relation un-à-plusieurs dans les modèles User et Article :

// 用户模型
class User extends Model
{
    public function articles()
    {
        return $this->hasMany(Article::class);
    }
}

// 文章模型
class Article extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Dans le code ci-dessus, nous définissons une méthode de relation nommée articles dans le User Modèle, Le mappage des relations un-à-plusieurs entre les utilisateurs et les articles est implémenté via la méthode hasMany. Une méthode de relation nommée user est définie dans le modèle Article, et le mappage de relations plusieurs-à-un entre les articles et les utilisateurs est implémenté via la méthode AppartientTo.

Lorsque nous devons trouver tous les articles d'un utilisateur, il suffit d'utiliser la méthode $user->articles :

$user = User::find($id);
$articles = $user->articles;

Mappage de relations plusieurs-à-plusieurs

Le mappage de relations plusieurs-à-plusieurs est souvent utilisé entre deux tables Relation plusieurs-à-plusieurs. Par exemple, en ce qui concerne la relation entre les utilisateurs et les rôles, un utilisateur peut avoir plusieurs rôles, et un rôle peut également appartenir à plusieurs utilisateurs. Dans ce cas, nous devons utiliser la méthode AppartientToMany dans le modèle Eloquent pour établir un mappage de relations plusieurs-à-plusieurs.

En prenant la table user et la table role comme exemple, nous devons établir un mappage de relations plusieurs-à-plusieurs dans les modèles User et Role :

// 用户模型
class User extends Model
{
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

// 角色模型
class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany(User::class);
    }
}

Dans le code ci-dessus, nous définissons une méthode de relation nommée rôles dans le User Dans ce modèle, le mappage des relations plusieurs-à-plusieurs entre les utilisateurs et les rôles est implémenté via la méthode AppartientToMany. Une méthode de relation nommée utilisateurs est définie dans le modèle de rôle, et le mappage de relations plusieurs-à-plusieurs entre les rôles et les utilisateurs est implémenté via la méthode AppartientToMany.

Lorsque nous avons besoin de trouver tous les rôles d'un utilisateur, il suffit d'utiliser la méthode $user->roles :

$user = User::find($id);
$roles = $user->roles;

Résumé

L'utilisation de la fonction de mappage des relations dans Laravel peut efficacement éviter le problème de l'utilisation de la table foreach chercher. Les mappages de relations un-à-un, un-à-plusieurs et plusieurs-à-plusieurs correspondent respectivement aux relations entre différentes tables de données et sont définis et mis en œuvre via la méthode du modèle Eloquent. Nous pouvons établir un mappage de relations en définissant des méthodes de relation dans le modèle Eloquent approprié, à l'aide des méthodes hasMany, appartientTo et appartientToMany. Cette méthode nous permet de mettre en œuvre des opérations de base de données complexes de manière simple et pratique, et rend également notre code plus clair et plus facile à maintenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!