Vad är Laravel Eloquent, hur man använder det, handledning med exempel

Laravel PHP-ramverket inkluderar Eloquent Object Relational Mapper (ORM), som ger ett extremt enkelt sätt att kommunicera med en databas. 

Laravel och Eloquent hjälper till att påskynda applikations- och plattformsutvecklingen, vilket ger en adekvat lösning på de flesta problem. Kraven åtgärdas med snabbare utveckling, samt välorganiserad, återanvändbar, underhållbar och skalbar kod. 

Hur vältalig fungerar

Utvecklare kan arbeta i Eloquent med flera databaser effektivt med hjälp av en ActiveMethod-implementering. Det är ett arkitektoniskt mönster där modellen skapad i Model-View-Controller-strukturen (MVC) motsvarar en tabell i databasen. Fördelen är att modellerna utför vanliga databasoperationer utan att koda långa SQL-frågor. Mallar låter dig fråga data i tabeller och infoga nya poster i tabeller. Processen att synkronisera flera databaser som körs på olika system förenklas. Du behöver inte skriva SQL-frågor. Allt du behöver göra är defiAvsluta databastabellerna och relationerna mellan dem, så kommer Eloquent att göra resten av arbetet.

Laravel förberedelse

Att uppskatta nyttan av Eloquent ORM och förstå ekosystemet är ett måste. Steg för att komma igång:

1. Installera Laravel från getcomposer.org, för att göra detta följ instruktionerna här
2. Skapande migration med hjälp av konsolen Artisan
3. Skapa mallar eloquent
4. kör i seed av databasen

Artisan Console är namnet på kommandoradsgränssnittet som ingår i Laravel. Ger en uppsättning användbara kommandon att använda när du utvecklar din applikation. Den drivs av den kraftfulla komponenten Symfony Console.

För att se en lista över alla tillgängliga Artisan-kommandon kan du använda listkommandot:

php artisan list

Alla kommandon kommer med en kortfattad beskrivning av dess argument och alternativ. Detta visas i en "hjälp"-skärm. För att visa en hjälpskärm, föregå kommandots namn med "hjälp" som visas:

php artisan help migrate

Migration

Migrering är en databashanteringsprocess genom att skriva PHP istället SQL. Ger ett sätt att lägga till versionskontroll till databasen. 

För att skapa en migrering, kör bara följande kommando:

php artisan make:migration create_student_records

Detta skapar migreringsfilen. I din textredigerare öppnar du filen du just skapade i mappen database\migrations:

<?php
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;

class CreateStudentRecordsTable extends Migration
{
    /**
    * Run the migrations.
    *
    * @return void
    */
    public function up()
    {
        Schema::create('student__records', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
        });
    }

    /**
    * Reverse the migrations.
    *
    * @return void
    */
    public function down()
    {
        Schema::dropIfExists('student__records');
    }
}

Koden är en klass med samma namn 'create student records', och har två metoder: upp och ner. Upp-metoden bör göra ändringar i databasen; så närhelst du migrerar din databas kommer valfri kod i upp-metoden att exekveras. Å andra sidan bör nedmetoden återställa dessa databasändringar; så närhelst du kör rollback av migration, bör nedmetoden ångra vad upp-metoden gjorde. Inuti metoden up det finns schemabyggaren som används för att skapa och manipulera tabellerna. Vad händer om du avbryter några av dina migreringar? Allt du behöver göra är att implementera följande kommando:

php artisan migrate:rollback

Och han ska samla den sista migration som har genomförts. Du kan också helt återställa databasen genom att köra:

php artisan migrate:reset

Detta kommer att avbryta alla dina migreringar.

Defition av modeller av Eloquent

När databasmigreringen är klar är nästa process seeding. Eloquent kommer in i bilden sedan seeding infogar uppgifter i vår databas. Så du måste skapa mallarna innan du fyller i databasen. Varje databastabell har en motsvarande modell som används för att interagera med den tabellen. Mallar låter dig fråga efter data i dina tabeller, samt infoga nya poster i tabellen. Det enklaste sättet att instansiera modellen är att använda följande kommando:

php artisan make:model Student

Ett exempel på en mall visas nedan Student, som kan användas för att hämta och lagra information från vår studentdatabastabell:

<?php
namespace App;
use IlluminateDatabaseEloquentModel;

class Student extends Model
{
    //
}

När du genererar en modell och samtidigt vill generera en databasmigrering kan du använda alternativet –migration o -m:

php artisan make:model Student --migration

php artisan make:model Student -m

Såmaskiner

Övergripande såmaskiner är en speciell uppsättning klasser som gör att vi kan fylla vår databas om och om igen med exakt samma data. Vi implementerar följande kommando:

php artisan make:seeder StudentsRecordSeeder

I textredigeraren, under seeds-mappen, öppna den nyskapade filen med filnamn: StudentsRecordSeeder.php. Som du kan se är detta bara en mycket enkel klass med en enda metod som kallas run().

<?php
use IlluminateDatabaseSeeder;

class StudentsRecordSeeder extends Seeder
{
    /**
    * Run the database seeds
    * @return void
    */

    public function run()
    {
        //
    }
}

Koden är bara ett omslag runt en konsolkommandoklass, speciellt byggd för att hjälpa till med uppgiften seeding. Redigera koden och spara den sedan.

public function run()
{
    echo 'Seeding!';
}

Och gå till terminalen:

php artisan db:seed --class=StudentsRecordSeeder

Nu kan du fylla tabellen med några poster och köra:

php artisan db:seed --class=class=StudentsRecordSeeder

Här kan du fortsätta att ta bort, lägga till, ändra poster i DB och sedan återställa dem med ett enkelt kommando.

CRUD med Laravel Eloquent

CRUD-operationer med Laravel Eloquent object-relational mapper (ORM) gör det lättare för Laravel-utvecklare att arbeta med flera databaser. Den utför skapa, läs, uppdatera och ta bort (CRUD) operationer och mappar objektmodeller till databastabeller. Hanterar alla databasinteraktioner som krävs för CRUD-operationer.

Skapande av register

Du kan använda metoden ::create för att infoga en ny post i databasen.

student_record::create(array(
    'first_name' => 'John',
    'last_name'  => 'Doe',
    'student_rank' => 1
));

Utöver den enkla skapandemetoden som visas ovan kan du också skapa ett nytt objekt och ge det olika attribut. Sedan kan du anropa save()-funktionen och köra koden. Metoder som firstOrCreate() eller firstOrNew() är andra alternativ för att skapa poster. Dessa gör att du kan hitta en student med vissa egenskaper; om den studenten inte hittas kommer du att skapa den i databasen eller instansiera en ny instans.

Läser uppteckningar

Med Eloquent ORM kan du hitta poster i din databas. Frågorna är enkelt konstruerade och erbjuder ett smidigt flöde. Så här skapar du uttalanden:where, kommer du att använda metoderna get() Och first(). Metoden first() kommer bara att returnera en post, medan metoden get() returnerar en slingbar array av poster. Även metoden find() kan användas med en uppsättning primärnycklar, som returnerar en samling matchande poster. Här är några exempel:

$student = Students::all();

Denna kod får alla elever. Medan följande kod hittar en specifik student efter ID:

$student = Students::find(1);

Dessutom, som visas nedan, beskriver koden hur du söker efter en elev baserat på ett specifikt attribut.

$JohnDoe = Students::where('name', '=', 'John Doe')->first();

För metoden get() visar den här koden hur man hittar en elev med en nivå över 5.

$rankStudents = Student::where('student_rank', '>', 5)->get();

Rekorduppdatering

Att uppdatera poster med Eloquent är lika enkelt. För att uppdatera en post, hitta bara posten du vill uppdatera, redigera attributen och spara. För att till exempel ändra betygsnivån för John Does elev till 5, hitta först eleven och kör sedan sparmetoden.

$JohnDoe = Bear::where('name', '=', 'John Doe')->first();
$JohnDoe->danger_level = 5;
$JohnDoe->save();

Sparmetoden kan också användas för att uppdatera modeller som redan finns i databasen.

Ta bort poster

Eloquent skryter med sin enkla uppdateringsprocess, men den har samma historia med radering. Det finns två alternativ: dra ut poster och kör raderingsmetoden, eller använd helt enkelt förstörningsmetoden. För att hitta och ta bort en post, kör bara följande kommandon:

$student = Students::find(1);
$student->delete();

För att radera en post och flera poster körs kommandona:

Students::destroy(1);
Students::destroy(1, 2, 3);

Observera att parametrarna för förstöra endast är primärnycklar till skillnad från deletemetoden som kan acceptera vilken databaskolumn som helst.

För att hitta och ta bort alla elever över nivå 10.

Students::where('student_rank', '>', 10)->delete();

Ercole Palmeri