Laravel
Vältalig

Introduktion

Anmärkningar

class User extends Model
{ 
    protected $table = 'customers';
}

Introduktion

Eloquent är ORM inbyggd i Laravel-ramverket. Det låter dig interagera med dina databastabeller på ett objektorienterat sätt med hjälp av ActiveRecord- mönstret.

En enkel modellklass kartlägger vanligtvis till en enda databastabell, och även förhållanden av olika typer ( en-till-en , en-till-många , många-till-många , polymorf) kan definieras mellan olika modellklasser.

Avsnittet Making a Model beskriver skapandet och definitionen av modellklasser.

Innan du kan börja använda Eloquent-modeller, se till att minst en databasanslutning har konfigurerats i konfigurationsfilen config/database.php .

För att förstå användningen av vältalig frågeställare under utveckling kan du använda php artisan ide-helper:generate kommando. Här är länken .

Under ämnesnavigering

Vältaligt förhållande

Lagra

Förutom att läsa data med Eloquent, kan du också använda dem för att infoga eller uppdatera data med metoden save() . Om du har skapat en ny modellinstans kommer posten att infogas ; annars, om du har hämtat en modell från databasen och ställt in nya värden, kommer den att uppdateras .

I det här exemplet skapar vi en ny User rekord:

$user = new User();
$user->first_name = 'John';
$user->last_name = 'Doe';
$user->email = '[email protected]';
$user->password = bcrypt('my_password');
$user->save();

Du kan också använda metoden create för att fylla fält med hjälp av en matris med data:

User::create([
    'first_name'=> 'John',
    'last_name' => 'Doe',
    'email'     => '[email protected]', 
    'password'  => bcrypt('changeme'),
]);

När du använder skapningsmetoden ska dina attribut deklareras i den fillable matrisen i din modell:

class User extends Model
{
    protected $fillable = [
         'first_name',
         'last_name',
         'email',
         'password',
    ];
}

Alternativt, om du vill göra alla attribut masstilldelningsbara, kan du definiera den $ skyddade egenskapen som en tom matris:

class User extends Model
{
    /**
    * The attributes that aren't mass assignable.
    *
    * @var array
    */
    protected $guarded = [];
}

Men du kan också skapa en post utan att ens ändra det fillable attributet i din modell genom att använda forceCreate metoden snarare än create metoden

User::forceCreate([
    'first_name'=> 'John',
    'last_name' => 'Doe',
    'email'     => '[email protected]', 
    'password'  => bcrypt('changeme'),
]);

Följande är ett exempel på uppdatering av en befintlig User genom att först laddar det (genom att använda find ), modifiera den och sedan spara den:

$user = User::find(1);
$user->password = bcrypt('my_new_password');
$user->save();

För att uppnå samma prestation med ett samtal med en enda funktion kan du använda update :

$user->update([
    'password' => bcrypt('my_new_password'),
]);

Metoderna för att create och update gör arbetet med stora uppsättningar data mycket enklare än att behöva ställa in varje nyckel- / värdepar för sig, vilket visas i följande exempel:

Observera användningen av only och except när du samlar in begärandedata. Det är viktigt att du anger exakta nycklar som du vill tillåta / låta uppdateras, annars är det möjligt för en angripare att skicka ytterligare fält med sin begäran och orsaka oavsiktliga uppdateringar.

// Updating a user from specific request data
$data = Request::only(['first_name', 'email']);
$user->find(1);
$user->update($data);

// Create a user from specific request data
$data = Request::except(['_token', 'profile_picture', 'profile_name']);
$user->create($data);

Tar bort

Du kan ta bort data efter att du har skrivit dem till databasen. Du kan antingen ta bort en modellinstans om du har hämtat en eller ange villkor för vilka poster som ska tas bort.

För att ta bort en modellinstans, hämta den och ring metoden delete() :

$user = User::find(1);
$user->delete();

Alternativt kan du specificera en primär nyckel (eller en matris med primära nycklar) för de poster du vill ta bort via metoden destroy() :

User::destroy(1);
User::destroy([1, 2, 3]);

Du kan också kombinera fråga med radering:

User::where('age', '<', 21)->delete();

Detta raderar alla användare som matchar villkoret.

Obs: När du utför ett uttalande om mass-borttagning via Eloquent kommer de deleting och deleted modellhändelserna inte att avfyras för de raderade modellerna. Detta beror på att modellerna aldrig hämtas när de raderar uttalandet.

Mjuk radering

Vissa gånger vill du inte ta bort en post permanent, men behålla den för revisions- eller rapporteringsändamål. För detta ger Eloquent mjuk radering av funktioner.

För att lägga till mjuk raderad funktionalitet till din modell måste du importera SoftDeletes och lägga till den i din Eloquent-modellklass:

namespace Illuminate\Database\Eloquent\Model;
namespace Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model
{
     use SoftDeletes;
}

När du raderar en modell kommer den att ställa in en tidsstämpel i en deleted_at tidsstämpel i tabellen för din modell, så se till att du först skapar kolumnen deleted_at i tabellen. Eller vid migrering bör du anropa softDeletes() -metoden på din plan för att lägga till den deleted_at tidsstämpeln. Exempel:

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

Alla frågor kommer att utelämna mjuka borttagna poster. Du kan tvinga fram dem om du vill genom att använda withTrashed() :

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

Om du vill tillåta användare att återställa en post efter mjuk radering (dvs i ett papperskorgen-typ) kan du använda restore() :

$user = User::find(1);
$user->delete();
$user->restore();

För att ta bort en post med kraft använder forceDelete() metoden forceDelete() som verkligen tar bort posten från databasen:

$user = User::find(1);
$user->forceDelete();

Ändra primärnyckel och tidsstämplar

Som standard förväntar sig Eloquent-modeller att den primära nyckeln ska namnges 'id' . Om det inte är ditt fall kan du ändra namnet på din primära nyckel genom att ange egenskapen $primaryKey .

class Citizen extends Model
{
    protected $primaryKey = 'socialSecurityNo';

    // ...
}

Nu kommer alla välkända metoder som använder din primära nyckel (t.ex. find eller findOrFail ) att använda det nya namnet.

Dessutom förväntar sig Eloquent att den primära nyckeln är ett automatiskt ökande heltal. Om din primära nyckel inte är ett automatiskt ökande heltal (t.ex. en GUID), måste du berätta för Eloquent genom att uppdatera $incrementing till false :

class Citizen extends Model
{
    protected $primaryKey = 'socialSecurityNo';

    public $incrementing = false;

    // ...
}

Som standard förväntar created_at att created_at och updated_at finns i dina tabeller. Om du inte vill att dessa kolumner ska hanteras automatiskt av Eloquent ställer du $timestamps egenskapen $timestamps på din modell till falsk:

class Citizen extends Model
{
    public $timestamps = false;

    // ...
}

Om du behöver anpassa namnen på kolumnerna som används för att lagra tidsstämplarna kan du ställa in CREATED_AT och UPDATED_AT konstanterna i din modell:

class Citizen extends Model
{
    const CREATED_AT = 'date_of_creation';
    const UPDATED_AT = 'date_of_last_update';

    // ...
}

Kasta 404 om enheten inte hittades

Om du vill kasta ett undantag automatiskt när du söker efter en post som inte finns i en modal, kan du använda endera

Vehicle::findOrFail(1);

eller

Vehicle::where('make', 'ford')->firstOrFail();

Om en post med den primära nyckeln 1 inte hittas kastas en ModelNotFoundException . Vilket är väsentligen detsamma som att skriva ( se källa ):

$vehicle = Vehicle::find($id);

if (!$vehicle) {
    abort(404);
}

Kloningsmodeller

Det kan hända att du behöver klona en rad, kanske ändra några attribut men du behöver ett effektivt sätt att hålla saker TORA. Laravel tillhandahåller en typ av "dold" metod för att du kan göra denna funktion. Även om det är helt odokumenterat måste du söka igenom API för att hitta det.

Med $model->replicate() du enkelt klona en post

$robot = Robot::find(1);
$cloneRobot = $robot->replicate();
// You can add custom attributes here, for example he may want to evolve with an extra arm!
$cloneRobot->arms += 1;
$cloneRobot->save();

Ovanstående skulle hitta en robot som har ett ID på 1 och sedan klonar den.