Byggnadsutsikt i Flask

Inom modellen eller utvecklingsparadigmet som den föreslår FlaskaEn av de viktigaste punkterna är hanteringen av vyerna, eftersom dessa tillåter oss att definiera hur användaren kommer att interagera med vår sida eller applikation.

Det enklaste sättet att arbeta med en vy är att definiera operationen direkt i definitionen av dess väg, men detta är inte alltid användbart eller tillräckligt, särskilt om vi bygger stora applikationer.

KravVi behöver en funktionell installation av Flaska och av kompatibilitetsskäl behöver vi en version som är högre än den 0.7 eftersom en av komponenterna som vi kommer att arbeta med inte ingick i ramverket förrän efter versionen. Vi måste också starta en applikation eller ha någon applikation Flaska så att vi kan inkludera exemplen i vyavsnittet och på så sätt kunna köra dem med webbläsare.

Rollbaserade vyer

Det är ett av de enklaste sätten att bygga interaktion med användaren, vi behöver bara skriva en funktion och dekorera den med rutten, detta gör när routern Flaska tar emot begäran, den kontrollerar om det finns en funktion som väntar på nämnda rutt, och sedan om den får den kör den den.

I allmänhet kräver denna typ av visningar åtminstone metoden SKAFFA SIG av HTTPSom en god praxis och av säkerhetsskäl kan vi dock använda metoden om vi vill lägga till värden i vår datastabilitet. POSTA.

Skapa en vy med GET

Vi ska skapa en vy med hjälp av metoden SKAFFA SIGFör att göra detta måste du helt enkelt definiera dess namn i en funktion och tilldela en rutt till den, sedan inuti funktionen kommer vi att placera vårt innehåll, låt oss se följande kod för att illustrera oss själva.

 @ app.route ('/ view-get') def view (): value = request.args.get ('content', 'sample') return 'Detta är en vy som använder GET och får ett värde:% s'% värde

I koden ser vi hur vi använder dekoratör För att ange vilken rutt vi väntar på definierar vi motsvarande funktion och inom detta ringer vi med begäran till de argument som mottagits av SKAFFA SIG, i det här fallet söker vi efter ett argument som kallas innehåll och tilldelar det till en variabel som kallas värde, om detta argument inte existerar kommer "sample" att placeras som standardvärde, och slutligen returnerar vi en text och skickar värdinnehållet .

Om vi ​​kör vårt exempel i webbläsaren skulle vi få följande:

Skapa en vy med POST

Vad händer om det vi vill är att ta emot känslig data och vi inte vill skicka den genom parametrar i URL: en, för i dessa fall måste vi använda POST -metoden, eftersom den skickar data som är dold från användarens syn, förstås där är andra säkerhetsåtgärder som vi bör använda men för närvarande behöver vi dem inte för detta fall.

För att skapa en vy som tar emot data från POST behöver du bara ange den förväntade metoden i dekoratör som tar emot den rutt vi vill ha, för detta använder vi den extra parametern metoder.

Sedan inom vår funktion kan vi använda begäran för att erhålla värdena måste vi, till skillnad från föregående exempel, istället för att kräva argumenten ange att vi tar emot värdena från ett formulär. Låt oss titta på koden för vad vi just förklarade.

 @ app.route ('/ post-view', methods = ['POST',]) def post_view (): value = request.form.get ('content', 'sample') return 'Detta är en vy med POST och får ett värde:% s '% värde

Vi kan märka att det är nästan samma kod som ovan förutom de skillnader som redan nämnts, men låt oss se vad som händer om vi kör vår kod direkt i vår webbläsare:

FÖRSTORA

Hur anger vi bara att vi kan ta emot metoden POSTA, vid åtkomst via SKAFFA SIG vår ansökan avvisar posten och skickar oss därför en kod 405 Metod är inte tillåten, så utan värden som kommer från en POST -begäran kommer denna vy inte att visa någon information.

Kombinera GET och POST i vyn

Eftersom hantering av olika vyer för varje metod inte alltid är vad vi vill, kan vi använda båda metoderna i samma vy, detta är mycket användbart, särskilt när vi vill bearbeta formulär, till exempel med metoden SKAFFA SIG vi visar formen och med POSTA vi behandlar försändelsen av samma.

För att använda det här läget behöver vi bara lägga till SKAFFA SIG i listan som vi gick vidare till metoder när du definierar dekoratör med sökvägen, låt oss se koden nedan:

 @ app.route ('/ view', methods = ['GET', 'POST',]) def view (): if request.method == "GET": return '' 'Show Views' '' else: value = request.form.get ('content', 'sample') return 'Detta är en vy med GET och POST som får ett värde:% s'% value

När du ringer rutten från webbläsaren med metod SKAFFA SIG vi får följande:

Genom att skriva något i textfältet och trycka på Enter skickar vi formuläret till samma sökväg men med metoden POSTA, vilket ger oss ett resultat som följande:

Här har vi sedan skrivit en sann funktionsbaserad vy, som gör att vi kan använda och dra nytta av båda metoderna för HTTP att göra vår verksamhet.

Klassbaserade vyer

Eftersom skapandet av funktioner även om de tjänar våra syften ibland är mycket krångligt och lämnar sig för att ha mer kod än nödvändigt, Flaska genomförde samtalen klassbaserade åsikter, ett koncept han har lånat av Django, och som gör att vi kan skriva klasser med vilka vi kommer att generera vyer, dessa klasser kan vara generiska som vi kan göra arv om vi vill.

För att kunna använda den här typen av komponenter måste vi först importera från kolv. visningar, där klassen Se Det är en generisk klass som gör att vi kan lägga till de grundläggande funktionerna för att kunna skicka rutter och definiera metoder.

Skapa vår klassbaserade vy

I det här exemplet kommer vi att skapa samma uppfattning som vi gjorde i det föregående exemplet men från ett klassbaserat tillvägagångssätt, på så sätt kan vi fastställa skillnaderna mellan båda formerna, kom ihåg att även om det inte visas i exempelkoden, vi har gjort importera i klassen View.

Låt oss titta på koden för vårt exempel:

 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 'Detta är en vy med GET och POST som får ett värde:% s'% valorapp.add_url_rule ('/ view-class', view_func = VistaClase.as_view ('view-class'))

Detta är den mest grundläggande formen av denna visningsstil, men vi ser att vi inte längre är beroende av dekoratör, det vi gör är att kalla metoden dispatch_request och vi passerade honom själv så att det får samma objekt med detta kan vi bestämma de förfrågningar vi får, sedan anger vi att vi kommer att få båda metoderna och slutligen definierar vi vårt beteende, resultatet per webbläsare blir detsamma som det föregående, vi kommer att ha en fält och när vi skickar det får vi det angivna svaret.

Men vad händer om vi vill skriva mycket renare kod? För detta kan vi använda klassen MethodView av Flaska vilket gör att vi kan skapa metoder inom klassen för att definiera metoderna HTTP på ett enklare sätt.

Låt oss se följande exempel där vi skriver om den tidigare koden för att använda det här läget:

 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 får ett värde:% s '% valorapp.add_url_rule ('/ view-class ', view_func = ViewClass.as_view (' view-class '))

Som vi kan se har vi avstått från definitionen av de metoder som vi kommer att få, dessutom använder vi inte längre metoden avsändande, vi definierar helt enkelt vad vi ska göra i metoden POSTA, och vad vi kommer att göra i GET, vilket ger mycket mer rengöring av vår syn.

Det finns fortfarande en debatt om att det är bättre att rollbaserade åsikter vågor klassbaserad, men det finns verkligen inte det ena bättre än det andra, det finns helt enkelt två sätt att arbeta, rekommendationen är att om vyn är väldigt enkel kan vi göra det med funktioner och om det redan har en mer fullständig logik gör vi det med klasser .

Med detta har vi avslutat denna handledning, där vi har byggt en viktig bas genom att veta hur åsikter fungerar och hur vi kan arbeta med deras olika metoder HTTP, eftersom detta är grunden som vi kan använda för att skapa mer avancerade applikationer.