updateOrCreate

Es kann auch vorkommen, dass Sie ein vorhandenes Modell aktualisieren oder ein neues Modell erstellen möchten, wenn es nicht vorhanden ist. Laravel bietet die updateOrCreate-Methode, um dies in nur einem Schritt zu erreichen. Wie die firstOrCreate-Methode stimmt updateOrCreate mit dem entsprechenden Modell überein, daher besteht keine Notwendigkeit, die save()-Methode aufzurufen:

// 如果有从奥克兰到圣地亚哥的航班，则价格定为99美元。
// 如果没匹配到存在的模型，则创建一个。
$flight = App\Flight::updateOrCreate( 
   ['departure' => 'Oakland', 'destination' => 'San Diego'],    
   ['price' => 99]
 );

Modell löschen

kann für Modellinstanzen aufgerufen werdendelete Methode zum Löschen von Instanzen:

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

Modell nach Primärschlüssel löschen

Im obigen Beispiel müssen Sie das entsprechende Modell in der Datenbank finden, bevor Sie delete aufrufen. Wenn Sie den Primärschlüssel des Modells kennen, können Sie das Modell tatsächlich direkt mit der Methode destroy löschen, ohne es zuerst in der Datenbank nachzuschlagen. Zusätzlich zum Akzeptieren eines einzelnen Primärschlüssels als Parameter akzeptiert die destroy-Methode auch mehrere Primärschlüssel oder verwendet Arrays und Sammlungen, um mehrere Primärschlüssel zu speichern:

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

Modell löschen durch Abfrage

Sie können auch Löschanweisungen für das Modell ausführen. In diesem Beispiel löschen wir alle als inaktiv markierten Flüge. Wie bei der Stapelaktualisierung löst auch die Stapellöschung keine Modellereignisse für das gelöschte Modell aus:

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

{note} Wenn die Stapellöschanweisung über Eloquent ausgeführt wird, werden die Modelle deleting und deleted nicht ausgeführt Ereignis ausgelöst werden. Daher werden die Modellbeispiele beim Ausführen einer Löschanweisung nie abgerufen.

Vorläufiges Löschen

Zusätzlich zum tatsächlichen Löschen von Datenbankeinträgen kann Eloquent auch „vorläufig löschen“ das Modell. Ein vorläufig gelöschtes Modell wird nicht tatsächlich aus der Datenbank gelöscht. Tatsächlich wird das Attribut deleted_at im Modell festgelegt und sein Wert in die Datenbank geschrieben. Wenn der Wert deleted_at nicht leer ist, bedeutet dies, dass dieses Modell vorläufig gelöscht wurde. Wenn Sie die Funktion zum vorläufigen Löschen des Modells aktivieren möchten, müssen Sie das Merkmal IlluminateDatabaseEloquentSoftDeletes für das Modell verwenden:

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

{tip} Das Merkmal SoftDeletes konvertiert automatisch das Attribut deleted_at in DateTime / Carbon Beispiel

Natürlich müssen Sie deleted_at einfügen Felder werden zur Datentabelle hinzugefügt. Die Datenbankmigration von Laravel verfügt über eine Methode zum Erstellen dieses Felds:

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

Wenn Sie nun die Methode delete für die Modellinstanz verwenden, werden das aktuelle Datum und die aktuelle Uhrzeit in das Feld deleted_at geschrieben. Gleichzeitig werden in den Abfrageergebnissen automatisch vorläufig gelöschte Datensätze ausgeschlossen.

Sie können die Methode trashed verwenden, um zu überprüfen, ob das aktuelle Modell vorläufig gelöscht wurde:

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

Abfrage das weich gelöschte Modell

Vorläufig gelöschte Modelle einbeziehen

Wie bereits erwähnt, schließen die Abfrageergebnisse automatisch vorläufig gelöschte Ergebnisse aus. Natürlich können Sie die Methode withTrashed verwenden, um Modelle einschließlich vorläufig gelöschter Modelle abzurufen:

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

withTrashed Die Methode kann auch in verwandten Abfragen verwendet werden:

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

Vorläufig gelöschtes Modell abrufen

onlyTrashed Methode NurVorläufig gelöschte Modelle abrufen:

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

Vorläufig gelöschte Modelle wiederherstellen

Manchmal werden vorläufig gelöschte Modelle „rückgängig gemacht“ Verwenden Sie restore auf vorläufig gelöschte Daten Methode zum Wiederherstellen eines gültigen Zustands:

$flight->restore();

Sie können die Methode restore auch in einer Abfrage verwenden, um mehrere Modelle schnell wiederherzustellen. Wie andere Batch-Operationen löst diese Operation keine Ereignisse im Modell aus:

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

Ähnlich wie die Methode withTrashed wird auch die Methode restore in Assoziationen verwendet:

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

Endgültiges Löschen

Wenn Sie Daten tatsächlich löschen möchten, verwenden Sie forceDelete Die Methode ist:

// 单个模型实例的永久删除...
$flight->forceDelete();
// 关联模型的永久删除...
$flight->history()->forceDelete();

Abfragebereich

Globaler Bereich

Der globale Bereich kann Einschränkungen zu Modellabfragen hinzufügen. Die Soft-Delete-Funktion von Laravel nutzt diese Funktion, um „nicht gelöschte“ Modelle aus der Datenbank abzurufen. Sie können ganz einfach und bequem Ihren eigenen globalen Bereich schreiben und jeder Modellabfrage Einschränkungen hinzufügen:

Globalen Bereich schreiben

Globalen Bereich schreiben Der Bereich ist einfach. Definieren Sie eine Klasse, die die IlluminateDatabaseEloquentScope-Schnittstelle implementiert, und implementieren Sie die apply-Methode. Fügen Sie je nach Bedarf die apply-Bedingung der Abfrage in der where-Methode hinzu:

<?php
    namespace App\Scopes;
    use Illuminate\Database\Eloquent\Scope;
    use Illuminate\Database\Eloquent\Model;
    use Illuminate\Database\Eloquent\Builder;
    class AgeScope implements Scope{  
      /**
     * 把约束加到 Eloquent 查询构造中。
     *
     * @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);   
         }
      }

{tip} Wenn Sie Felder in der Select-Anweisung hinzufügen müssen, sollten Sie die addSelectMethode statt selectMethode. Dadurch wird effektiv verhindert, dass vorhandene Select-Anweisungen versehentlich ersetzt werden.

Globalen Geltungsbereich anwenden

Um einem Modell einen globalen Geltungsbereich zuzuweisen, müssen Sie die boot-Methode des Modells überschreiben und die addGlobalScope-Methode verwenden : Nachdem

<?php
    namespace App;use App\Scopes\AgeScope;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{  
      /**
     *  模型的 「启动」 方法.
     *
     * @return void
     */  
     protected static function boot()  
       {     
          parent::boot();        
          static::addGlobalScope(new AgeScope);  
        }
   }

den Bereich hinzugefügt hat, generiert die Abfrage für User::all() das folgende SQL Abfrageanweisung:

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

Anonymer globaler Bereich

Eloquent ermöglicht auch die Verwendung von Abschlüssen zum Definieren globaler Bereiche, sodass kein einfacher Bereich geschrieben werden muss. Einzelne Klassen:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    use Illuminate\Database\Eloquent\Builder;
    class User extends Model{  
      /**
     *模型的「启动」方法.
     *
     * @return void
     */  
     protected static function boot()   
      {      
        parent::boot();        
        static::addGlobalScope('age', function (Builder $builder) {  
                  $builder->where('age', '>', 200);       
                }); 
       }
   }

Globalen Bereich aufheben

Wenn Sie den globalen Bereich für die aktuelle Abfrage aufheben müssen, müssen Sie die Methode withoutGlobalScope verwenden. Diese Methode akzeptiert nur den Klassennamen des globalen Bereichs als einzigen Parameter:

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

Oder, wenn ein Abschluss zum Definieren des globalen Bereichs verwendet wird:

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

Wenn Sie einen Teil oder alles abbrechen müssen Für den globalen Bereich müssen Sie withoutGlobalScopes verwenden Methode:

// 取消所有的全局作用域...
User::withoutGlobalScopes()->get();
// 取消部分全局作用域...
User::withoutGlobalScopes([ 
   FirstScope::class, SecondScope::class
 ])->get();

Lokaler Bereich

Der lokale Bereich ermöglicht die Definition eines gemeinsamen Satzes von Einschränkungen für die Verwendung in der Anwendung Wiederverwendung. Beispielsweise müssen Sie häufig alle „beliebten“ Benutzer erfassen. Um einen solchen Bereich zu definieren, fügen Sie einfach das Präfix scope vor der entsprechenden Eloquent-Modellmethode hinzu:

Scope gibt immer eine Abfrage-Builder-Instanz zurück:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{  
      /**
     * 只查询受欢迎的用户的作用域.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */   
      public function scopePopular($query)  
        {      
          return $query->where('votes', '>', 100);   
        }    
     /**
     * 只查询 active 用户的作用域.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */  
      public function scopeActive($query)  
        {      
          return $query->where('active', 1);  
         }
      }

Verwendung lokaler Bereiche

Sobald ein Bereich definiert ist, können Bereichsmethoden aufgerufen werden, wenn dieses Modell abgefragt wird. Es ist jedoch nicht erforderlich, beim Aufruf dieser Methoden das Präfix scope anzugeben. Sie können sogar Aufrufe an mehrere Bereiche verketten, zum Beispiel:

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

Verwenden Sie den or Abfrageläufer, um mehrere Eloquent-Modelle zu integrieren. Möglicherweise müssen Sie Abschlussrückrufe verwenden:

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

, da dies der Fall sein kann Es ist etwas mühsam, Laravel bietet „High-Level“ orWhere Methode, mit der Sie Aufrufbereiche verketten können, ohne Abschlüsse zu verwenden:

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

Dynamic Scope

Manchmal kann es wünschenswert sein, eine Rolle zu definieren, die Argumentdomänen akzeptiert. Dies kann durch die Übergabe zusätzlicher Parameter an den Bereich erreicht werden. Bereichsparameter sollten in $query platziert werden Nach den Parametern:

<?php
    namespace App;
    use Illuminate\Database\Eloquent\Model;
    class User extends Model{   
     /**
     * 将查询作用域限制为仅包含给定类型的用户。
     *
     * @param  \Illuminate\Database\Eloquent\Builder $query
     * @param  mixed $type
     * @return \Illuminate\Database\Eloquent\Builder
     */   
    public function scopeOfType($query, $type)  
      {      
        return $query->where('type', $type);   
       }
      }

Auf diese Weise können Sie beim Aufruf des Scopes die Parameter übergeben:

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

Modellvergleich

Manchmal müssen Sie möglicherweise feststellen, ob zwei Modelle „gleich“ sind. Mit der is-Methode kann schnell überprüft werden, ob zwei Modelle dieselben Primärschlüssel, Tabellen und Datenbankverbindungen haben:

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

Ereignisse

Eloquente Modelle lösen mehrere Ereignisse aus, sodass Sie sich in die folgenden Knoten des Modelllebenszyklus einbinden können: retrieved, creating, created, updating, updated, saving, saved, deleting, deleted, restoring und restored. Mithilfe von Ereignissen können Sie Code immer dann ausführen, wenn ein bestimmtes Modell in der Datenbank gespeichert oder aktualisiert wird. Jedes Ereignis akzeptiert eine Modellinstanz über seinen Konstruktor. Das Ereignis

retrieved wird ausgelöst, wenn ein vorhandenes Modell Daten aus der Datenbank nachschlägt. Jedes Mal, wenn ein neues Modell gespeichert wird, werden die Ereignisse creating und created ausgelöst. Wenn das Modell bereits in der Datenbank vorhanden ist und die Methode save aufgerufen wird, werden die Ereignisse updating / updated ausgelöst. In diesen Fällen werden auch die Ereignisse saving / saved ausgelöst.

{note} Bei der Durchführung von Stapelaktualisierungen über Eloquent werden die Ereignisse saved und updated des aktualisierten Modells nicht ausgelöst. Dies liegt daran, dass das Modell während der Batch-Aktualisierung nicht tatsächlich abgerufen wird.

Definieren Sie zunächst ein $dispatchesEvents-Attribut für das Eloquent-Modell, um mehrere Knoten des Eloquent-Modelllebenszyklus Ihrer eigenen Ereignisklasse zuzuordnen:

<?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;   
       /**
     * 为模型事件。
     *
     * @var array
     */ 
      protected $dispatchesEvents = [    
          'saved' => UserSaved::class,        
          'deleted' => UserDeleted::class,   
           ];
       }

definiert Eloquent-Ereignisse und ordnet sie zu können Sie Ereignis-Listener verwenden, um diese Ereignisse zu verarbeiten.

Beobachter

Beobachter definieren

Wenn in einem Es gibt Mehrere Ereignisse werden im Modell abgehört, und Beobachter können verwendet werden, um diese Zuhörer in einer separaten Klasse zu organisieren. Die Methodennamen der Beobachterklasse sind den Eloquent-Ereignissen zugeordnet, die Sie abhören möchten. Diese Methoden verwenden alle das Modell als einzigen Parameter. make:observer Der Artisan-Befehl kann schnell eine neue Beobachterklasse erstellen:

php artisan make:observer UserObserver --model=User

Dieser Befehl platziert eine neue Beobachterklasse im Ordner App/Observers. Wenn dieses Verzeichnis nicht existiert, wird Artisan es für Sie erstellen. Verwenden Sie die folgende Methode, um Beobachter zu aktivieren:

<?php
    namespace App\Observers;
    use App\User;
    class UserObserver{   
     /**
     * 处理 User 「新建」事件。
     *
     * @param  \App\User  $user
     * @return void
     */   
      public function created(User $user) 
         {      
           //  
          }   
     /**
     * 处理 User 「更新」 事件。
     *
     * @param  \App\User  $user
     * @return void
     */   
      public function updated(User $user)  
        {      
          //   
         }   
     /**
     * 处理 User 「删除」 事件。
     *
     * @param  \App\User  $user
     * @return void
     */   
     public function deleted(User $user) 
        {   
             //   
         }
   }

Verwenden Sie die Methode observe, um einen Beobachter für das Modell zu registrieren, das Sie beobachten möchten. Beobachter können auch im boot-Verfahren des Dienstleisters registriert werden. Hier ist ein Beispiel für die Registrierung eines Beobachters in AppServiceProvider:

<?php
    namespace App\Providers;
    use App\User;use App\Observers\UserObserver;
    use Illuminate\Support\ServiceProvider;
    class AppServiceProvider extends ServiceProvider{  
      /**
     * 启动应用服务。
     *
     * @return void
     */   
      public function boot()  
       {       
         User::observe(UserObserver::class);   
       }  
    /**
     * 注册服务提供者。
     *
     * @return void
     */  
     public function register() 
        {      
          //   
         }
      }