Bygningsutsikt i Flask

Innenfor modellen eller utviklingsparadigmet den foreslår KolbeEt av de viktigste punktene er styringen av visningene, siden disse lar oss definere måten brukeren vil samhandle med siden eller applikasjonen vår.

Den enkleste måten å arbeide med utsikt er ved å definere operasjonen direkte i definisjonen av banen, men dette er ikke alltid nyttig eller tilstrekkelig, spesielt hvis vi bygger store applikasjoner.

KravVi trenger en funksjonell installasjon av Kolbe og av kompatibilitetshensyn trenger vi en versjon som er høyere enn den 0.7 siden en av komponentene vi skal jobbe med ikke ble inkludert i rammeverket før etter nevnte versjon. Vi må også starte en applikasjon eller ha en applikasjon Kolbe slik at vi kan inkludere eksemplene i visningsdelen og dermed kunne utføre dem med nettleser.

Rollebaserte visninger

Det er en av de enkleste måtene å bygge interaksjon med brukeren, vi trenger bare å skrive en funksjon og dekorere den med ruten, dette gjør når ruteren Kolbe mottar forespørselen, sjekker den om det er en funksjon som venter på ruten, og hvis den får den, kjører den den.

Vanligvis krever denne typen visninger minst metoden FÅ av HTTPSom en god praksis og av sikkerhetsmessige årsaker, kan vi imidlertid også bruke metoden hvis vi vil legge til verdier i datastyrkestrukturen vår. POST.

Opprette en visning med GET

Vi skal lage en visning ved hjelp av metoden FÅFor å gjøre dette må du bare definere navnet i en funksjon og tilordne en rute til den, så inne i funksjonen vil vi plassere innholdet vårt, la oss se følgende kode for å illustrere oss selv.

 @ app.route ('/ view-get') def view (): value = request.args.get ('content', 'sample') return 'Dette er en visning som bruker GET og mottar en verdi:% s'% verdi

I koden ser vi hvordan vi bruker dekoratør For å indikere hvilken rute vi venter på, definerer vi den tilsvarende funksjonen, og innenfor dette ringer vi med be om til argumentene mottatt av FÅ, i dette tilfellet søker vi etter et argument som kalles innhold og tilordner det til en variabel som kalles verdi, hvis dette argumentet ikke eksisterer, vil "sample" plasseres som standardverdi, og til slutt returnerer vi en tekst og sender innholdet i verdi .

Hvis vi kjører eksempelet vårt i nettleseren, får vi følgende:

Opprette en visning med POST

Hva skjer hvis det vi ønsker er å motta sensitive data, og vi ikke vil passere det gjennom parametere i URL -en, for i disse tilfellene må vi bruke POST -metoden, siden det sender dataene som er skjult for brukerens visning, selvfølgelig der er andre sikkerhetstiltak som vi bør bruke, men for øyeblikket trenger vi dem ikke for denne saken.

For å bygge en visning som mottar data fra POST, trenger du bare å angi den forventede metoden i dekoratør som mottar ruten vi ønsker, for dette bruker vi tilleggsparameteren metoder.

Så innen vår funksjon kan vi bruke be om For å oppnå verdiene må vi i motsetning til det forrige eksemplet, i stedet for å kreve argumentene, indikere at vi mottar verdiene fra et skjema. La oss se på koden for det vi nettopp forklarte.

 @ app.route ('/ post-view', methods = ['POST',]) def post_view (): value = request.form.get ('content', 'sample') return 'This is a view using POST og mottar en verdi:% s '% verdi

Vi kan legge merke til at det er nesten den samme koden som ovenfor bortsett fra forskjellene som allerede er nevnt, men la oss se hva som skjer hvis vi kjører koden vår direkte i nettleseren vår:

FORSTØRRE

Hvordan spesifiserer vi bare at vi kan motta metoden POST, når du får tilgang via FÅ vår søknad avviser oppføringen og sender oss derfor en kode 405 Metoden er ikke tillatt, så uten verdier som kommer fra en POST -forespørsel, vil denne visningen ikke vise noen informasjon.

Kombinere GET og POST i visningen

Siden håndtering av forskjellige visninger for hver metode ikke alltid er det vi ønsker, kan vi bruke begge metodene i samme visning, dette er veldig nyttig, spesielt når vi ønsker å behandle skjemaer, for eksempel med metoden FÅ vi viser skjemaet og med POST vi behandler forsendelsen av det samme.

For å bruke denne modusen må vi bare legge til FÅ på listen vi passerte til metoder når du definerer dekoratør med banen, la oss se koden nedenfor:

 @ app.route ('/ view', methods = ['GET', 'POST',]) def view (): if request.method == "GET": return '' 'Show Views' '' else: value = request.form.get ('content', 'sample') return 'Dette er en visning som bruker GET og POST som mottar en verdi:% s'% verdi

Når du ringer ruten fra nettleseren med metode FÅ vi får følgende:

Ved å skrive noe i tekstfeltet og trykke Enter sender vi skjemaet til den samme banen, men med metoden POST, som gir oss et resultat som følgende:

Her har vi da skrevet et sant funksjonsbasert syn, som lar oss bruke og dra fordel av begge metodene HTTP å gjøre operasjonene våre.

Klassebaserte visninger

Siden opprettelsen av funksjoner, selv om de tjener våre formål, noen ganger er veldig tungvint og egner seg til å ha mer kode enn nødvendig, Kolbe gjennomførte samtalene klassebaserte visninger, et konsept han har lånt fra Django, og som lar oss skrive klasser som vi vil generere visninger med, kan disse klassene være generiske som vi kan gjøre arv til hvis vi ønsker det.

For å bruke denne typen komponenter må vi først importere fra flask.views, hvor klassen Utsikt Det er en generisk klasse som lar oss legge til de grunnleggende funksjonene for å kunne sende ruter og definere metoder.

Å skape vårt klassebaserte syn

I dette eksemplet skal vi lage det samme synet som vi gjorde i det forrige eksemplet, men fra en klassebasert tilnærming, på denne måten kan vi etablere forskjellene mellom begge skjemaene, husk at selv om det ikke vises i eksempelkoden, vi har laget import i klassen View.

La oss se på koden for vårt eksempel:

 class ViewClass (View): methods = ['GET', 'POST',] def dispatch_request (self): if request.method == "GET": return '' 'Show Views' '' if request.method == " POST ": value = request.form.get ('content', 'sample') return 'Dette er en visning som bruker GET og POST som mottar en verdi:% s'% valorapp.add_url_rule ('/ view-class', view_func = VistaClase.as_view ('view-class'))

Dette er den mest grunnleggende formen for denne visningen, men vi ser at vi ikke lenger er avhengige av dekoratør, det vi gjør er å kalle metoden dispatch_request og vi passerte ham selv- slik at den får det samme objektet med dette kan vi bestemme forespørslene vi mottar, så indikerer vi at vi vil motta begge metodene og til slutt definerer vi atferden vår, resultatet per nettleser vil være det samme som den forrige, vi vil ha en feltet, og når vi sender det, vil vi motta det angitte svaret.

Men hva om vi vil skrive mye renere kode? Til dette kan vi bruke klassen MethodView av Kolbe som lar oss lage metoder innen klassen for å definere metodene HTTP på en enklere måte.

La oss se følgende eksempel hvor vi omskriver den forrige koden for å bruke denne modusen:

 class ViewClass (MethodView): def get (self): return '' 'Show Views' '' def post (self): value = request.form.get ('content', 'sample') return 'This is a view using GET and POST som mottar en verdi:% s '% valorapp.add_url_rule ('/ view-class ', view_func = ViewClass.as_view (' view-class '))

Som vi kan se, har vi dispensert fra definisjonen av metodene vi vil motta, i tillegg bruker vi ikke lenger metoden utsendelse, vi definerer ganske enkelt hva vi skal gjøre i metoden POST, og hva vi vil gjøre i GET, og dermed gi mye mer rengjøring for synet vårt.

Det er fortsatt en debatt om at hvis det er bedre rollebaserte synspunkter bølger klassebasert, men det er virkelig ikke den ene bedre enn den andre, det er ganske enkelt to måter å jobbe på. Anbefalingen er at hvis utsikten er veldig enkel kan vi gjøre det med funksjoner, og hvis den allerede har en mer fullstendig logikk, gjør vi det med klasser .

Med dette har vi fullført denne opplæringen, der vi har bygget en viktig base ved å vite hvordan visninger fungerer og hvordan vi kan jobbe med deres forskjellige metoder HTTP, siden dette er grunnlaget som vi kan bruke til å lage mer avanserte applikasjoner.