Django
templating
Ricerca…
variabili
È possibile accedere alle variabili fornite nel contesto della vista utilizzando la notazione doppia coppia:
Nel tuo views.py :
class UserView(TemplateView):
""" Supply the request user object to the template """
template_name = "user.html"
def get_context_data(self, **kwargs):
context = super(UserView, self).get_context_data(**kwargs)
context.update(user=self.request.user)
return context
In user.html :
<h1>{{ user.username }}</h1>
<div class="email">{{ user.email }}</div>
La notazione dot avrà accesso a:
- le proprietà dell'oggetto, ad es.
user.usernamesarà{{ user.username }} - ricerche nel dizionario, ad esempio
request.GET["search"]sarà{{ request.GET.search }} - metodi senza argomenti, ad esempio
users.count()sarà{{ user.count }}
Le variabili del modello non possono accedere ai metodi che accettano argomenti.
Le variabili possono anche essere testate e ripetute:
{% if user.is_authenticated %}
{% for item in menu %}
<li><a href="{{ item.url }}">{{ item.name }}</a></li>
{% endfor %}
{% else %}
<li><a href="{% url 'login' %}">Login</a>
{% endif %}
Si accede agli URL utilizzando il formato {% url 'name' %} , dove i nomi corrispondono ai nomi nel tuo urls.py
{% url 'login' %} - Probabilmente verrà visualizzato come /accounts/login/
{% url 'user_profile' user.id %} - Gli argomenti per gli URL sono forniti in ordine
{% url next %} : gli URL possono essere variabili
Templating in Views basate su classi
Puoi passare i dati a un modello in una variabile personalizzata.
Nel tuo views.py :
from django.views.generic import TemplateView
from MyProject.myapp.models import Item
class ItemView(TemplateView):
template_name = "item.html"
def items(self):
""" Get all Items """
return Item.objects.all()
def certain_items(self):
""" Get certain Items """
return Item.objects.filter(model_field="certain")
def categories(self):
""" Get categories related to this Item """
return Item.objects.get(slug=self.kwargs['slug']).categories.all()
Una semplice lista nel tuo item.html :
{% for item in view.items %}
<ul>
<li>{{ item }}</li>
</ul>
{% endfor %}
È anche possibile recuperare proprietà aggiuntive dei dati.
Assumendo che il modello di Item ha un name di campo:
{% for item in view.certain_items %}
<ul>
<li>{{ item.name }}</li>
</ul>
{% endfor %}
Templating in viste basate sulle funzioni
È possibile utilizzare un modello in una vista basata sulla funzione come segue:
from django.shortcuts import render
def view(request):
return render(request, "template.html")
Se si desidera utilizzare le variabili del modello, è possibile farlo come segue:
from django.shortcuts import render
def view(request):
context = {"var1": True, "var2": "foo"}
return render(request, "template.html", context=context)
Quindi, in template.html , puoi fare riferimento alle tue variabili in questo modo:
<html>
{% if var1 %}
<h1>{{ var2 }}</h1>
{% endif %}
</html>
Filtri modello
Il sistema di template Django ha tag e filtri integrati, che sono funzioni all'interno del template per rendere il contenuto in un modo specifico. È possibile specificare più filtri con pipe e i filtri possono avere argomenti, proprio come nella sintassi delle variabili.
{{ "MAINROAD 3222"|lower }} # mainroad 3222
{{ 10|add:15}} # 25
{{ "super"|add:"glue" }} # superglue
{{ "A7"|add:"00" }} # A700
{{ myDate | date:"D d M Y"}} # Wed 20 Jul 2016
Un elenco di filtri integrati disponibili può essere trovato su https://docs.djangoproject.com/en/dev/ref/templates/builtins/#ref-templates-builtins-filters .
Creazione di filtri personalizzati
Per aggiungere i tuoi filtri modello, crea una cartella denominata templatetags all'interno della cartella dell'app. Quindi aggiungi un __init__.py e il file il tuo file che conterrà i filtri:
#/myapp/templatetags/filters.py
from django import template
register = template.Library()
@register.filter(name='tostring')
def to_string(value):
return str(value)
Per utilizzare effettivamente il filtro è necessario caricarlo nel modello:
#templates/mytemplate.html
{% load filters %}
{% if customer_id|tostring = customer %} Welcome back {% endif%}
Trucchi
Anche se all'inizio i filtri sembrano semplici, consente di fare alcune cose interessanti:
{% for x in ""|ljust:"20" %}Hello World!{% endfor %} # Hello World!Hello World!Hel...
{{ user.name.split|join:"_" }} ## replaces whitespace with '_'
Vedi anche i tag dei modelli per maggiori informazioni.
Impedisci che i metodi sensibili vengano richiamati nei modelli
Quando un oggetto viene esposto al contesto del modello, sono disponibili i suoi metodi senza argomenti. Questo è utile quando queste funzioni sono "getter". Ma può essere pericoloso se questi metodi alterano alcuni dati o hanno alcuni effetti collaterali. Anche se probabilmente ti fidi dello scrittore di modelli, potrebbe non essere a conoscenza degli effetti collaterali di una funzione o pensare di chiamare l'attributo sbagliato per errore.
Dato il seguente modello:
class Foobar(models.Model):
points_credit = models.IntegerField()
def credit_points(self, nb_points=1):
"""Credit points and return the new points credit value."""
self.points_credit = F('points_credit') + nb_points
self.save(update_fields=['points_credit'])
return self.points_credit
Se scrivi questo, per errore, in un modello:
You have {{ foobar.credit_points }} points!
Ciò incrementerà il numero di punti ogni volta che viene chiamato il modello. E potresti anche non accorgertene.
Per evitare ciò, è necessario impostare l'attributo alters_data su True per i metodi con effetti collaterali. Ciò renderà impossibile chiamarli da un modello.
def credit_points(self, nb_points=1):
"""Credit points and return the new points credit value."""
self.points_credit = F('points_credit') + nb_points
self.save(update_fields=['points_credit'])
return self.points_credit
credit_points.alters_data = True
L'utilizzo di {% estende%}, {% include%} e {% blocchi%}
sommario
{% extends%} : dichiara il modello fornito come argomento come padre del modello corrente. Utilizzo:
{% extends 'parent_template.html' %}.{% block%} {% endblock%} : questo è usato per definire sezioni nei tuoi template, così che se un altro template estende questo, sarà in grado di sostituire qualunque codice html sia stato scritto al suo interno. I blocchi sono identificati dal loro nome. Utilizzo:
{% block content %} <html_code> {% endblock %}.{% include%} : questo inserirà un modello all'interno di quello corrente. Tieni presente che il modello incluso riceverà il contesto della richiesta e puoi dargli anche variabili personalizzate. Utilizzo di base:
{% include 'template_name.html' %}, utilizzo con variabili:{% include 'template_name.html' with variable='value' variable2=8 %}
Guida
Supponiamo che tu stia costruendo il tuo codice lato front-end con layout comuni per tutto il codice e non vuoi ripetere il codice per ogni modello. Django ti offre tag costruiti per farlo.
Supponiamo di avere un sito web di blog con 3 modelli che condividono lo stesso layout:
project_directory
..
templates
front-page.html
blogs.html
blog-detail.html
1) Definisci il file base.html ,
<html>
<head>
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>
2) Estendilo in blog.html come,
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% endblock %}
# None of the code written here will be added to the template
Qui abbiamo esteso il layout di base in modo che il suo layout HTML sia ora disponibile nel blog.html blog.html. Il concetto di { % block %} è l'ereditarietà del modello che ti consente di creare un modello di base "scheletro" che contiene tutti gli elementi comuni del tuo sito e definisce i blocchi che i modelli figlio possono sovrascrivere.
3) Supponiamo che tutti i tuoi 3 modelli abbiano anche lo stesso div HTML che definisce alcuni post popolari. Invece di scrivere 3 volte, crea un nuovo template posts.html .
blog.html
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% include 'posts.html' %} # includes posts.html in blog.html file without passing any data
<!-- or -->
{% include 'posts.html' with posts=postdata %} # includes posts.html in blog.html file with passing posts data which is context of view function returns.
{% endblock %}
