Viste degli edifici a Flask

All'interno del modello o paradigma di sviluppo che propone BorracciaUno dei punti più importanti è la gestione delle visualizzazioni, poiché queste ci permettono di definire il modo in cui l'utente interagirà con la nostra pagina o applicazione.

Il modo più semplice per lavorare con una vista è definire l'operazione direttamente nella definizione del suo percorso, tuttavia questo non è sempre utile o adeguato, soprattutto se costruiamo applicazioni di grandi dimensioni.

RequisitiAbbiamo bisogno di un'installazione funzionale di Borraccia e per motivi di compatibilità abbiamo bisogno di una versione superiore a quella 0.7 poiché uno dei componenti con cui lavoreremo non è stato incluso nel framework fino a dopo tale versione. Dobbiamo anche avviare un'applicazione o avere qualche applicazione Borraccia in modo che possiamo includere gli esempi nella sezione delle viste e quindi essere in grado di eseguirli tramite browser.

Viste basate sui ruoli

È uno dei modi più semplici per costruire l'interazione con l'utente, dobbiamo solo scrivere una funzione e decorarla con il percorso, questo fa quando il router Borraccia riceve la richiesta, verifica se c'è una funzione in attesa di detta route, quindi se la riceve, la esegue.

Generalmente questo tipo di viste richiede almeno il metodo OTTENERE di HTTPTuttavia, come buona pratica e per motivi di sicurezza, se vogliamo aggiungere valori alla nostra struttura di persistenza dei dati, possiamo anche utilizzare il metodo INVIARE.

Creare una vista con GET

Creeremo una vista usando il metodo OTTENEREPer fare ciò, devi semplicemente definire il suo nome in una funzione e assegnarle un percorso, quindi all'interno della funzione inseriremo il nostro contenuto, vediamo il codice seguente per illustrarci.

 @ app.route ('/ view-get') def view (): value = request.args.get ('content', 'sample') return 'Questa è una vista che usa GET e riceve un valore:% s'% valore

Nel codice poi vediamo come usiamo il decoratore Per indicare quale rotta stiamo aspettando, definiamo la funzione corrispondente e all'interno di questa effettuiamo una chiamata con richiesta alle argomentazioni ricevute da OTTENERE, in questo caso cerchiamo un argomento chiamato content e lo assegniamo a una variabile chiamata value, se questo argomento non esiste, "sample" verrà posizionato come valore predefinito, e infine restituiamo un testo e passiamo il contenuto di value .

Se eseguiamo il nostro esempio nel browser, otterremo quanto segue:

Creazione di una vista con POST

Cosa succede se quello che vogliamo è ricevere dati sensibili e non vogliamo passarli attraverso parametri nell'URL, perché in questi casi dobbiamo usare il metodo POST, poiché invia i dati nascosti alla vista dell'utente, ovviamente lì sono altre misure di sicurezza che dovremmo usare ma al momento non ne abbiamo bisogno per questo caso.

Per costruire una vista che riceve i dati tramite POST, devi solo indicare il metodo previsto nel decoratore che riceve il percorso che vogliamo, per questo usiamo il parametro aggiuntivo metodi.

Quindi all'interno della nostra funzione possiamo usare richiesta per ottenere i valori però, a differenza dell'esempio precedente, invece di richiedere gli argomenti, dobbiamo indicare che stiamo ricevendo i valori da un form. Diamo un'occhiata al codice per ciò che abbiamo appena spiegato.

 @ app.route ('/ post-view', method = ['POST',]) def post_view (): value = request.form.get ('content', 'sample') return 'Questa è una vista che utilizza POST e riceve un valore:% s'% valore

Possiamo notare che è quasi lo stesso codice di sopra tranne per le differenze già menzionate, ma vediamo cosa succede se eseguiamo il nostro codice direttamente nel nostro browser:

INGRANDIRE

Come facciamo a specificare solo che possiamo ricevere il metodo INVIARE, quando si accede tramite OTTENERE la nostra domanda rifiuta l'iscrizione e quindi ci invia un codice 405 Metodo non consentito, quindi senza valori provenienti da una richiesta POST questa vista non mostrerà alcuna informazione.

Combinando GET e POST nella vista

Poiché la gestione di viste diverse per ciascun metodo non è sempre ciò che vogliamo, possiamo utilizzare entrambi i metodi nella stessa vista, questo è molto utile soprattutto quando vogliamo elaborare i moduli, ad esempio con il metodo OTTENERE mostriamo la forma e con INVIARE elaboriamo la spedizione degli stessi.

Per utilizzare questa modalità dobbiamo solo aggiungere OTTENERE nella lista a cui siamo passati metodi quando si definisce il decoratore con il percorso, vediamo il codice qui sotto:

 @ app.route ('/ view', method = ['GET', 'POST',]) def view (): if request.method == "GET": return '' 'Show Views' '' else: value = request.form.get ('content', 'sample') return 'Questa è una vista che utilizza GET e POST che riceve un valore:% s'% valore

Quando si chiama il percorso dal browser con il metodo OTTENERE otteniamo quanto segue:

Quindi scrivendo qualcosa nel campo di testo e premendo Invio stiamo inviando il modulo al suo stesso percorso ma con il metodo INVIARE, che ci dà un risultato come il seguente:

Qui abbiamo quindi scritto una vera vista basata sulle funzioni, che ci permette di utilizzare e sfruttare entrambi i metodi di HTTP per fare le nostre operazioni.

Viste basate sulla classe

Poiché la creazione di funzioni anche se servono ai nostri scopi è a volte molto macchinosa e si presta ad avere più codice del necessario, Borraccia implementato le chiamate viste basate sulla classe, un concetto da cui ha preso in prestito Django, e questo ci consente di scrivere classi con le quali genereremo viste, queste classi possono essere generiche con le quali possiamo fare ereditarietà se lo desideriamo.

Per utilizzare questo tipo di componente dobbiamo prima importare da flask.views, dove la classe Visualizzazione È una classe generica che ci permetterà di aggiungere le funzionalità di base per poter inviare rotte e definire metodi.

Creare la nostra vista basata sulla classe

In questo esempio creeremo la stessa vista che abbiamo fatto nell'esempio precedente ma da un approccio basato sulle classi, in questo modo possiamo stabilire le differenze tra entrambe le forme, ricorda che sebbene non appaia nel codice di esempio, abbiamo fatto il importare della classe View.

Diamo un'occhiata al codice per il nostro esempio:

 class ViewClass (View): method = ['GET', 'POST',] def dispatch_request (self): if request.method == "GET": return '' 'Show Views' '' if request.method == " POST ": value = request.form.get ('content', 'sample') return 'Questa è una vista che utilizza GET e POST che riceve un valore:% s'% valorapp.add_url_rule ('/ view-class', view_func = VistaClase.as_view ('classe di visualizzazione'))

Questa è la forma più elementare di questo stile di vista, tuttavia vediamo che non dipendiamo più dal decoratore, quello che facciamo è chiamare il metodo dispatch_request e lo abbiamo superato se stesso in modo che riceva il suo stesso oggetto con questo possiamo determinare le richieste che riceviamo, quindi indichiamo che riceveremo entrambi i metodi e infine definiamo i nostri comportamenti, il risultato per browser sarà lo stesso del precedente, avremo un campo e quando lo invieremo riceveremo la risposta specificata.

Ma cosa succede se volessimo scrivere un codice molto più pulito? Per questo possiamo usare la classe MethodView di Borraccia che ci permette di creare metodi all'interno della classe per definire i metodi HTTP in modo più semplice.

Vediamo il seguente esempio in cui riscriviamo il codice precedente per utilizzare questa modalità:

 class ViewClass (MethodView): def get (self): return '' 'Show Views'' 'def post (self): value = request.form.get (' content ',' sample ') return' Questa è una vista che usa GET e POST che riceve un valore:% s'% valorapp.add_url_rule ('/view-class', view_func = ViewClass.as_view ('view-class'))

Come possiamo vedere, abbiamo rinunciato alla definizione dei metodi che riceveremo, inoltre non utilizziamo più il metodo spedizione, definiamo semplicemente cosa faremo nel metodo INVIARE, e cosa faremo nel GET, dando così molta più pulizia alla nostra vista.

C'è ancora un dibattito sul fatto che se è meglio visualizzazioni basate sui ruoli onde basato sulla classe, ma in realtà non ce n'è uno migliore dell'altro, ci sono semplicemente due modi di lavorare, la raccomandazione è che se la vista è molto semplice possiamo farlo con le funzioni e se ha già una logica più completa lo facciamo con le classi .

Con questo abbiamo finito questo tutorial, in cui abbiamo costruito una base importante sapendo come funzionano le viste e come possiamo lavorare con i loro diversi metodi HTTP, poiché questa è la base che possiamo utilizzare per creare applicazioni più avanzate.