Créer des modèles et migration: utilisez PHP Artisan Make: Modèle post -m pour générer des modèles et des fichiers de migration, définir la structure de la table et exécuter PHP Artisan Migrate; 2. 3. Utiliser une association éloquente: définir l'appartenance et les relations HasMany dans le modèle, et utilisez la méthode avec () pour précharger les données associées pour éviter les problèmes de requête n 1; 4. Requête éloquente: Utilisez le constructeur de requête pour des appels de cha?ne tels que Where, Orderby et d'autres méthodes, et réutiliser la logique de requête par le biais de la gamme locale publiée; 5. Protection de l'attribution par lots: Set $ ??remplissable ou $ gardé dans les attributs du modèle pour empêcher une affectation inattendue; 6. Délétion douce: introduire un trait de softdeletes et ajouter des softdeletes () à la migration, utiliser delete () et restaurer () pour contr?ler la suppression et la récupération douce; 7. Accessoires et modificateurs: Traitez automatiquement les formats de données lors de la définition ou de l'obtention d'attributs via SetttLeAtTribute et GetTitleAtTribute. Eloquent interagit avec la base de données via le modèle, afin que les développeurs puissent utiliser efficacement des données sans écrire SQL natif. Il est recommandé que chaque tableau corresponde à un modèle, définisse raisonnablement la relation d'association et utilise pleinement les fonctions fournies par Eloquentent pour terminer les opérations de données, et finalement obtenir une structure de code claire et maintenable.

Elognent est ORM intégré de Laravel (mappeur relatif par objet) qui facilite l'interaction avec votre base de données à l'aide de la syntaxe PHP au lieu d'écrire SQL brut. Il est puissant, expressif et adapté aux débutants une fois que vous avez compris les bases. Voici comment utiliser Eloquent efficacement dans Laravel.

1. Création de modèles et de migrations

Chaque table de base de données a un modèle éloquent correspondant. Pour créer un modèle avec une migration, exécutez:

 PHP Artisan Make: Modèle post -m

Cela crée:

• app/Models/Post.php (le modèle)
• database/migrations/xxxx_xx_xx_create_posts_table.php (la migration)

Dans le fichier de migration, définissez votre structure de table:

 Schéma :: Create ('Posts', fonction (Table Blueprint $) {
    $ table-> id ();
    $ table-> String ('title');
    $ table-> text ('contenu');
    $ Table-> ForeignId ('user_id') -> contrainte ();
    $ Table-> TimeStamps ();
});

Exécutez la migration:

 PHP Artisan Migrate

Vous pouvez maintenant utiliser le modèle Post pour interagir avec le tableau posts .

Remarque: Si votre modèle est dans un dossier comme Models , assurez-vous de le référencer correctement ou de mettre à jour l'espace de noms par défaut dans config/auth.php si nécessaire.

2. Opérations CRUD de base

Une fois votre modèle configuré, vous pouvez effectuer des opérations de base.

Récupérer tous les enregistrements

 $ Posts = Post :: all ();

Trouver un enregistrement par id

 $ post = post :: find (1);
// ou lancer une exception si elle n'est pas trouvée
$ post = Post :: findorfail (1);

Créer un nouvel enregistrement

 Post :: Create ([[
    'title' => 'mon premier post',
    'Content' => 'Hello World',
    'user_id' => 1,
]));

Ou manuellement:

 $ post = new Post ();
$ post-> title = 'un autre post';
$ post-> content = 'plus de contenu';
$ post-> user_id = 1;
$ post-> sauver ();

Mettre à jour un enregistrement

 $ post = post :: find (1);
$ post-> title = 'title mis à jour';
$ post-> sauver ();

Ou utilisez une mise à jour de masse:

 POST :: WHERE ('ID', 1) -> Update (['Title' => 'Updated']);

Supprimer un record

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

// ou supprimer directement
Post :: destrument (1);

3. Utiliser des relations éloquentes

Eloquent rend la définition des relations entre les modèles simples.

Définir une relation (par exemple, le poste appartient à l'utilisateur)

Dans le modèle Post :

 Fonction publique User ()
{
    return $ this-> appartenance (user :: class);
}

Dans le modèle User :

 Postes de fonction publique ()
{
    retourner $ this-> hasmany (post :: class);
}

Vous pouvez maintenant accéder aux données connexes:

 $ post = Post :: avec ('utilisateur') -> trouver (1);
echo $ post-> utilisateur-> nom; // accéder à l'auteur

$ user = user :: find (1);
ForEach ($ user-> Posts comme $ post) {
    Echo $ post-> titre;
}

Utilisez with() pour les relations de chargement impatientes et évitez les problèmes de requête n 1.

4. interroger avec éloquent

Les modèles éloquents étendent le constructeur de requête, afin que vous puissiez les méthodes de cha?ne:

 $ publié Posts = Post :: Where ('Status', 'publié')
    -> où ('créé_at', '>', maintenant () -> subdays (7))
    -> orderBy ('Create_at', 'desc')
    -> get ();

Scopes (requêtes réutilisables)

Définissez une portée locale dans votre modèle:

 Scopepublié de fonction publique ($ Query)
{
    renvoyer $ query-> où (?statut?, ?publié?);
}

Utilisez-le:

 $ Posts = Post :: publié () -> get ();

5. Protection d'affectation de masse

Pour utiliser create() ou update() en toute sécurité, définissez les champs remplissables ou gardés.

Dans votre modèle:

 protégé $ fillable = ['title', 'contenu', 'user_id'];

Ou, alternativement:

 protégé $ gardé = []; // permet tout, mais moins sécurisé

6. Supprimations souples (facultatives)

Pour "supprimer" des enregistrements sans les supprimer de la base de données:

• Ajouter use Illuminate\Database\Eloquent\SoftDeletes; à votre modèle.
• Ajouter $table->softDeletes(); dans votre migration.
• Ensuite, utilisez ->delete() - il définit deleted_at au lieu de retirer la ligne.

Restaurer un enregistrement supprimé en douceur:

 $ post = Post :: withTrashed () -> trouver (1);
$ post-> restaurer ();

7. Accessoires et mutateurs

Modifiez les données lors de l'obtention ou de la définition d'attributs.

Mutateur (set)

 SetttLeAtTribute de la fonction publique (Valeur $)
{
    $ this-> attributs ['title'] = ucFirst ($ value);
}

Accessor (Get)

 Fonction publique GetTitleAtTribute ($ VALEUR)
{
    return ucFirst ($ value);
}

Maintenant, chaque fois que vous obtenez ou définissez title , il est capitalisé.

Eloquent fait du travail avec des bases de données dans Laravel intuitive et propre. Commencez par les modèles et les requêtes de base, puis utilisez progressivement les relations, les lunettes et les accessoires à mesure que votre application se développe. La plupart du temps, vous n'aurez pas besoin de SQL brut.

Fondamentalement, n'oubliez pas: un modèle par table, définition des relations et laissez éloquent faire le gros levage.

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!