1-getting Started.pdf

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:


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:


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 :


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:


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:


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é:


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:


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:


$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:


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:


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:


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


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


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

* @param

\Illuminate\Database\Eloquent\Model

$builder $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:


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:


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:


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:


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 :


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


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 :


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