Share
Dans la première partie de cette série de didacticiels en trois parties, nous avons vu comment structurer la structure du modèle dans une application basée sur Flask utilisant Jinja2. Nous avons également vu comment utiliser des blocs pour exploiter l'héritage dans les modèles. Dans cette partie, nous verrons comment écrire un filtre personnalisé, un processeur de contexte personnalisé et une macro.
Je vais développer l'application de catalogue que nous avons créée dans la première partie de cette série. Je vais d’abord ajouter un processeur de contexte Jinja2 personnalisé pour afficher un nom descriptif pour chaque produit. Ensuite, je créerai un filtre Jinja2 personnalisé pour faire le même travail que le processeur de contexte personnalisé. Ensuite, je montrerai comment créer une macro Jinja2 personnalisée pour les champs de formulaire standard.
Parfois, nous pouvons vouloir calculer ou traiter une valeur directement dans les modèles. Jinja2 maintient l'idée que le traitement de la logique doit être traité dans des vues et non dans des modèles, et maintient donc les modèles propres. Un processeur de contexte devient un outil pratique dans ce cas. Nous pouvons transmettre nos valeurs à une méthode; cela sera ensuite traité dans une méthode Python et notre valeur résultante sera retournée. Par conséquent, nous ajoutons simplement une fonction au contexte du modèle (merci à Python de nous avoir permis de transmettre des fonctions comme n'importe quel autre objet)..
Alors, disons que nous voulons ajouter un nom descriptif pour chaque produit dans le format Nom de catégorie / produit. Pour cela, il faut ajouter une méthode, qui doit être décoré avec @ app.context_processor.
@ app.context_processor def some_processor (): def nom complet (produit): return '0 / 1'. format (produit ['catégorie'], produit ['nom']]) return 'nom complet': nom complet
Techniquement, un contexte est juste un dictionnaire Python qui peut être modifié pour ajouter et supprimer des valeurs. Toute méthode avec le décorateur spécifié doit renvoyer un dictionnaire permettant de mettre à jour le contexte actuel de l'application..
Pour utiliser ce processeur de contexte, ajoutez simplement la balise Jinja2 suivante dans le modèle..
full_name (product)
Si nous ajoutons ceci à cela flask_app / templates / product.html de notre application, cela ressemblerait à:
% extended 'home.html'% % le conteneur de blocs%% endblock%full_name (product)
produit ['nom'] catégorie de produit']
$ produit ['prix']
La page de produit résultante ressemblerait maintenant à:
Après avoir examiné l'exemple ci-dessus, des développeurs expérimentés pourraient penser qu'il était stupide d'utiliser un processeur de contexte à cette fin. On peut simplement écrire un filtre pour obtenir le même résultat; cela rendra les choses beaucoup plus propres. Un filtre peut être écrit pour afficher le nom descriptif du produit comme indiqué ci-dessous.
Accentsconagua
@ app.template_filter ('full_name') def full_name_filter (product): renvoie le format '0 / 1'. (product ['category'], product ['name']) Ce filtre peut être utilisé comme un filtre normal, c’est-à-dire en ajoutant un | (tuyau) symbole puis le nom du filtre.
produit | nom_complet
Le filtre ci-dessus donnerait le même résultat que le processeur de contexte l'a démontré il y a un certain temps.
Pour porter les choses à un niveau supérieur, créons un filtre qui formatera la devise en fonction de la langue locale du navigateur. Pour cela, nous devons d’abord installer un paquet Python nommé ccy.
$ pip install ccy
Maintenant, nous devons ajouter une méthode pour le filtre de devise.
importer ccy depuis la fiole demande d'importation @ app.template_filter ('format_currency') def format_currency_filter (montant): code_monnaie = ccy.countryccy (request.accept_languages.best [-2:]) renvoie le format '0 1'. currency_code, montant)Pour utiliser ce filtre, nous devons ajouter les éléments suivants dans notre modèle:
product ['price'] | format_currency
Maintenant, la page du produit ressemblerait à ceci:
Les macros nous permettent d’écrire des morceaux réutilisables de blocs HTML. Ils sont analogues aux fonctions des langages de programmation habituels. Nous pouvons transmettre des arguments aux macros comme aux fonctions en Python, puis les utiliser pour traiter le bloc HTML. Les macros peuvent être appelées à n’importe quel nombre de fois, et la sortie variera en fonction de la logique à l’intérieur. Travailler avec des macros dans Jinja2 est un sujet très courant et a de nombreux cas d'utilisation. Ici, nous verrons simplement comment une macro peut être créée puis utilisée après importation.
L'un des éléments de code les plus redondants en HTML consiste à définir des champs de saisie dans les formulaires. La plupart des champs ont un code similaire avec quelques modifications de style, etc. Voici une macro qui crée des champs de saisie à l'appel. La meilleure pratique consiste à créer la macro dans un fichier séparé pour une meilleure réutilisation, par exemple, _helpers.html:
% macro render_field (name ,, type = "text") -% % - endmacro%
Maintenant, cette macro doit être importée dans le fichier à utiliser:
% from '_helpers.jinja' import render_field%
Ensuite, il peut simplement être appelé en utilisant ce qui suit:
Il est toujours recommandé de définir des macros dans un fichier différent afin de maintenir le code propre et d'améliorer sa lisibilité. Si une macro privée inaccessible à partir du fichier actuel est nécessaire, nommez-la avec un trait de soulignement précédant le nom..
Dans ce tutoriel, nous avons vu comment écrire un filtre personnalisé, un processeur de contexte personnalisé et une macro personnalisée pour les formulaires. Dans la prochaine partie de cette série, nous verrons comment implémenter le formatage avancé de la date et de l'heure au niveau du modèle dans Jinja2 à l'aide de moment.js..
