Laravel (5.7) Eloquent: начало работы

Последнее обновление 30 июля 2019 г. 08:10:25 (UTC / GMT +8 часов)

script1adsense2code

script1adsense3code

Вступление

Laravel Eloquent ORM предоставляет красивую и простую реализацию ActiveRecord для работы с нашей базой данных. Каждая таблица базы данных в приложении Laravel имеет соответствующую «Модель». Эта модель используется для взаимодействия с таблицей. Модели позволяют нам либо запрашивать данные в таблице, либо вставлять новые записи в таблицу.

Для работы с eloquent ORM первое, что вы должны сделать, это настроить соединение с базой данных в вашем config / database.php.

Определение моделей

Итак, как мы начнем с Model, мы начнем с ее создания. Модели обычно находятся в каталоге приложения, но вы можете разместить их в любом месте, которое может быть автоматически загружено в соответствии с файлом composer.json. Все модели Eloquent, которые вы напишете в Laravel, расширят классlightateDatabaseEloquentModel.

Самый простой способ создать экземпляр модели - использовать команду make: model artisan:

php artisan make:model Flight

В случае, если вы хотите создать миграцию базы данных одновременно с генерацией модели, вы можете использовать опцию -migration или -m:

php artisan make:model Flight --migration
php artisan make:model Flight -m

Красноречивые модельные соглашения

Давайте рассмотрим создание модели полета, мы будем использовать эту модель для хранения и извлечения информации из нашей таблицы базы данных рейсов:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Flight extends Model
{
    //
}

Имена таблиц

Обратите внимание, что мы не сообщили Eloquent, какую таблицу использовать для нашей модели Flight. Как правило, в качестве имени таблицы используется «случай змеи», то есть множественное имя класса, если другое имя не указано явно. Так что в нашем случае Eloquent будет предполагать, что модель Flight хранит записи в таблице рейсов. Однако вы можете указать пользовательскую таблицу, определив свойство таблицы в вашей модели:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Flight extends Model
{
    /**
     * The table associated with the model.
     *
     * @var string
     */
    protected $table ='my_flights';
}

Основные ключи

Столбец id всегда будет использоваться Eloquent в качестве столбца первичного ключа. Вы можете определить защищенное свойство $ primaryKey, чтобы переопределить это соглашение:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Flight extends Model
{
    /**
     * The primary key associated with the table.
     *
     * @var string
     */
    protected $primaryKey ='flight_id';
}

Кроме того, Eloquent будет предполагать, что первичный ключ является возрастающим целочисленным значением, это означает, что по умолчанию первичный ключ будет автоматически преобразован в int. если вы хотите использовать нечисловой или неинкрементный первичный ключ, вы должны установить для открытого свойства $ incrementing в вашей модели значение false.

<?php
class Flight extends Model
{
    /**
     * Indicates if the IDs are auto-incrementing.
     *
     * @var bool
     */
    public $incrementing = false;
}

В случае, когда ваш первичный ключ не является целым числом, для защищенного свойства $ keyType вашей модели должно быть установлено значение string:

<?php
class Flight extends Model
{
    /**
     * The "type" of the auto-incrementing ID.
     *
     * @var string
     */
    protected $keyType ='string';
}

Timestamps

Eloquent ожидает, что по умолчанию в вашей таблице будут присутствовать столбцы create_at и updated_at. Если вы не хотите, чтобы Eloquent автоматически управлял этими столбцами, вам следует установить для свойства $ timestamp в вашей модели значение 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;
}

Если вы хотите настроить формат вашей метки времени, вам следует установить свойство $ dateFormat для вашей модели. Это свойство будет определять способ хранения атрибутов даты в базе данных, а также их формат при сериализации модели в 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';
}

Если вам нужно настроить имена столбцов, используемых для хранения меток времени, вы можете установить константы CREATED_AT и UPDATED_AT для модели:

<?php
class Flight extends Model
{
    const CREATED_AT ='creation_date';
    const UPDATED_AT ='last_update';
}

Подключение к базе данных

Поведение по умолчанию всех моделей Eloquent заключается в использовании подключения к базе данных по умолчанию, настроенного для вашего приложения. Если вы предпочитаете указать другое соединение для модели, вы должны использовать свойство $ connection:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Flight extends Model
{
    /**
     * The connection name for the model.
     *
     * @var string
     */
    protected $connection ='connection-name';
}

Значения атрибутов по умолчанию

В случае, если вы хотите определить значения по умолчанию для купола атрибутов вашей модели, вы должны определить свойство $ attribute для вашей модели:

<?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,
    ];
}

Получение моделей

Когда модель создана и связана с таблицей базы данных, вы готовы начать извлечение данных из базы данных. Каждую модель Eloquent можно рассматривать как мощный построитель запросов, который позволяет свободно запрашивать таблицу базы данных, связанную с моделью. Например:

<?php
$flights = App\Flight::all();
foreach ($flights as $flight) {
    echo $flight->name;
}

Добавление дополнительных ограничений

Метод Eloquent all возвращает все результаты в таблице модели. Поскольку каждая модель служит построителем запросов, к запросам также можно добавлять ограничения, а затем использовать метод get для получения результатов:

$flights = App\Flight::where('active', 1)
               ->orderBy('name', 'desc')
               ->take(10)
               ->get();

Обновление моделей

Мы можем использовать методы fresh и refresh для обновления наших моделей, метод fresh будет повторно извлекать модель из нашей базы данных. Это не повлияет на существующий экземпляр модели:

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

Метод обновления, с другой стороны, повторно гидратирует существующую модель, используя свежие данные из базы данных. Кроме того, все загруженные отношения возвращаемых данных также будут обновлены:

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

Коллекции

Для таких красноречивых методов, как all и get, которые получают несколько результатов, будет возвращен экземпляр IlluminateDatabaseEloquentCollection. Класс коллекции предоставит множество полезных методов для работы с результатами Eloquent:

$flights = $flights->reject(function ($flight) {
    return $flight->cancelled;
});

Вы также можете перебрать коллекцию как массив:

```foreach ($flights as $flight) {
    echo $flight->name;
}

Результаты Chunking

В случаях, когда вам нужно обработать тысячи записей Eloquent, вы должны использовать команду chunk. Этот метод порции извлекает «порцию» моделей Eloquent и передает их в данное замыкание для обработки. Использование метода chunk поможет вам сэкономить память при работе с большими наборами результатов:

Flight::chunk(200, function ($flights) {
    foreach ($flights as $flight) {
        //
    }
});

Первым аргументом, передаваемым методу, является количество записей, которые вы хотите получить за «порцию». Закрытие, переданное в качестве второго аргумента, будет вызываться для каждого чанка, полученного из базы данных. Будет выполнен запрос к базе данных для извлечения каждого куска записей, переданных в Closure.

Использование курсоров

Метод курсора позволит вам перебирать записи вашей базы данных с помощью курсора, он будет выполнять только один запрос. При обработке большого количества данных можно использовать метод курсора, чтобы значительно сократить использование памяти:

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

Получение одиночных моделей / агрегатов

Помимо извлечения всех записей для данной таблицы, вы также можете извлечь отдельные записи, используя find или first. Вместо того, чтобы возвращать коллекцию моделей, эти методы будут возвращать один экземпляр модели:

// Retrieving a model by its primary key...
$flight = App\Flight::find(1);
```// Retrieving the first model matching the query constraints...
$flight = App\Flight::where('active', 1)->first();

Вы также можете вызвать метод find с массивом первичных ключей, который вернет коллекцию соответствующих записей:

$ flight = AppFlight :: find ([1, 2, 3]);

Не найдено исключений

Иногда вы можете создать исключение, если модель не найдена. Это полезно в маршрутах или контроллерах. Методы findOrFail и firstOrFail извлекают первый результат запроса; однако, если результат не найден, будет выдано исключение IlluminateDatabaseEloquentModelNotFoundException:

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

Если вы не поймете исключение, ответ 404 HTTP будет автоматически отправлен обратно пользователю. Нет необходимости писать явные проверки для возврата 404 ответов при использовании этих методов:

Route::get('/api/flights/{id}', function ($id) {
    return App\Flight::findOrFail($id);
});

Получение агрегатов

Вы также можете использовать методы count, sum, max и другие агрегатные методы, предоставляемые построителем запросов. Эти методы будут возвращать соответствующее скалярное значение вместо полного экземпляра модели:

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

Вставка и обновление моделей

Вставки

Когда вы хотите создать новую запись в базе данных, вы должны создать экземпляр модели, установить атрибуты для модели и затем вызвать метод save:

<?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();
    }
}

В приведенном выше примере мы присвоили параметр name из входящего HTTP-запроса атрибуту name экземпляра модели AppFlight. При вызове метода сохранения новая запись будет вставлена в базу данных. Отметки времени созданного и обновленного времени автоматически устанавливаются при вызове метода сохранения, поэтому нам не нужно устанавливать их вручную.

Обновления

Метод сохранения также можно использовать для обновления моделей, которые уже существуют в базе данных. Когда вы хотите обновить модель, первое, что нужно сделать, это извлечь ее, затем установить любые атрибуты, которые вы хотите обновить, и, наконец, вы можете вызвать метод save. Нет необходимости устанавливать updated_at вручную, так как он будет обновляться автоматически:

$flight = App\Flight::find(1);
$flight->name ='New Flight Name';
$flight->save(); >

Массовые обновления

Вы также можете выполнять обновления для любого количества моделей, соответствующих данному запросу. В приведенном ниже примере все активные рейсы, которые также имеют пункт назначения Сан-Диего, будут помечены как задержанные:

App\Flight::where('active', 1)
          ->where('destination', 'San Diego')
          ->update(['delayed' => 1]);

Метод update ожидает массив пар столбцов и значений, представляющих столбец, который должен быть обновлен.

Массовое задание

Вы также можете использовать метод create, чтобы сохранить новую модель в одну строку. Вставленный экземпляр модели возвращается вам из метода. Но прежде чем сделать это, вы должны сначала указать в модели атрибут fillable или guard, поскольку все модели Eloquent по умолчанию защищают от массового назначения.

Уязвимость массового назначения возникает, когда пользователь передает неожиданный параметр HTTP через запрос, и этот параметр вносит изменения в столбец в вашей базе данных, который вы не ожидали. Например, очень злонамеренный пользователь может отправить параметр is_admin через HTTP-запрос, который затем будет передан в метод создания вашей модели, позволяющий пользователю повысить свои привилегии до уровня администратора.

Итак, для начала вы должны определить, какие атрибуты модели вы хотите сделать массовыми назначаемыми. Вы можете сделать это, используя свойство $ fillable в модели. Например, давайте сделаем присваиваемым атрибут имени нашей модели модели полета:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Flight extends Model
{
    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = ['name'];
}

когда мы назначаем атрибуты массово, мы можем использовать метод create для вставки новой записи в базу данных. Метод create вернет сохраненный экземпляр модели:

$flight = App\Flight::create(['name' => 'Flight 10']);
If you already have a model instance, you can use the fill method to populate it with an array of attributes:
```$flight->fill(['name' => 'Flight 22']);

Атрибуты охраны

Хотя свойство $ fillable служит «белым списком» атрибутов, которые должны быть массово назначаемыми, вы также можете выбрать использование $ guarded. Свойство $ guarded должно содержать массив атрибутов, которые вы не хотите массово назначать. Все остальные атрибуты, отсутствующие в массиве, будут массово назначаться. Таким образом, $ guarded будет функционировать как «черный список». Важно отметить, что вы можете использовать либо $ fillable, либо $ guarded - но не оба. В примере, показанном ниже, все атрибуты, кроме цены, будут назначаться по массе:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Flight extends Model
{
    /**
     * The attributes that aren't mass assignable.
     *
     * @var array
     */
    protected $guarded = ['price'];
}

В сценариях, когда вы хотите сделать все атрибуты массово назначаемыми, вы можете определить свойство $ guarded как пустой массив:

/**
 * The attributes that are not mass assignable.
 *
 * @var array
 */
protected $guarded = [];

Другие методы создания

firstOrCreate / firstOrNew

Есть два других метода, которые вы можете использовать для создания моделей путем массового присвоения атрибутов: firstOrCreate и firstOrNew. Метод firstOrCreate пытается найти запись базы данных, используя заданные пары столбец / значение. Если модель не может быть найдена в базе данных, вставляется запись с атрибутами из первого параметра, а также с атрибутами во втором необязательном параметре.

Так же, как firstOrCreate, метод firstOrNew пытается найти запись в базе данных, соответствующую заданным атрибутам. Однако, если модель не видна, возвращается новый экземпляр модели. Обратите внимание, что модель, возвращаемая firstOrNew, еще не сохранена в базе данных. Вам нужно вызвать save вручную, чтобы сохранить его:

// this line will retrieve flight by name, or create it in the case it doesn't exist...
$flight = App\Flight::firstOrCreate(['name' => 'Flight 10']);
// this will 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

Существуют ситуации, когда вы хотите обновить существующую модель или создать новую модель, если ее нет. Laravel предоставляет нам метод updateOrCreate, чтобы сделать это за один шаг. Как и метод firstOrCreate, updateOrCreate сохранит модель, поэтому нет необходимости вызывать 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]
);

Удаление моделей

Если вы хотите удалить модель, вы можете вызвать метод delete для экземпляра модели:

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

Удаление существующей модели по ключу

В приведенном выше примере мы извлекаем модель из базы данных перед вызовом метода delete. Однако, если мы знаем первичный ключ модели, мы можем удалить модель, не извлекая ее, вызвав метод destroy. В дополнение к одному первичному ключу в качестве аргумента метод destroy принимает несколько первичных ключей, коллекцию первичных ключей или массив первичных ключей:

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

Удаление моделей по запросу .

Вы также можете запустить оператор удаления для набора моделей. В приведенном ниже примере мы удаляем все рейсы, помеченные как неактивные. Как и в случае массовых обновлений, при массовом удалении не будут запускаться события модели для удаляемых моделей:

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

Мягкое удаление

В отличие от фактического удаления записей из вашей базы данных, Eloquent также может выполнять «мягкое удаление» на моделях. Когда мы мягко удаляем модели, модели фактически не удаляются из вашей базы данных. Вместо этого мы устанавливаем атрибут delete_at для модели, и этот столбец вставляется в базу данных. Если модель имеет ненулевое значение delete_at, модель была удалена мягко. Чтобы включить мягкое удаление в модели, вы должны использовать черту IlluminateDatabaseEloquentSoftDeletes для модели:

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
class Flight extends Model
{
    use SoftDeletes;
}

Кроме того, вам нужно добавить столбец delete_at в таблицу базы данных. Компоновщик схемы Laravel содержит вспомогательный метод для создания столбца delete_at:

Schema::table('flights', function (Blueprint $table) {
    $table->softDeletes();
});

Теперь, когда метод удаления вызывается для модели, в столбце delete_at будут установлены текущие время и дата. И когда мы запрашиваем модель, которая использует мягкое удаление, мягко удаленные модели будут автоматически исключены из всех результатов запроса.

Чтобы узнать, был ли данный экземпляр модели удален, вы должны использовать метод trashed:

```if ($flight->trashed()) {
    //
}

Запрос мягких удаленных моделей

Включая мягко удаленные модели

Как было отмечено выше, все удаленные модели будут автоматически исключены из результатов запроса. Однако можно принудительно отобразить удаленные модели в наборе результатов, используя метод withTrashed в запросе:

$flights = App\Flight::withTrashed()
                ->where('account_id', 1)
                ->get();

Метод withTrashed также можно использовать в запросе отношения:

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

Получение только мягко удаленных моделей

Метод onlyTrashed извлекает только программно удаленные модели:

$flights = App\Flight::onlyTrashed()
                ->where('airline_id', 1)
                ->get();

Восстановление мягко удаленных моделей

Есть моменты, когда вы можете «удалить» мягко удаленную модель. Чтобы вернуть мягко удаленную модель обратно в активное состояние, вы должны использовать метод восстановления в экземпляре модели:

$flight->restore();

Вы также можете использовать метод восстановления в запросе, чтобы быстро восстановить несколько моделей. И, как и другие «массовые» операции, это не вызовет никаких событий модели для восстанавливаемых моделей:

App\Flight::withTrashed()
        ->where('airline_id', 1)
        ->restore();

Как и метод withTrashed, метод восстановления также может использоваться для отношений:

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

Удаление моделей без возможности восстановления

Есть моменты, когда вам нужно действительно удалить модель из вашей базы данных. Чтобы окончательно удалить мягко удаленную модель из базы данных, используйте метод forceDelete:

// Force deleting a single model instance...
$flight->forceDelete();
// Force deleting all related models...
$flight->history()->forceDelete();

Области запросов

Global Scopes

Глобальные области действия позволят нам добавить ограничения ко всем запросам для данной модели. Собственная функциональность мягкого удаления Laravel использует глобальные области действия, чтобы извлекать только «не удаленные» модели из базы данных. Написание собственных глобальных областей может предоставить удобный и простой способ убедиться, что каждый запрос для данной модели получает определенные ограничения.

Написание глобальных областей

Написание глобальной области довольно просто. Сначала определите класс, который реализует интерфейс IlluminateDatabaseEloquentScope. Этот интерфейс требует от нас реализации одного метода: применить. Метод apply добавляет необходимые ограничения к запросу:

<?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);
    }
}

Применение глобальных областей

Когда нам нужно назначить глобальную область видимости модели, мы должны переопределить метод загрузки данной модели и использовать метод addGlobalScope:

<?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);
    }
}

После того как мы добавим область, запрос к User :: all () создаст следующий оператор SQL:

select * from `users` where `age` > 200

Анонимные Глобальные Области

Eloquent также позволит вам определять глобальные области действия с помощью Closures, это особенно полезно для простых областей, которые не требуют отдельного класса:

<?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);
        });
    }
}

Удаление глобальных областей

Если вы хотите удалить глобальную область для данного запроса, вы можете использовать метод безGlobalScope. Этот метод принимает имя класса глобальной области видимости в качестве единственного аргумента:

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

Или, если вы определили глобальную область с помощью Closure:

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

Если вы хотите удалить несколько или даже все глобальные области, вы можете использовать метод безGlobalScopes:

// Remove all of the global scopes...
User::withoutGlobalScopes()->get();
// Remove some of the global scopes...
User::withoutGlobalScopes([
    FirstScope::class, SecondScope::class
])->get();

Местные возможности

Локальные области позволяют нам определять общие наборы ограничений, которые мы можем легко повторно использовать в вашем приложении. Например, нам может понадобиться часто получать всех пользователей, которые считаются «популярными». Определить область видимости просто, просто добавьте метод модели Eloquent к области видимости.

Все области должны всегда возвращать экземпляр построителя запросов:

<?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);
    }
}

Использование локальной области

После определения области вы можете вызывать методы области при запросе модели. Однако вы не должны включать префикс области при вызове этого метода. Вы можете объединять вызовы в различные области, например:

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

Объединение нескольких областей Eloquent модели с использованием оператора или запроса может потребовать использования обратных вызовов Closure:

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

Но, поскольку Laravel знает, что это может быть громоздким, Laravel предоставляет метод «более высокого порядка» или «Где», который позволит вам свободно объединять эти области вместе без использования Closures:

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

Динамические Области

Есть моменты, когда вы можете захотеть определить область, которая принимает параметры. Чтобы начать с этим, вам просто нужно добавить дополнительные параметры в вашу область. Параметры области должны быть определены после параметра $ query:

<?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);
    }
}

Теперь вы можете передать параметры при вызове области:

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

Сравнение моделей

Иногда вам может потребоваться определить, являются ли две модели «одинаковыми». Метод is можно использовать для быстрой проверки того, что две модели имеют одинаковый первичный ключ, таблицу и соединение с базой данных:

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

События

Eloquent модели могут запускать несколько событий, что позволяет нам подключиться к следующим точкам в жизненном цикле модели: извлекать, создавать, создавать, обновлять, обновлять, сохранять, сохранять, удалять, удалять, восстанавливать, восстанавливать. События позволяют нам легко выполнять код каждый раз, когда определенный класс модели сохраняется или обновляется в базе данных. Каждое событие получит экземпляр модели через своего конструктора.

Полученное событие возникает, когда существующая модель извлекается из базы данных. Каждый раз, когда новая модель сохраняется в первый раз, оба события будут созданы и созданы. Если модель уже существует в базе данных, а затем вызывается метод сохранения, то запускаются события обновления / обновления. Однако в обоих сценариях события сохранения / сохранения будут срабатывать.

Для начала, определите свойство $ dispatchesEvents в нашей модели Eloquent, которое отображает различные точки жизненного цикла модели Eloquent в наши собственные классы событий:

<?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,
    ];
}

После определения и сопоставления наших событий Eloquent мы можем использовать прослушиватели событий для обработки событий.

Наблюдатели

Определение наблюдателей

В случаях, когда мы слушаем много событий в данной модели, мы можем использовать наблюдателей, чтобы сгруппировать всех наших слушателей в один класс. Классы наблюдателей имеют имена методов, которые отражают события Eloquent, которые мы хотим прослушивать. Каждый из этих методов получит модель в качестве единственного аргумента. Команда make: наблюдатель Artisan - это самый простой способ создать новый класс наблюдателей:

php artisan make:observer UserObserver --model=User

Эта команда поместит нового наблюдателя в наш каталог App / Observers. Если этот каталог не существует, Artisan создаст его для нас. Наш новый наблюдатель будет выглядеть следующим образом:

<?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)
    {
        //
    }
}

Если мы хотим зарегистрировать наблюдателя, мы будем использовать метод наблюдения на модели, которую мы хотим наблюдать. Мы можем зарегистрировать наблюдателей в методе загрузки одного из наших поставщиков услуг. В этом случае мы зарегистрируем наблюдателя в AppServiceProvider:

<?php
namespace App\Providers;
use App\User;
use App\Observers\UserObserver;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        User::observe(UserObserver::class);
    }
}