Création de vues dans Flask

Dans le modèle ou paradigme de développement qu'il propose BallonL'un des points les plus importants est la gestion des vues, car celles-ci nous permettent de définir la manière dont l'utilisateur interagira avec notre page ou application.

La façon la plus simple de travailler avec une vue est de définir l'opération directement dans la définition de son chemin, cependant ce n'est pas toujours utile ou adéquat, surtout si nous construisons de grosses applications.

ExigencesNous avons besoin d'une installation fonctionnelle de Ballon et pour des raisons de compatibilité nous avons besoin d'une version supérieure à celle 0.7 car l'un des composants avec lesquels nous allons travailler n'a été inclus dans le framework qu'après ladite version. Nous devons également démarrer une application ou avoir une application Ballon afin que nous puissions inclure les exemples dans la section vues et ainsi pouvoir les exécuter par navigateur.

Vues basées sur les rôles

C'est l'un des moyens les plus simples de créer une interaction avec l'utilisateur, il suffit d'écrire une fonction et de la décorer avec la route, cela fait quand le routeur Ballon reçoit la requête, il vérifie s'il y a une fonction en attente de ladite route, puis s'il l'obtient, il l'exécute.

Généralement ce type de vues nécessite au moins la méthode AVOIR de HTTPCependant, à titre de bonne pratique et pour des raisons de sécurité, si nous souhaitons ajouter des valeurs à notre structure de persistance des données, nous pouvons également utiliser la méthode PUBLIER.

Créer une vue avec GET

Nous allons créer une vue en utilisant la méthode AVOIRPour ce faire, il vous suffit de définir son nom dans une fonction et de lui affecter une route, puis à l'intérieur de la fonction nous placerons notre contenu, voyons le code suivant pour nous illustrer.

 @ app.route ('/ view-get') def view (): value = request.args.get ('content', 'sample') return 'Ceci est une vue utilisant GET et reçoit une valeur :% s'% valeur

Dans le code, nous voyons comment nous utilisons le décorateur Pour indiquer quel itinéraire nous attendons, nous définissons la fonction correspondante et à l'intérieur de celle-ci nous effectuons un appel avec demande aux arguments reçus par AVOIR, dans ce cas nous recherchons un argument appelé content et l'assignons à une variable appelée value, si cet argument n'existe pas, "sample" sera placé comme valeur par défaut, et enfin nous retournons un texte et passons le contenu de value .

Si nous exécutons notre exemple dans le navigateur, nous obtiendrons ce qui suit :

Créer une vue avec POST

Que se passe-t-il si ce que nous voulons, c'est recevoir des données sensibles et que nous ne voulons pas les passer par des paramètres dans l'URL, car dans ces cas, nous devons utiliser la méthode POST, car elle envoie les données cachées à la vue de l'utilisateur, bien sûr là sont d'autres mesures de sécurité que nous devrions utiliser mais pour le moment nous n'en avons pas besoin pour ce cas.

Pour construire une vue qui reçoit des données par POST, il suffit d'indiquer la méthode attendue dans le décorateur qui reçoit la route que l'on veut, pour cela on utilise le paramètre supplémentaire méthodes.

Ensuite, dans notre fonction, nous pouvons utiliser demande pour obtenir les valeurs, cependant, contrairement à l'exemple précédent, au lieu d'exiger les arguments, nous devons indiquer que nous recevons les valeurs d'un formulaire. Regardons le code pour ce que nous venons d'expliquer.

 @ app.route ('/ post-view', methodes = ['POST',]) def post_view (): value = request.form.get ('content', 'sample') return 'Ceci est une vue utilisant POST et reçoit une valeur : % s'% valeur

On peut remarquer qu'il s'agit presque du même code que ci-dessus à l'exception des différences déjà mentionnées, mais voyons ce qui se passe si nous exécutons notre code directement dans notre navigateur :

AGRANDIR

Comment pouvons-nous seulement spécifier que nous pouvons recevoir la méthode PUBLIER, lors de l'accès via AVOIR notre application rejette l'entrée et nous envoie donc un code 405 Méthode non autorisée, donc sans valeurs provenant d'une requête POST, cette vue n'affichera aucune information.

Combiner GET et POST dans la vue

Comme gérer des vues différentes pour chaque méthode n'est pas toujours ce que l'on veut, on peut utiliser les deux méthodes dans la même vue, c'est très utile surtout quand on veut traiter des formulaires, par exemple, avec la méthode AVOIR on montre la forme et avec PUBLIER nous traitons l'expédition de la même chose.

Pour utiliser ce mode, il suffit d'ajouter AVOIR dans la liste que nous avons passée à méthodes lors de la définition du décorateur avec le chemin, voyons le code ci-dessous :

 @ app.route ('/ view', methodes = ['GET', 'POST',]) def view (): if request.method == "GET": return '' 'Show Views' '' else: value = request.form.get ('content', 'sample') return 'Ceci est une vue utilisant GET et POST qui reçoit une valeur :% s'% value

Lors de l'appel de la route depuis le navigateur avec la méthode AVOIR on obtient ce qui suit :

Ensuite, en écrivant quelque chose dans le champ de texte et en appuyant sur Entrée, nous envoyons le formulaire sur son même chemin mais avec la méthode PUBLIER, ce qui nous donne un résultat comme le suivant :

Ici, nous avons ensuite écrit une véritable vue basée sur les fonctions, qui nous permet d'utiliser et de tirer parti des deux méthodes de HTTP pour faire nos opérations.

Vues basées sur les classes

Comme la création de fonctions même si elles servent à nos fins est parfois très lourde et se prête à avoir plus de code que nécessaire, Ballon mis en œuvre les appels vues basées sur les classes, un concept qu'il a emprunté Django, et cela nous permet d'écrire des classes avec lesquelles nous allons générer des vues, ces classes peuvent être génériques avec lesquelles nous pouvons faire de l'héritage si nous le souhaitons.

Pour utiliser ce type de composant, nous devons d'abord importer de fiole.vues, où la classe Vue C'est une classe générique qui va nous permettre d'ajouter les fonctionnalités de base pour pouvoir dispatcher des routes et définir des méthodes.

Créer notre vue basée sur les classes

Dans cet exemple, nous allons créer la même vue que dans l'exemple précédent mais à partir d'une approche basée sur les classes, de cette manière, nous pouvons établir les différences entre les deux formes, rappelez-vous que même si cela n'apparaît pas dans l'exemple de code, nous avons fait le importer de la classe View.

Regardons le code de notre exemple :

 class ViewClass (View): methodes = ['GET', 'POST',] def dispatch_request (self): if request.method == "GET": return '' 'Show Views' '' if request.method == " POST " : value = request.form.get ('content', 'sample') return 'Ceci est une vue utilisant GET et POST qui reçoit une valeur :% s'% valorapp.add_url_rule ('/ view-class', view_func = VistaClase.as_view ('view-class'))

C'est la forme la plus basique de ce style de vues, cependant nous voyons que nous ne dépendons plus de la décorateur, ce que nous faisons est d'appeler la méthode dispatch_request et nous l'avons dépassé soi pour qu'il reçoive son même objet avec cela nous pouvons déterminer les requêtes que nous recevons, puis nous indiquons que nous recevrons les deux méthodes et enfin nous définissons nos comportements, le résultat par navigateur sera le même que le précédent, nous aurons un champ et lorsque nous l'envoyons, nous recevrons la réponse spécifiée.

Mais que se passe-t-il si nous voulons écrire un code beaucoup plus propre ? Pour cela, nous pouvons utiliser la classe MethodView de Ballon qui nous permet de créer des méthodes au sein de la classe pour définir les méthodes HTTP d'une manière plus simple.

Voyons l'exemple suivant où nous réécrivons le code précédent pour utiliser ce mode :

 class ViewClass (MethodView): def get (self): return '' 'Show Views'' 'def post (self): value = request.form.get (' content ',' sample ') return' Ceci est une vue utilisant GET et POST qui reçoivent une valeur : % s'% valorapp.add_url_rule ('/ view-class', view_func = ViewClass.as_view (' view-class'))

Comme on peut le voir, nous avons renoncé à la définition des méthodes que nous allons recevoir, en plus nous n'utilisons plus la méthode envoi, on définit simplement ce qu'on va faire dans la méthode PUBLIER, et ce que nous ferons dans le GET, donnant ainsi beaucoup plus de nettoyage à notre vue.

Il y a encore un débat selon lequel s'il vaut mieux vues basées sur les rôles vagues basé sur la classe, mais il n'y a vraiment pas l'un meilleur que l'autre, il y a simplement deux façons de travailler, la recommandation est que si la vue est très simple on peut le faire avec des fonctions et si elle a déjà une logique plus complète on le fait avec des classes .

Avec cela, nous avons terminé ce tutoriel, dans lequel nous avons construit une base importante en sachant comment fonctionnent les vues et comment nous pouvons travailler avec leurs différentes méthodes HTTP, car c'est la base que nous pouvons utiliser pour créer des applications plus avancées.