Laraveli õpetus algajatele

Laraveli lõi Taylor Otwell. Alates selle esialgsest väljalaskmisest 2011. aasta juunis (versioon 1) on see veebiarendustööstuse PHP-raamistiku sektoris pidevalt populaarsemaks muutunud. Suur osa sellest populaarsusest on tingitud paljudest arendajapõhistest funktsioonidest, mis see laos kaasas on.

Miks Laravel?

Umbes 2000, enamus PHP koodid oli protseduuriline ja seda võis leida "skriptide" kujul, millel oleks spagetikoodi sassis segadus. Isegi kõige lihtsamatel lehtedel puudus murede eraldamine, ja seega oli rakendusel üsna lihtne kasvada kiiresti hooldusõudusunenäoks. Maailm vajas midagi paremat... Sisestage PHP versioon 5 ja erinevad PHP raamistikud, mis üritavad tuua väga vajalikku eraldusvõimet ja paremaid lahendusi erinevatele veebirakendustega seotud probleemidele.

Sellest ajast alates oleme näinud palju välja antud raamistikke, mis sillutaksid teed praegu olemasolevatele ja kasutatavatele populaarsetele raamistikele. Täna oleks (meie arvates) esikolmik Zend Framework, Symfony ja loomulikult Laravel. Kuigi kõik need raamistikud põhinesid sarnastel põhimõtetel ja on suunatud (põhimõtteliselt) samade ühiste probleemide lahendamisele, seisnevad nende peamised erinevused nende rakendamises. Kõigil neil on oma veidrused, kuidas probleeme lahendada. Kui vaatate nende kõigi loodud koodi, näete, et neid eraldab üsna kindel joon. Meie tagasihoidliku arvamuse kohaselt on Laraveli raamistik parim.

Lisateave Erinevus Laraveli ja CodeIgniteri vahel

Kuidas Laravelit koos heliloojaga alla laadida ja installida

MÄRKUSED Eeldatakse, et teie kohalikku süsteemi on PHP koopia juba installitud. Kui ei, saate lugeda, kuidas seda installida siin

Composer on nii paketi- kui ka sõltuvushaldur. Selle installimiseks avage terminal ja CD uude kataloogi. Käivitage see käsk:

curl -Ss getcomposer.org/installer | php

Selle käsu tulemused näevad välja järgmised:

märkused Laraveli seadistamise kohta leiate põhjalikumaid juhiseid Laraveli dokumentatsioonist siin.

Näete, et see laadib alla ja kompileerib skripti composer.phari, mida me Laraveli installimiseks kasutame. Kuigi uue Laraveli rakenduse seadistamiseks on palju võimalusi, teeme seda Laraveli helilooja skripti kaudu. Selle skripti installimiseks käivitage:

composer global require laravel/installer

Mis näeb välja umbes selline:

See laadib alla ja installib kõik raamistiku failid ise ning kõik selle jaoks vajalikud sõltuvused. Pakendid salvestatakse tarnija kataloogi. Kui see on alla laaditud ja installitud, on see sama lihtne kui järgmise käsu väljastamine:

laravel new uploadApp

Näete midagi järgmist väljundit:

Composer installib kõik paketid, mida Laravel töötamiseks vajab. See võib võtta mõne minuti, nii et olge kannatlik. Kui see on lõpetatud, käivitage installitu vaatamiseks käsk ls -al.

Siin on Laraveli tavalise rakenduse kataloogide lühike ülevaade:

• rakendus/ : See on lähtekaust, kus asub meie rakenduse kood. Kõik kontrollerid, poliitikad ja mudelid on selles kaustas
• bootstrap/ : Hoiab rakenduse käivitusskripti ja mõnda klassikaardi faili
• config/ : Hoiab rakenduse konfiguratsioonifaile. Tavaliselt ei muudeta neid otseselt, vaid tuginetakse väärtustele, mis on seadistatud rakenduse juurtes olevas .env-failis (keskkond).
• andmebaas/ : Sisaldab andmebaasifaile, sealhulgas migratsioone, seemneid ja katsetehaseid
• avalik/ : Avalikult juurdepääsetav kaust, mis sisaldab kompileeritud varasid ja loomulikult faili index.php
• ressursid/ : Sisaldab esiotsa varasid, nagu JavaScripti failid, keelefailid, CSS/SASS-failid ja kõik rakenduses kasutatavad mallid (nn blade mallid)
• marsruudid/ : Kõik rakenduses olevad marsruudid on siin sees. Marsruute on mitu erinevat ulatust, kuid see, millele me keskendume, on fail web.php
• ladustamine/ : Kõik rakenduse kasutatavad ajutised vahemälufailid, seansifailid, koostatud vaateskriptid ja logifailid
• testid/ : Sisaldab rakenduse testfaile, nagu seadmetestid ja funktsionaalsed testid.
• müüja/ : Kõik heliloojaga installitud sõltuvuspaketid

Nüüd siis loome ülejäänud rakenduse ja käivitame selle spetsiaalse käsitöökäsuga (et säästa end veebiserveri, nagu Apache või nginx, installimise ja konfigureerimise vaevast). Env-fail sisaldab kõiki konfiguratsiooniväärtusi, mida kataloogis /config olevad failid rakenduse konfigureerimiseks kasutavad. Selle sees märkate, et rakenduse sisemistes kasutatavate erinevate parameetrite konfiguratsiooniväärtus.

Rakenduse disain: meie nõuete kiire ülevaade

Selles veebipõhises Laraveli õpetuses koostame väga lihtsa rakenduse, mis teeb ainult kahte asja:

1. hallata failide üleslaadimist veebivormist
2. varem üleslaaditud failide kuvamine teisel lehel.

Selle projekti puhul on meie rakendus ainult kirjutatav, mis tähendab, et kasutaja saab kirjutada ainult faile ja vaadata üleslaaditud failide loendit. See rakendus on äärmiselt elementaarne, kuid see peaks olema hea tava, et saaksite oma Laraveli oskusi ja teadmisi edasi arendada. Pange tähele, et olen lühiduse huvides välistanud igasuguse andmebaasi modelleerimise, migreerimise ja autentimise, kuid reaalses rakenduses on need täiendavad asjad, mida soovite kaaluda.

Siin on nimekiri komponentidest, mida vajame, et rakendus töötaks ootuspäraselt:

• A tee mis võimaldab välismaailmal (Internetil) rakendust kasutada ning määrab lõpp-punkti, mis osutab üleslaaditud faili salvestamise loogika asukohale
• A kontroller mis käsitleb päringu vastusevoogu
• A šabloon mida kasutatakse varem üleslaaditud failide loendi ja tegeliku üleslaadimisvormi kuvamiseks
• A taotleda mida vastutav töötleja kasutab veebivormilt edastatud andmete kinnitamiseks

Mis on marsruut?

Laraveli marsruut on põhimõtteliselt URI-ga määratud lõpp-punkt, mis toimib "osutajana" mõnele rakenduse pakutavale funktsioonile. Kõige sagedamini osutab marsruut lihtsalt kontrolleri meetodile ja määrab ka, millised HTTP-meetodid suudavad seda URI-d tabada. Marsruut ei tähenda alati ka kontrolleri meetodit; see võib lihtsalt edastada rakenduse täitmise ka määratletud sulgemis- või anonüümsele funktsioonile.

Miks kasutada marsruuti?

Marsruudid salvestatakse failidesse projekti juurkataloogi kausta /routes alla. Vaikimisi on mõned erinevad failid, mis vastavad rakenduse erinevatele "külgedele" ("küljed" pärineb kuusnurkse arhitektuuri metoodikast). Nende hulka kuuluvad:

• web.php Avalikkuse ees "brauseri"-põhised marsruudid. Need on kõige levinumad ja neid tabab veebibrauser. Need läbivad veebi vahevara rühma ja sisaldavad ka võimalusi csrf kaitse (mis aitab kaitsta vormipõhiste pahatahtlike rünnakute ja häkkide eest) ja sisaldab üldiselt teatud olekuid (selle all pean silmas, et nad kasutavad seansse)
• api.php Marsruudid, mis vastavad API rühmale ja millel on seega vaikimisi lubatud API vahevara. Need marsruudid on olekuta ja neil ei ole seansse ega ristpäringumälu (üks päring ei jaga andmeid ega mälu ühegi teise päringuga – igaüks neist on kapseldatud).
• console.php Need marsruudid vastavad kohandatud käsitööliste käskudele, mille olete oma rakenduse jaoks loonud
• channels.php Registreerib marsruudid sündmuste edastamiseks

Võtmefail, millega praegu tegeleda, on brauserispetsiifiline fail, web.php . Vaikimisi on juba määratletud üks marsruut, mis on see, mille vajutate oma rakenduse veebijuuri navigeerides (veebijuur on avalikus kataloogis). Meie üleslaadimisrakenduse toimimiseks vajame kolme erinevat marsruuti:

• /upload See on meie failide üleslaadimise veebivormi kuvava avalehe URI.
• /process See on koht, kuhu /upload URI-s asuv vorm postitab oma vormis saadetud andmed (vormi "toiming")
• /list See loetleb kõik saidile üles laaditud failid

meeles Lõpp-punkt /list ei pruugi olla vajalik, kui soovime panna kogu üleslaadimisvormi ja failide loendi kuvamise loogika ühele lehele, kuid hoidsime need praegu eraldi, et käsitletavale teemale veidi rohkem asja lisada .

//inside routes/web.php
Route::get('/upload', 'UploadController@upload')->name('upload');
Route::get('/download, 'UploadController@download)->name(‘download');
Route::post('/process', 'UploadController@process')->name('process');
Route::get('/list', 'UploadController@list')->name('list');

Selles Laraveli raamistiku õpetuses loetleme selle iga soovitud marsruudi jaoks selgesõnaliselt marsruudifailis web.php, kasutades ühte saadaolevatest HTTP-spetsiifilistest päringumeetoditest (get(), post(), put() , delete(), patch() või options() ). Kõigi nende jaotuse saamiseks vaadake see välja. Need meetodid määravad, millistel HTTP-verbidel on antud marsruudile juurdepääs. Kui vajate marsruuti rohkem kui ühe HTTP-verbi vastuvõtmiseks (see võib juhtuda, kui kasutate ühte lehte nii algandmete kuvamiseks kui ka esitatud vormiandmete postitamiseks), võite kasutada valikut Route::any( ) meetod.

Teine argument nii meetodi Route::get() kui ka Route::post() (ja kõigi teiste marsruudi fassaadil oleva HTTP-verbiga seotud meetodi puhul) on konkreetse kontrolleri ja selle sees asuva meetodi nimi. kontroller, mis käivitatakse marsruudi lõpp-punkti tabamisel lubatud HTTP-päringuga (GET, POST, PATCH jne). Kasutame UploadControllerit kõigi kolme marsruudi jaoks ja oleme need määranud järgmiselt:

Viimane meetod, mida igal marsruudil kutsume, on selle funktsioon name(), mis võtab argumendina vastu ühe stringi ja mida kasutatakse konkreetse marsruudi enam-vähem "märgistamiseks" kergesti meeldejääva nimega (meie juhtudel, üleslaadimine, töötlemine ja loend). Ma saan aru, et igale marsruudile oma nime andmine, kui URL on täpselt sama nimega, ei tundu nii suurepärane funktsioon, kuid see on tõesti kasulik, kui teil on konkreetne marsruut, näiteks /users/profile/dashboard/config, mida oleks lihtsam meeles pidada kui profile-admin või user-config.

Märkus fassaadide kohta:

• Fassaadid pakuvad "staatilise" liidese klassidele, mis on saadaval rakenduse teeninduskonteineris."
• Need pakuvad lühidalt meeldejäävat süntaksit, mis võimaldab teil kasutada Laraveli funktsioone, ilma et peaksite meeles pidama pikki klassinimesid, mis tuleb sisestada või käsitsi konfigureerida.

Ülaltoodud marsruudimääratlustes selles Laraveli raamistiku õpetuses kasutame marsruudi fassaadi selle asemel, et luua käsitsi uus valgustus-/marsruutimis-/ruuteriobjekt ja kutsuda sellel objektil vastavad meetodid. See on lihtsalt otsetee, mis säästab tippimist. Fassaade kasutatakse kogu Laraveli raamistikus palju – saate ja peaksite nendega lähemalt tutvuma. Fassaadide dokumendid leiate siin.

Mis on kontroller?

Kontroller on "MVC" (Model-View-Controller) arhitektuuris "C", millel Laravel põhineb. Kontrolleri töö võib taandata sellele lihtsale määratlusele: See võtab kliendilt päringu vastu ja tagastab kliendile vastuse. See on paljaste luude määratlus ja see on ka iga kontrolleri miinimumnõuded. Seda, mida see nende kahe asja vahel teeb, peetakse üldiselt vastutava töötleja "toiminguks" (või "marsruudi rakendamiseks"). See toimib teise sisenemispunktina rakendusele (esimene on päring) kliendile, kes saadab päringu kasuliku koormuse (mille juurde jõuame järgmisena) rakendusele, oodates teatud tüüpi vastust (aadressi vormis). eduleht, ümbersuunamine, vealeht või mõni muu HTTP-vastus).

Kontroller teeb (põhimõtteliselt) sama asja kui marsruudi määratlus, mille anonüümne funktsioon on seatud "toiminguks", kui seda marsruuti tabatakse. Erinevus seisneb selles, et kontroller peab hästi vastu probleemide eraldamisele, samal ajal kui marsruut on määratletud tegeliku URL-i definitsiooniga, mis tähendab põhimõtteliselt, et me ühendame marsruudile määratud URI marsruudi rakendusega või koodiga, mis käivitatakse, kui see marsruut on tabas.

Näiteks kaks järgmist koodiosa annavad sama tulemuse:

Näide nr 1: marsruudi määratlus ja rakendamine ühes meetodikutses (failis web.php marsruudid)

//inside routes/web.php
<?php
Route::get('/hello-world', function(Request $request) {
   $name = $request->name;
   return response()->make("<h1>Hello World! This is ".$name, 200);
});

Näide nr 2: marsruudi määratlus asub routes/web.php sees, kuid selle rakendamine asub klassis /app/Http/Controllers/HelloWorldController

//inside routes/web.php
<?php

Route::get('/hello-world', 'HelloWorldController@index')->name('hello-world');

------------------------------------------------------------------------------------
//inside app/Http/Controllers/HelloWorldController.php
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;

class HelloWorldController extends Controller
{
   public function index(Request $request)
   {
       $name = $request->name;
       return response()->make("<h1>Hello World! This is ".$name, 200);
   }
}

Kuigi Laraveli näide nr 2 näib olevat palju rohkem tööd (mida see pole – lihtsalt natuke rohkem koodi on kõik), vaadake kasu, mida saame, kui paneme oma tegevusloogika antud "tere-maailm" marsruudi jaoks kontrolleri sisse. koos marsruudi määratlusega kui tagasihelistamise funktsiooniga:

1. Meie loogika on selgelt eraldatud oma klassi (murede eraldamine)
2. Meie kontroller on seadistatud hilisemaks laienduseks, kui peaksime sellele lisavõimalusi lisama... Ütleme, et võib-olla tahtsime lisada "hüvasti maailm" funktsiooni... Sel juhul nimetaksime kontrolleri ümber üldisemaks "HelloController" ja seejärel määraksime kaks erinevat meetodit, tere () ja hüvasti (). Samuti peaksime määratlema kaks eraldi marsruuti, mis kaardistasid /Tere ja / hüvasti URI-d kontrolleri sobivale meetodile. See on soovitav võrreldes marsruudifaili suurendamisega, kusjuures iga marsruudi juurutamine on määratletud tagasihelistamise funktsioonidena.
3. Laravelil on sisseehitatud võimalus salvestada kõik rakenduses olevad marsruudimääratlused vahemällu, nii et see kiirendab antud marsruudi leidmiseks kuluvat aega (suurendab rakenduse jõudlust); Samas saate seda kasutada ainult siis, kui kõik teie määratletud marsruudid rakenduses on konfigureeritud kontrollerispetsiifilisi vastendusi kasutades (vt ülaltoodud näidet nr 2).

Käivitame selle käsu, mis genereerib meile uue kontrolleri.

// ...inside the project's root directory:
php artisan make:controller UploadController   

Põhimõtteliselt genereerib see käsk kontrolleri nimega "UploadController" tünni peamise kontrolleri kataloogis aadressil /app/Http/Controllers/UploadController.php. Avage see fail ja vaadake seda. See on väga lihtne, sest see on ainult kontrolleri jämeversioon, millel on õige nimeruumi tee ja vajalikud klassid, millest see ulatub.

Taotluse genereerimine

Enne kui jätkame selles PHP Laraveli õpetuses ja teeme UploadControlleri loodud tünnis mõned muudatused, on minu arvates mõttekam luua kõigepealt päringuklass. Selle põhjuseks on asjaolu, et päringut käsitlev kontrolleri meetod peab oma allkirja sisestama päringuobjekti vihje, võimaldades tal automaatselt kinnitada sissetulevad vormiandmed (nagu on täpsustatud meetodis rule(). Rohkem sellest hiljem...) Praegu kasutame käsitöölise käsk uuesti, et genereerida meie päringu tünn:

php artisan make:request UploadFileRequest

See käsk genereerib rakenduses/Http/Requests/UploadFileRequest faili nimega UploadFileRequest. Avage tünn ja piiluge... See on väga lihtne, sisaldades ainult kahte meetodit, autoriseerimist () ja reegleid.

Valideerimisloogika loomine

Muutkem päringu tüpi, et see vastaks meie rakenduse vajadustele. Muutke faili nii, et see näeks välja järgmine:

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class UploadFileRequest extends FormRequest
{
   /**
    * Determine if the user is authorized to make this request.
    *
    * @return bool
    */
   public function authorize()
   {
       return true;
   }

   /**
    * Get the validation rules that apply to the request.
    *
    * @return array
    */
   public function rules()
   {
       return [
           'fileName' => 'required|string',
           'userFile' => 'required|file'
       ];
   }
}

Mitte palju muudatusi, kuid pange tähele, et autoriseerimismeetod tagastab nüüd vale vale asemel tõene. See meetod otsustab, kas lubada päringul rakendusse siseneda või mitte. Kui see on seatud väärtusele Väär, peatab see päringu süsteemi sisenemise (mis oleks tavaliselt kontrolleri meetod). See oleks väga mugav koht kasutaja volituste kontrollimiseks või muuks loogikaks, mis võib otsustada, kas päring saab edastada kontrollerile. Praegu pöördume siin lihtsalt tagasi, et lubada kõigel ja kõigel taotlust kasutada.

Teine meetod, rule() on see, kus valideerimisel tuleb mängu kogu võlu. Idee on lihtne: tagastage massiiv, mis sisaldab reegleid järgmisel kujul:

'formFieldName' => 'constraints this field has separated by pipe characters (|)'

Seal on palju erinevaid valideerimispiiranguid, mida Laravel toetab kohe alguses. Nende täieliku loendi leiate veebipõhisest dokumentatsioonist siin. Meie üleslaadimisrakenduse jaoks on kaks välja, mis edastatakse POST-i päringu kaudu esiküljel olevalt vormilt. Parameeter fileName peab olema vormi keha sees (st kohustuslik) ja seda kasutatakse failinimena, mille all me faili salvestusruumi salvestame (seda tehakse kontrolleris – jõuame selleni veidi hiljem). Samuti täpsustame, et faili nimi peab olema string, lisades torumärgi (|) ja sõna "string". Piirangud on alati piiritletud torudega, mis võimaldab ühe real määrata antud väljale kõik lisakriteeriumid! Milline jõud!

Teine parameeter userFile on tegelik fail, mille kasutaja veebilehe vormilt üles laadib. Vajalik on ka UserFile ja peab olla fail. Märge: Kui eeldaksime, et üleslaaditav fail on pilt, kasutaksime selle asemel pildipiirangut, mis piiraks populaarsete pilditüüpide hulka kuuluvaid failitüüpe (jpeg, png, bmp, gif või svg). Kuna tahame lubada kasutajal üles laadida mis tahes tüüpi faile, jääme ainult faili kinnitamise piirangu juurde.

See on peaaegu kõik, mis päringuobjektis on. Selle põhiülesanne on lihtsalt säilitada vastuvõetav kriteeriumide (piirangute) kogum, millele vormi kehaparameetrid peavad vastama, et rakendusse sügavamale minna. Veel tuleb tähele panna, et need kaks välja (kasutajafail ja failinimi) peavad olema määratud ka HTML-koodi sees sisendväljade kujul (välja nimega, mis vastab päringuobjekti sees olevale nimele).

Võite küsida: kindlasti määratleb see vormipäringu omadused, kuid kus neid piiranguid tegelikult kontrollitakse? Järgmisena käsitleme seda.

Kontrolleri muutmine

Avage rakendus/Http/Controllers/UploadController ja tehke selles järgmised muudatused:

<?php

namespace App\Http\Controllers;

use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Http\Request;
use App\Http\Requests\UploadFileRequest; //our new request class
use Illuminate\Support\Facades\Storage; 

class UploadController extends Controller
{
   /**
    * This is the method that will simply list all the files uploaded by name and provide a
    * link to each one so they may be downloaded
    *
    * @param $request : A standard form request object
    * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
    * @throws BindingResolutionException
    */
   public function list(Request $request)
   {
       $uploads = Storage::allFiles('uploads');

       return view('list', ['files' => $uploads]);
   }

   /**
    * @param $file
    * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
    * @throws BindingResolutionException
    */
   public function download($file)
   {
       return response()->download(storage_path('app/'.$file));
   }

   /**
    * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
    * @throws BindingResolutionException
    */
   public function upload()
   {
       return view('upload');
   }

   /**
    * This method will handle the file uploads. Notice that the parameter's typehint
    * is the exact request class we generated in the last step. There is a reason for this!
    *
    * @param $request : The special form request for our upload application
    * @return array|\Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|null
    * @throws BindingResolutionException
    */
   public function store(UploadFileRequest $request)
   {
       //At this point, the parameters passed into the $request (from form) are
       //valid--they satisfy each of the conditions inside the rules() method

       $filename = $request->fileName;    //parameters have already been validated
       $file = $request->file('userFile'); //that we don't need any additional isset()

       $extension = $file->getClientOriginalExtension(); //grab the file extension
       $saveAs = $filename . "." . $extension; //filename to save file under

       $file->storeAs('uploads', $saveAs, 'local'); //save the file to local folder

       return response()->json(['success' => true]); //return a success message
   }
}

Seega on see üleslaaditud failide kettale salvestamine üsna lihtne. Siin on ülaltoodud üleslaadimismeetodi jaotus:

• Tipi vihje kontrolleri meetodis päringuklassile, mis täidab funktsiooni "liha ja kartul", et saaksime sissetulevad andmed automaatselt kinnitada
• Haarake fail kontrolleri meetodi sees olevast (nüüd kinnitatud) päringuobjektist välja (sel juhul andsime sellele nimeks upload(), kuid sellele oleks võinud anda ka standardsema nime, näiteks store()).
• Haara failinimi taotlusest välja
• Looge lõplik failinimi, mida kasutatakse alloleva faili salvestamiseks. Meetod getClientOriginalExtension() haarab lihtsalt üleslaaditud faili algse laiendi.
• Salvestage fail kohalikku failisüsteemi, kasutades meetodit storeAs(), edastades esimese argumendina nimelise tee kataloogis /storage ja teisena salvestatava failinime.
• Tagastada JSON-vastus, mis näitab, et taotlus oli edukas

Blade mall

Selle pusle viimane suurem osa on tera mall, mis sisaldab meie lihtsa rakenduse jaoks kogu HTML-i, CSS-i ja JavaScripti. Siin on kood – selgitame seda hiljem.

<body>
   <h1>Upload a file</h1>
   <form id="uploadForm" name="uploadForm" action="{{route('upload')}}" enctype="multipart/form-data">
       @csrf
       <label for="fileName">File Name:</label>
       <input type="text" name="fileName" id="fileName" required /><br />
       <label for="userFile">Select a File</label>
       <input type="file" name="userFile" id="userFile" required />
       <button type="submit" name="submit">Submit</button>
   </form>
   <h2 id="success" style="color:green;display:none">Successfully uploaded file</h2>
   <h2 id="error" style="color:red;display:none">Error Submitting File</h2>
   <script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
   <script>
        $('#uploadForm').on('submit', function(e) {
            e.preventDefault();
            var form = $(this);
            var url = form.attr('action');
            $.ajax({
                url: url,
                type: "POST",
                data: new FormData(this),
                processData: false,
                contentType: false,
                dataType: "JSON",
                success: function(data) {
                    $("#fileName").val("");
                    $("#userFile").val("");
                }
            }).done(function() {
                $('#success').css('display', 'block');
                window.setTimeout(()=>($("#success").css('display', 'none')), 5000);
            }).fail(function() {
                $('#error').css('display', 'block');
                window.setTimeout(()=>($("#error").css('display', 'none')), 5000);
            });
        });
   </script>
</body>
</html>

Siin on see, mida meie /üleslaadimine leht näeb välja selline:

See on väga tüüpiline näide blade-failist, mis sisaldab HTML-vormingut ja javascripti/jQuery't asünkroonsete funktsioonide lisamiseks (et leht ei värskendaks). Põhiline on olemas silt ilma meetodi atribuudita (mida selgitan vaid sekundiga) ja uudishimuliku toimingu atribuudiga väärtusega {{route('file.upload')}}. Blade puhul tuntakse seda kui a Direktiivi. Direktiiv on lihtsalt funktsiooni väljamõeldud nimi – need on funktsioonid, mis on spetsiifilised teramallidele, mis täidavad erinevaid toiminguid, mis on ühised veebilehtede ja veebirakenduste koostamisel. Et paremini mõista kõike lahedat jama, mida blade võib teha, vaadake dokumente siin. Ülaltoodud juhul kasutame vormi esitamiseks URL-i loomiseks marsruudi direktiivi.

Pidage meeles, et määratlesime oma marsruudid varem rakenduses failis web.php, määrates igaühele hõlpsasti meeldejääva nime. Direktiiv {{route()}} aktsepteerib marsruudi nime, otsib selle üles sisemise vahemällu salvestatud marsruutide loendist ja genereerib täieliku URL-i selle marsruudi määratluse põhjal failis web.php. Esimesel juhul täpsustame, et soovime, et vorm saadaks oma esitatud andmed meie rakenduse URL-ile /process, mis on määratletud kui POST liinil.

Järgmine imelik asi, mida võisite märgata, on @csrf silt otse avavormi sildi all. Blade'is genereerib see silt vormil parameetri _token, mida kontrollitakse rakenduses enne, kui vormi andmeid töödeldakse. See tagab vormi sees olevate andmete õige päritolu ja hoiab ära saidiülese taotluse võltsimise rünnakud. Selle kohta lisateabe saamiseks vaadake docs.

Pärast seda määratleme oma vormi tavalisena, kuid pange tähele, et meie vormi parameetrite nimed userFile ja fileName on täpselt sama nagu on määratletud meie päringuobjektis. Kui unustasime lisada päringuobjektis määratletud parameetri sisendi (või kirjutasime selle valesti), siis päring nurjub ja tagastatakse tõrge, mis takistab algse vormipäringu tabamist kontrolleri meetodil, mis asub aadressil UploadController@ protsess .

Proovige seda ja esitage selle vormi abil rakendusele mõned failid. Seejärel navigeerige lehele /nimekirja lehele, et näha üleslaadimiskausta sisu koos üleslaaditud failidega tabelis:

Suurem pilt

Astume sammu tagasi ja vaatame, mida oleme selles Laraveli õpetuses teinud.

See diagramm kujutab rakendust praegusel kujul (kõrgetasemelised üksikasjad välja arvatud):

Peaksite meeles pidama, et selle Laraveli õpetuse alguses loodud päringuobjektil peaksid olema samad reeglite meetodis määratletud parameetrid, mis on tera malli vormil (kui mitte, lugege uuesti jaotist "Valideerimisloogika loomine"). . Kasutaja sisestab vormi veebilehele, mis renderdatakse blade mallimootori kaudu (see protsess toimub loomulikult autopiloodil, nii et me ei pea sellele isegi mõtlema) ja esitab vormi. Malli allosas olev jQuery kood peatab vaikimisi esitamise (mis suunab automaatselt eraldi lehele), loob ajaxi päringu, laadib päringu koos vormiandmetega ja laadib faili üles ning saadab kogu asja meie esimesse kihti. rakendus: taotlus.

Päringuobjekti täidetakse, seostades meetodi rule() sees olevad parameetrid esitatud vormi parameetritega, seejärel valideerib andmed vastavalt igale määratud reeglile. Kui kõik reeglid on täidetud, edastatakse päring mis tahes kontrolleri meetodile, mis vastab marsruudifailis web.php määratletud väärtustele. Sel juhul teeb töö UploadControlleri protsess() meetod. Kui oleme kontrollerile vajutanud, teame juba, et taotlus läbis valideerimise, nii et me ei pea uuesti testima, kas antud failinimi on tegelikult string või parameeter userFile sisaldab teatud tüüpi faili… Võime jätkata normaalne.

Seejärel haarab kontrolleri meetod päringuobjektist valideeritud parameetrid, genereerib täieliku failinime, ühendades sisestatud failinime parameetri userFile'i algse laiendiga, salvestab faili meie rakenduse kataloogi ja tagastab seejärel lihtsa JSON-kodeeringu. vastus, mis kinnitab, et taotlus oli edukas. Vastuse võtab vastu jQuery loogika, mis teeb veel mõned kasutajaliidesega seotud toimingud, näiteks kuvab edu- (või veateate) 5 sekundit, seejärel peidab selle ja kustutab eelmised vormikirjed… see on nii, et kasutaja teaks et taotlus õnnestus, ja saavad soovi korral üles laadida mõne muu faili.

Pange tähele ka ülaltoodud diagrammi, kus on piir kliendi ja serveri vahel. See kontseptsioon on teie jaoks ülioluline ja aitab teil lahendada probleeme ja probleeme, mis võivad tekkida tulevikus, kui žongleerite näiteks mitme asünkroonse päringuga, mis võivad igal ajahetkel esineda. Eraldamine on otse päringuobjekti piiril. Päringuobjekti ennast võib pidada ülejäänud rakenduse "väravaks"... See teostab veebibrauserist edastatud vormiväärtuste esialgse valideerimise ja registreerimise. Kui need loetakse kehtivaks, jätkub see kontrollerile. Kõik enne seda on esiotsas ("klient" tähendab sõna-sõnalt "kasutaja arvutis"). Vastus tagastatakse rakendusest tagasi kliendi poolele, kus meie jQuery kood kuulab kannatlikult selle saabumist ja teeb pärast selle kättesaamist mõned lihtsad kasutajaliidese toimingud.

Oleme käsitlenud peaaegu 90+ olulist korduma kippuvat Laraveli ja PHP-ga seotud intervjuu küsimused nii värsketele kui ka kogenud kandidaatidele õige töö saamiseks.