Les billets Laracon EU sont maintenant disponibles! Obtenez vos billets aujourd'hui!

SEARCH 5.8 ☰

Eloquent: Commencer
# introduction
# Définir des modèles
# Conventions modèles éloquentes
# Valeurs d'attribut par défaut
# Récupérer des modèles
# Des collections
# Résultats tronqués
# Récupération de modèles uniques / agrégats
# Récupération des agrégats
# Insertion et mise à jour de modèles
# Inserts
# Mises à jour
# Affectation de masse
# Autres méthodes de création
# Suppression de modèles
# Suppression douce
# Interrogation de modèles supprimés progressivement
# Portées de la requête
# Portées globales
# Portées locales
# Comparaison de modèles
# Événements
# Observateurs

# introduction
Eloquent ORM fourni avec Laravel fournit une belle et simple implémentation d'ActiveRecord pour
travailler avec votre base de données. Chaque table de base de données a un "Modèle" correspondant
qui est utilisé pour interagir avec cette table. Les modèles vous permettent de rechercher des données
dans vos tables, ainsi que d'insérer de nouveaux enregistrements dans la table.
 Avant de commencer, assurez-vous de configurer une connexion de base de données dans . Pour plus
d'informations sur la configuration de votre base de données, consultez la documentation
. config/database.php

# Définir des modèles

Pour commencer, créons un modèle Eloquent. Les modèles résident généralement dans le
app répertoire, mais vous êtes libre de les placer à tout endroit pouvant être chargé automatiquement

en fonction de votre fichier. Tous les modèles Eloquent étendent la

classe. composer.json Illuminate\Database\Eloquent\Model

Le moyen le plus simple de créer une instance de modèle consiste à utiliser la commande Artisan
: make:model

php artisan make:model Flight

Si vous souhaitez générer une migration de base de données lorsque vous générez le modèle, vous
pouvez utiliser l' option --migration ou -m :

php artisan make:model Flight --migration

php artisan make:model Flight -m

Conventions modèles éloquentes

Examinons maintenant un exemple de Flight modèle que nous utiliserons pour extraire et stocker des
informations à partir de notre flights table de base de données:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

//

}
Noms de table
Notez que nous n'avons pas indiqué à Eloquent quelle table utiliser pour notre Flight modèle. Par
convention, le nom au pluriel "cas du serpent" de la classe sera utilisé comme nom de table sauf si un
autre nom est explicitement spécifié. Ainsi, dans ce cas, Eloquent supposera que le Flight modèle
stocke les enregistrements dans la flights table. Vous pouvez spécifier une table personnalisée en
définissant une table propriété sur votre modèle:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

/**

* The table associated with the model.

* @var string

*/

protected $table = 'my_flights';

Clés primaires
Eloquent supposera également que chaque table a une colonne de clé primaire nommée id . Vous
pouvez définir une $primaryKey propriété protégée pour remplacer cette convention.

De plus, Eloquent suppose que la clé primaire est une valeur entière incrémentée, ce qui signifie que par
défaut, la clé primaire est convertie int automatiquement en une clé . Si vous souhaitez utiliser une clé
primaire non incrémentée ou non numérique, vous devez définir la $incrementing propriété publique de
votre modèle sur false . Si votre clé primaire n'est pas un entier, vous devez définir la
$keyType propriété protected sur votre modèle string .

Horodatage
Par défaut, Eloquent s'attend à ce created_at que des updated_at colonnes existent sur vos tables. Si
vous ne souhaitez pas que ces colonnes soient gérées automatiquement par Eloquent, définissez la
$timestamps propriété de votre modèle sur false :

<?php
 namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

/**

* Indicates if the model should be timestamped.

* @var bool

*/

public $timestamps = false;

Si vous devez personnaliser le format de vos horodatages, définissez la $dateFormat propriété sur votre
modèle. Cette propriété détermine la manière dont les attributs de date sont stockés dans la base de
données, ainsi que leur format lorsque le modèle est sérialisé en tableau ou en JSON:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

/**

* The storage format of the model's date columns.

* @var string

*/

protected $dateFormat = 'U';

Si vous devez personnaliser les noms des colonnes utilisées pour stocker les horodatages, vous pouvez
définir les constantes CREATED_AT et UPDATED_AT dans votre modèle:

<?php

class Flight extends Model

{
 const CREATED_AT = 'creation_date';

const UPDATED_AT = 'last_update';

Connexion à la base de données

Par défaut, tous les modèles Eloquent utiliseront la connexion à la base de données par défaut
configurée pour votre application. Si vous souhaitez spécifier une connexion différente pour le modèle,
utilisez la $connection propriété:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

/**

* The connection name for the model.

* @var string

*/

protected $connection = 'connection-name';

Valeurs d'attribut par défaut

Si vous souhaitez définir les valeurs par défaut de certains attributs de votre modèle, vous pouvez
définir une $attributes propriété sur votre modèle:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

/**
 * The model's default values for attributes.

* @var array

*/

protected $attributes = [

'delayed' => false,

];

# Récupérer des modèles

Une fois que vous avez créé un modèle et sa table de base de données associée , vous êtes prêt à
commencer à extraire des données de votre base de données. Considérez chaque modèle Eloquent
comme un puissant générateur de requêtes vous permettant d'interroger facilement la table de base de
données associée au modèle. Par exemple:

<?php

$flights = App\Flight::all();

foreach ($flights as $flight) {

echo $flight->name;

Ajout de contraintes supplémentaires

La all méthode Eloquent renverra tous les résultats dans le tableau du modèle. Étant donné que
chaque modèle Eloquent sert de générateur de requête , vous pouvez également ajouter des contraintes
aux requêtes, puis utiliser la get méthode pour extraire les résultats:

$flights = App\Flight::where('active', 1)

->orderBy('name', 'desc')

->take(10)

->get();

Les modèles Eloquent étant des générateurs de requêtes, vous devez revoir toutes les
méthodes disponibles dans le générateur de requêtes . Vous pouvez utiliser l'une de ces
méthodes dans vos requêtes Eloquent.
Modèles rafraîchissants
Vous pouvez actualiser les modèles à l'aide des méthodes fresh et refresh . La fresh méthode
récupérera le modèle de la base de données. L'instance de modèle existante ne sera pas affectée:

$flight = App\Flight::where('number', 'FR 900')->first();

$freshFlight = $flight->fresh();

La refresh méthode réhydratera le modèle existant en utilisant de nouvelles données de la base de

données. En outre, toutes ses relations chargées seront également actualisées:

$flight = App\Flight::where('number', 'FR 900')->first();

$flight->number = 'FR 456';

$flight->refresh();

$flight->number; // "FR 900"

Des collections
Pour les méthodes Eloquent telles que all et get qui récupèrent plusieurs résultats, une instance de
sera retournée. La classe fournit une variété de méthodes utiles pour travailler avec vos résultats
Eloquent: Illuminate\Database\Eloquent\Collection Collection

$flights = $flights->reject(function ($flight) {

return $flight->cancelled;

});

Vous pouvez également parcourir la collection comme un tableau:

foreach ($flights as $flight) {

echo $flight->name;

Résultats tronqués
Si vous devez traiter des milliers d'enregistrements Eloquent, utilisez la chunk commande. La
chunk méthode récupérera un "bloc" de modèles Eloquent, les alimentant à une donnée Closure à
 traiter. L'utilisation de cette chunk méthode vous permettra d'économiser de la mémoire lorsque vous
travaillerez avec de grands ensembles de résultats:

Flight::chunk(200, function ($flights) {

foreach ($flights as $flight) {

//

});

Le premier argument transmis à la méthode est le nombre d'enregistrements que vous souhaitez
recevoir par "morceau". La fermeture passée en tant que deuxième argument sera appelée pour chaque
bloc extrait de la base de données. Une requête de base de données sera exécutée pour extraire chaque
bloc d'enregistrements transmis à la fermeture.

Utilisation de curseurs
La cursor méthode vous permet de parcourir les enregistrements de votre base de données à l'aide
d'un curseur, qui n'exécutera qu'une seule requête. Lors du traitement de grandes quantités de
données, la cursor méthode peut être utilisée pour réduire considérablement votre utilisation de la
mémoire:

foreach (Flight::where('foo', 'bar')->cursor() as $flight) {

//

# Récupération de modèles uniques / agrégats

En plus de récupérer tous les enregistrements d'une table donnée, vous pouvez également extraire des
enregistrements uniques à l'aide de find ou first . Au lieu de renvoyer une collection de modèles, ces
méthodes renvoient une seule instance de modèle:

// Retrieve a model by its primary key...

$flight = App\Flight::find(1);

// Retrieve the first model matching the query constraints...

$flight = App\Flight::where('active', 1)->first();

Vous pouvez également appeler la find méthode avec un tableau de clés primaires, qui renverront une
collection des enregistrements correspondants:
 $flights = App\Flight::find([1, 2, 3]);

Exceptions Introuvables
Parfois, vous souhaiterez peut-être lancer une exception si aucun modèle n’est trouvé. Ceci est
particulièrement utile dans les routes ou les contrôleurs. Les méthodes findOrFail et firstOrFail vont
récupérer le premier résultat de la requête; Cependant, si aucun résultat n'est trouvé, un sera
lancé: Illuminate\Database\Eloquent\ModelNotFoundException

$model = App\Flight::findOrFail(1);

$model = App\Flight::where('legs', '>', 100)->firstOrFail();

Si l'exception n'est pas interceptée, une 404 réponse HTTP est automatiquement renvoyée à
l'utilisateur. Il n'est pas nécessaire d'écrire des vérifications explicites pour renvoyer les 404 réponses
lors de l'utilisation de ces méthodes:

Route::get('/api/flights/{id}', function ($id) {

return App\Flight::findOrFail($id);

});

Récupération des agrégats

Vous pouvez également utiliser les count , sum , max et d' autres méthodes globales fournies par le
générateur de requêtes . Ces méthodes renvoient la valeur scalaire appropriée au lieu d'une instance de
modèle complète:

$count = App\Flight::where('active', 1)->count();

$max = App\Flight::where('active', 1)->max('price');

# Insertion et mise à jour de modèles

Inserts
To create a new record in the database, create a new model instance, set attributes on the model, then
call the save method:
 <?php

namespace App\Http\Controllers;

use App\Flight;

use Illuminate\Http\Request;

use App\Http\Controllers\Controller;

class FlightController extends Controller

/**

* Create a new flight instance.

* @param Request $request

* @return Response

*/

public function store(Request $request)

// Validate the request...

$flight = new Flight;

$flight->name = $request->name;

$flight->save();

In this example, we assign the name parameter from the incoming HTTP request to the name attribute
of the App\Flight model instance. When we call the save method, a record will be inserted into the
database. The created_at and updated_at timestamps will automatically be set when the save
method is called, so there is no need to set them manually.

Updates
The save method may also be used to update models that already exist in the database. To update a
model, you should retrieve it, set any attributes you wish to update, and then call the save method.
Again, the updated_at timestamp will automatically be updated, so there is no need to manually set its
value:
 $flight = App\Flight::find(1);

$flight->name = 'New Flight Name';

$flight->save();

Mass Updates
Updates can also be performed against any number of models that match a given query. In this
example, all flights that are active and have a destination of San Diego will be marked as delayed:

App\Flight::where('active', 1)

->where('destination', 'San Diego')

->update(['delayed' => 1]);

The update method expects an array of column and value pairs representing the columns that should
be updated.

Lors de la publication d'une mise à jour en masse via Eloquent, les événements saved et
updated modèles ne sont pas déclenchés pour les modèles mis à jour. En effet, les modèles
ne sont jamais réellement récupérés lors de la mise à jour en masse.

Affectation de masse
Vous pouvez également utiliser cette create méthode pour enregistrer un nouveau modèle sur une
seule ligne. L'instance de modèle insérée vous sera renvoyée par la méthode. Cependant, avant de le
faire, vous devrez spécifier un attribut fillable ou un guarded attribut sur le modèle, car tous les
modèles Eloquent protègent contre les affectations en masse par défaut.

Une vulnérabilité d’assignation en masse se produit lorsqu'un utilisateur transmet un paramètre HTTP
inattendu via une demande et que ce paramètre modifie une colonne de votre base de données
inattendue. Par exemple, un utilisateur malveillant peut envoyer un is_admin paramètre via une requête
HTTP, qui est ensuite transmise à la create méthode de votre modèle , permettant ainsi à l'utilisateur
de se faire passer pour un administrateur.

Donc, pour commencer, vous devez définir les attributs de modèle que vous souhaitez rendre
assignables en masse. Vous pouvez le faire en utilisant la $fillable propriété sur le modèle. Par
exemple, assignons l' name attribut de notre Flight modèle en masse:
 <?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Flight extends Model

/**

* The attributes that are mass assignable.

* @var array

*/

protected $fillable = ['name'];

Une fois que les attributs ont été assignés en masse, vous pouvez utiliser la create méthode pour
insérer un nouvel enregistrement dans la base de données. La create méthode retourne l'instance de
modèle enregistrée:

$flight = App\Flight::create(['name' => 'Flight 10']);

Si vous avez déjà une instance de modèle, vous pouvez utiliser la fill méthode pour la remplir avec un
tableau d'attributs:

$flight->fill(['name' => 'Flight 22']);

Attributs de garde
Tandis que $fillable sert comme une "liste blanche" d'attributs qui devraient être assignables en
masse, vous pouvez également choisir d'utiliser $guarded . La $guarded propriété doit contenir un
tableau d'attributs que vous ne souhaitez pas affecter en masse. Tous les autres attributs ne figurant
pas dans le tableau seront assignables en masse. Donc, $guarded fonctionne comme une "liste noire".
De manière importante, vous devez utiliser l'un $fillable ou l' autre ou $guarded pas les deux. Dans
l'exemple ci-dessous, tous les attributs sauf pour price seront assignables en masse:

<?php

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

class Flight extends Model

/**

* The attributes that aren't mass assignable.

* @var array

*/

protected $guarded = ['price'];

Si vous souhaitez rendre tous les attributs assignables en masse, vous pouvez définir la
$guarded propriété comme un tableau vide:

/**

* The attributes that aren't mass assignable.

* @var array

*/

protected $guarded = [];

Autres méthodes de création

firstOrCreate / firstOrNew

There are two other methods you may use to create models by mass assigning attributes:
firstOrCreate and firstOrNew . The firstOrCreate method will attempt to locate a database record

using the given column / value pairs. If the model can not be found in the database, a record will be
inserted with the attributes from the first parameter, along with those in the optional second
parameter.

The firstOrNew method, like firstOrCreate will attempt to locate a record in the database matching
the given attributes. However, if a model is not found, a new model instance will be returned. Note that
the model returned by firstOrNew has not yet been persisted to the database. You will need to call
save manually to persist it:

// Retrieve flight by name, or create it if it doesn't exist...

$flight = App\Flight::firstOrCreate(['name' => 'Flight 10']);

// Retrieve flight by name, or create it with the name, delayed, and arrival time attributes...
 // Retrieve flight by name, or create it with the name, delayed, and arrival_time attributes...

$flight = App\Flight::firstOrCreate(

['name' => 'Flight 10'],

['delayed' => 1, 'arrival_time' => '11:30']

);

// Retrieve by name, or instantiate...

$flight = App\Flight::firstOrNew(['name' => 'Flight 10']);

// Retrieve by name, or instantiate with the name, delayed, and arrival_time attributes...

$flight = App\Flight::firstOrNew(

['name' => 'Flight 10'],

['delayed' => 1, 'arrival_time' => '11:30']

);

updateOrCreate

Vous pouvez également rencontrer des situations dans lesquelles vous souhaitez mettre à jour un
modèle existant ou créer un nouveau modèle s'il n'en existe aucun. Laravel fournit une
updateOrCreate méthode pour le faire en une étape. Comme la firstOrCreate méthode,

updateOrCreate le modèle persiste, il n’est donc pas nécessaire d’appeler : save()

// If there's a flight from Oakland to San Diego, set the price to $99.

// If no matching model exists, create one.

$flight = App\Flight::updateOrCreate(

['departure' => 'Oakland', 'destination' => 'San Diego'],

['price' => 99, 'discounted' => 1]

);

# Suppression de modèles
Pour supprimer un modèle, appelez la delete méthode sur une instance de modèle:

$flight = App\Flight::find(1);

$flight->delete();

Suppression d'un modèle existant par clé

Dans l'exemple ci-dessus, nous récupérons le modèle de la base de données avant d'appeler la
delete méthode. Toutefois, si vous connaissez la clé primaire du modèle, vous pouvez supprimer le

modèle sans le récupérer en appelant la destroy méthode. En plus d'une clé primaire unique comme
argument, la destroy méthode acceptera plusieurs clés primaires, un tableau de clés primaires ou une
collection de clés primaires:

App\Flight::destroy(1);

App\Flight::destroy(1, 2, 3);

App\Flight::destroy([1, 2, 3]);

App\Flight::destroy(collect([1, 2, 3]));

Suppression de modèles par requête

Vous pouvez également exécuter une instruction delete sur un ensemble de modèles. Dans cet
exemple, nous allons supprimer tous les vols marqués comme inactifs. Comme les mises à jour en
masse, les suppressions en masse ne déclencheront aucun événement de modèle pour les modèles
supprimés:

$deletedRows = App\Flight::where('active', 0)->delete();

Lors de l'exécution d'une instruction de suppression en masse via Eloquent, les événements
deleting et les deleted modèles ne sont pas déclenchés pour les modèles supprimés. En
effet, les modèles ne sont jamais réellement récupérés lors de l'exécution de l'instruction
delete.

Suppression douce
En plus de supprimer les enregistrements de votre base de données, Eloquent peut également
"supprimer en douceur" les modèles. Lorsque les modèles sont supprimés, ils ne sont pas réellement
supprimés de votre base de données. Au lieu de cela, un deleted_at attribut est défini sur le modèle et
inséré dans la base de données. Si un modèle a une deleted_at valeur non NULL , le modèle a été
supprimé manuellement. Pour activer les suppressions douces pour un modèle, utilisez le trait sur le
modèle: Illuminate\Database\Eloquent\SoftDeletes

<?php

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

use Illuminate\Database\Eloquent\SoftDeletes;

class Flight extends Model

use SoftDeletes;

Le SoftDeletes trait transforme automatiquement l' deleted_at attribut en une instance

DateTime / Carbon pour vous.

Vous devez également ajouter la deleted_at colonne à votre table de base de données. Le constructeur
de schéma Laravel contient une méthode d'assistance pour créer cette colonne:

Schema::table('flights', function (Blueprint $table) {

$table->softDeletes();

});

Désormais, lorsque vous appelez la delete méthode sur le modèle, la deleted_at colonne est définie
sur la date et l'heure actuelles. De plus, lorsque vous interrogez un modèle utilisant des suppressions
logicielles, les modèles supprimés seront automatiquement exclus de tous les résultats de la requête.

Pour déterminer si une instance de modèle donnée a été supprimée à l'aide d'un logiciel, utilisez la
trashed méthode suivante:

if ($flight->trashed()) {

//

Interrogation de modèles supprimés progressivement

Y compris les modèles supprimés mous

Comme indiqué ci-dessus, les modèles supprimés sont automatiquement exclus des résultats de la
requête. Cependant, vous pouvez forcer les modèles supprimés à apparaître dans un jeu de résultats à
l'aide de la withTrashed méthode de la requête:
 $flights = App\Flight::withTrashed()

->where('account_id', 1)

->get();

La withTrashed méthode peut également être utilisée sur une requête de relation :

$flight->history()->withTrashed()->get();

Récupération des modèles supprimés uniquement

La onlyTrashed méthode ne récupérera que les modèles supprimés:

$flights = App\Flight::onlyTrashed()

->where('airline_id', 1)

->get();

Restauration de modèles supprimés progressivement

Parfois, vous souhaiterez peut-être "annuler la suppression" d'un modèle supprimé. Pour restaurer un
modèle supprimé logiquement dans un état actif, utilisez la restore méthode sur une instance de
modèle:

$flight->restore();

Vous pouvez également utiliser la restore méthode dans une requête pour restaurer rapidement
plusieurs modèles. De nouveau, comme pour les autres opérations "en masse", cela ne déclenchera
aucun événement de modèle pour les modèles restaurés:

App\Flight::withTrashed()

->where('airline_id', 1)

->restore();

Comme la withTrashed méthode, la restore méthode peut également être utilisée sur des relations :

$flight->history()->restore();

Supprimer définitivement des modèles

Parfois, vous devrez peut-être réellement supprimer un modèle de votre base de données. Pour
supprimer définitivement un modèle supprimé de la base de données, utilisez la forceDelete méthode
 suivante:

// Force deleting a single model instance...

$flight->forceDelete();

// Force deleting all related models...

$flight->history()->forceDelete();

# Portées de la requête

Portées globales
Les étendues globales vous permettent d'ajouter des contraintes à toutes les requêtes pour un modèle
donné. La fonctionnalité de suppression logicielle propre à Laravel utilise des étendues globales pour
extraire uniquement les modèles "non supprimés" de la base de données. L'écriture de vos propres
domaines globaux peut constituer un moyen pratique et simple de s'assurer que chaque requête d'un
modèle donné reçoit certaines contraintes.

Ecriture des champs globaux

Écrire une portée globale est simple. Définissez une classe qui implémente l' interface. Cette interface
vous oblige à mettre en œuvre une méthode: . La méthode peut ajouter des contraintes à la requête
selon les besoins: Illuminate\Database\Eloquent\Scope apply apply where

<?php

namespace App\Scopes;

use Illuminate\Database\Eloquent\Scope;

use Illuminate\Database\Eloquent\Model;

use Illuminate\Database\Eloquent\Builder;

class AgeScope implements Scope

/**

* Apply the scope to a given Eloquent query builder.

* @param \Illuminate\Database\Eloquent\Builder $builder

* @param \Illuminate\Database\Eloquent\Model $model

 * @return void

*/

public function apply(Builder $builder, Model $model)

$builder->where('age', '>', 200);

Si votre portée globale ajoute des colonnes à la clause select de la requête, vous devez utiliser
la addSelect méthode à la place de select . Cela empêchera le remplacement involontaire
de la clause select existante de la requête.

Appliquer des champs globaux

Pour assigner une portée globale à un modèle, vous devez redéfinir la boot méthode d' un modèle
donné et utiliser la addGlobalScope méthode suivante:

<?php

namespace App;

use App\Scopes\AgeScope;

use Illuminate\Database\Eloquent\Model;

class User extends Model

/**

* The "booting" method of the model.

* @return void

*/

protected static function boot()

parent::boot();

static::addGlobalScope(new AgeScope);

Après avoir ajouté l'étendue, une requête produira le code SQL suivant: User::all()
 select * from `users` where `age` > 200

Portées globales anonymes

Eloquent vous permet également de définir des étendues globales à l’aide de Closures, ce qui est
particulièrement utile pour les étendues simples qui ne justifient pas une classe distincte:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

use Illuminate\Database\Eloquent\Builder;

class User extends Model

/**

* The "booting" method of the model.

* @return void

*/

protected static function boot()

parent::boot();

static::addGlobalScope('age', function (Builder $builder) {

$builder->where('age', '>', 200);

});

Supprimer des étendues globales

Si vous souhaitez supprimer une étendue globale pour une requête donnée, vous pouvez utiliser la
withoutGlobalScope méthode. La méthode accepte le nom de classe de la portée globale comme seul

argument:

User::withoutGlobalScope(AgeScope::class)->get();

Ou, si vous avez défini l'étendue globale à l'aide d'une fermeture:

 User::withoutGlobalScope('age')->get();

Si vous souhaitez supprimer plusieurs, voire toutes les étendues globales, vous pouvez utiliser la
withoutGlobalScopes méthode suivante:

// Remove all of the global scopes...

User::withoutGlobalScopes()->get();

// Remove some of the global scopes...

User::withoutGlobalScopes([

FirstScope::class, SecondScope::class

])->get();

Portées locales
Les étendues locales vous permettent de définir des ensembles communs de contraintes que vous
pouvez facilement réutiliser dans votre application. Par exemple, vous devrez peut-être extraire
fréquemment tous les utilisateurs considérés comme "populaires". Pour définir une portée, préfixez une
méthode de modèle Eloquent avec scope .

Les étendues doivent toujours renvoyer une instance de générateur de requête:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model

/**

* Scope a query to only include popular users.

* @param \Illuminate\Database\Eloquent\Builder $query

* @return \Illuminate\Database\Eloquent\Builder

*/

public function scopePopular($query)

return $query->where('votes', '>', 100);

}
 /**

* Scope a query to only include active users.

* @param \Illuminate\Database\Eloquent\Builder $query

* @return \Illuminate\Database\Eloquent\Builder

*/

public function scopeActive($query)

return $query->where('active', 1);

Utiliser une portée locale

Une fois que l'étendue a été définie, vous pouvez appeler les méthodes d'étendue lors de l'interrogation
du modèle. Cependant, vous ne devez pas inclure le scope préfixe lorsque vous appelez la méthode.
Vous pouvez même chaîner des appels à différentes portées, par exemple:

$users = App\User::popular()->active()->orderBy('created_at')->get();

La combinaison de plusieurs portées de modèle Eloquent via un or opérateur de requête peut

nécessiter l’utilisation de rappels de fermeture:

$users = App\User::popular()->orWhere(function (Builder $query) {

$query->active();

})->get();

Cependant, étant donné que cela peut être fastidieux, Laravel fournit une orWhere méthode "d'ordre
supérieur" qui vous permet de chaîner facilement ces étendues sans utiliser de Closures:

$users = App\User::popular()->orWhere->active()->get();

Portées dynamiques
Parfois, vous voudrez peut-être définir une étendue qui accepte les paramètres. Pour commencer,
ajoutez simplement vos paramètres supplémentaires à votre portée. Les paramètres de portée doivent
être définis après le $query paramètre:
 <?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model

/**

* Scope a query to only include users of a given type.

* @param \Illuminate\Database\Eloquent\Builder $query

* @param mixed $type

* @return \Illuminate\Database\Eloquent\Builder

*/

public function scopeOfType($query, $type)

return $query->where('type', $type);

Maintenant, vous pouvez passer les paramètres lorsque vous appelez la portée:

$users = App\User::ofType('admin')->get();

# Comparaison de modèles
Parfois, vous devrez peut-être déterminer si deux modèles sont "identiques". La is méthode peut être
utilisée pour vérifier rapidement que deux modèles ont la même clé primaire, table et connexion à la
base de données:

if ($post->is($anotherPost)) {

//

# Événements
Modèles Eloquent feu plusieurs événements, vous permettant de connecter le du cycle de vie d'un
modèle des points suivants: retrieved , creating , created , updating , updated , saving , saved ,
deleting , deleted , restoring , restored . Les événements vous permettent d'exécuter facilement du

code chaque fois qu'une classe de modèle spécifique est enregistrée ou mise à jour dans la base de
données. Chaque événement reçoit l'instance du modèle via son constructeur.

L' retrieved événement se déclenchera lorsqu'un modèle existant est extrait de la base de données.
Lorsqu'un nouveau modèle est enregistré pour la première fois, les événements creating et created se
déclenchent. Si un modèle existait déjà dans la base de données et que la save méthode est appelée,
les événements updating / updated seront déclenchés. Cependant, dans les deux cas, les événements
saving / saved seront déclenchés.

Lors de la publication d'une mise à jour en masse via Eloquent, les événements saved et
updated modèles ne sont pas déclenchés pour les modèles mis à jour. En effet, les modèles
ne sont jamais réellement récupérés lors de la mise à jour en masse.

Pour commencer, définissez une $dispatchesEvents propriété sur votre modèle Eloquent qui mappe
divers points du cycle de vie du modèle Eloquent avec vos propres classes d'événement :

<?php

namespace App;

use App\Events\UserSaved;

use App\Events\UserDeleted;

use Illuminate\Notifications\Notifiable;

use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable

use Notifiable;

/**

* The event map for the model.

* @var array

*/

protected $dispatchesEvents = [

'saved' => UserSaved::class,

'deleted' => UserDeleted::class,

 ];

Après avoir défini et mappé vos événements Eloquent, vous pouvez utiliser des écouteurs d’événements
pour gérer les événements.

Observateurs

Définir les observateurs

Si vous écoutez de nombreux événements sur un modèle donné, vous pouvez utiliser des observateurs
pour regrouper tous vos auditeurs dans une même classe. Les classes d'observateurs ont des noms de
méthodes qui reflètent les événements Eloquent que vous souhaitez écouter. Chacune de ces méthodes
reçoit le modèle comme seul argument. La commande Artisan est le moyen le plus simple de créer une
nouvelle classe d'observateur: make:observer

php artisan make:observer UserObserver --model=User

Cette commande placera le nouvel observateur dans votre répertoire. Si ce répertoire n'existe pas,
Artisan le créera pour vous. Votre nouvel observateur ressemblera à ceci: App/Observers

<?php

namespace App\Observers;

use App\User;

class UserObserver

/**

* Handle the User "created" event.

* @param \App\User $user

* @return void

*/

public function created(User $user)

//

}
 /**

* Handle the User "updated" event.

* @param \App\User $user

* @return void

*/

public function updated(User $user)

//

/**

* Handle the User "deleted" event.

* @param \App\User $user

* @return void

*/

public function deleted(User $user)

//

To register an observer, use the observe method on the model you wish to observe. You may register
observers in the boot method of one of your service providers. In this example, we'll register the
observer in the AppServiceProvider :

<?php

namespace App\Providers;

use App\User;

use App\Observers\UserObserver;

use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider

/**

* Bootstrap any application services.

* @return void
 */

public function boot()

User::observe(UserObserver::class);

/**

* Register the service provider.

* @return void

*/

public function register()

//

L A R A V E L I S A T R A D E M A R K O F T AY L O R O T W E L L . C O P Y R I G H T © T AY L O R O T W E L L .

DESIGNED BY