Django
templating
Zoeken…
Variabelen
Variabelen die u in uw weergavecontext hebt opgegeven, zijn toegankelijk via dubbele accolades:
In uw 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>
De puntnotatie geeft toegang tot:
- eigenschappen van het object, bijv.
user.usernameis{{ user.username }} - zoeken in woordenboeken, bijv.
request.GET["search"]zal{{ request.GET.search }} - methoden zonder argumenten, bijvoorbeeld
users.count()zijn{{ user.count }}
Sjabloonvariabelen hebben geen toegang tot methoden waarvoor argumenten nodig zijn.
Variabelen kunnen ook worden getest en doorgelust:
{% 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 %}
URL's worden geopend met de indeling {% url 'name' %} , waarbij de namen overeenkomen met namen in uw urls.py
{% url 'login' %} - Wordt waarschijnlijk weergegeven als /accounts/login/
{% url 'user_profile' user.id %} - Argumenten voor URL's worden op volgorde geleverd
{% url next %} - URL's kunnen variabelen zijn
Templeren in op klassen gebaseerde weergaven
U kunt gegevens doorgeven aan een sjabloon in een aangepaste variabele.
In uw 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()
Een eenvoudige lijst in uw item.html :
{% for item in view.items %}
<ul>
<li>{{ item }}</li>
</ul>
{% endfor %}
U kunt ook extra eigenschappen van de gegevens ophalen.
Ervan uitgaande dat uw model Item heeft een name veld:
{% for item in view.certain_items %}
<ul>
<li>{{ item.name }}</li>
</ul>
{% endfor %}
Templeren in op functies gebaseerde weergaven
U kunt als volgt een sjabloon in een functiegebaseerde weergave gebruiken:
from django.shortcuts import render
def view(request):
return render(request, "template.html")
Als u sjabloonvariabelen wilt gebruiken, kunt u dit als volgt doen:
from django.shortcuts import render
def view(request):
context = {"var1": True, "var2": "foo"}
return render(request, "template.html", context=context)
Vervolgens kunt u in template.html als volgt naar uw variabelen verwijzen:
<html>
{% if var1 %}
<h1>{{ var2 }}</h1>
{% endif %}
</html>
Sjabloonfilters
Het Django-sjabloonsysteem heeft ingebouwde tags en filters , functies in de sjabloon om inhoud op een specifieke manier weer te geven. Meerdere filters kunnen worden opgegeven met pijpen en filters kunnen argumenten hebben, net als bij variabele syntaxis.
{{ "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
Een lijst met beschikbare ingebouwde filters is te vinden op https://docs.djangoproject.com/en/dev/ref/templates/builtins/#ref-templates-builtins-filters .
Aangepaste filters maken
Om uw eigen sjabloonfilters toe te voegen, maakt u een map met de naam templatetags in uw app-map. Voeg vervolgens een __init__.py en het bestand dat uw bestand bevat met de filters:
#/myapp/templatetags/filters.py
from django import template
register = template.Library()
@register.filter(name='tostring')
def to_string(value):
return str(value)
Om het filter daadwerkelijk te gebruiken, moet u het in uw sjabloon laden:
#templates/mytemplate.html
{% load filters %}
{% if customer_id|tostring = customer %} Welcome back {% endif%}
Trucs
Hoewel de filters in het begin eenvoudig lijken, kunnen er enkele handige dingen worden gedaan:
{% for x in ""|ljust:"20" %}Hello World!{% endfor %} # Hello World!Hello World!Hel...
{{ user.name.split|join:"_" }} ## replaces whitespace with '_'
Zie ook sjabloontags voor meer informatie.
Voorkom dat gevoelige methoden in sjablonen worden aangeroepen
Wanneer een object wordt blootgesteld aan de sjablooncontext, zijn de methoden zonder argumenten beschikbaar. Dit is handig wanneer deze functies "getters" zijn. Maar het kan gevaarlijk zijn als deze methoden sommige gegevens wijzigen of sommige bijwerkingen hebben. Hoewel u de sjabloonschrijver waarschijnlijk vertrouwt, is hij zich mogelijk niet bewust van de bijwerkingen van een functie of denkt hij per ongeluk het verkeerde kenmerk te noemen.
Gegeven het volgende model:
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
Als u dit per ongeluk in een sjabloon schrijft:
You have {{ foobar.credit_points }} points!
Dit verhoogt het aantal punten telkens wanneer de sjabloon wordt opgeroepen. En je merkt het misschien niet eens.
Om dit te voorkomen, moet u het kenmerk alters_data op True voor methoden met bijwerkingen. Dit maakt het onmogelijk om ze vanuit een sjabloon op te roepen.
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
Gebruik van {% verlengt%}, {% include%} en {% blokken%}
samenvatting
{% verlengt%} : hiermee wordt de sjabloon als argument opgegeven als de bovenliggende sjabloon van de huidige sjabloon. Gebruik:
{% extends 'parent_template.html' %}.{% block%} {% endblock%} : dit wordt gebruikt om secties in uw sjablonen te definiëren, zodat als een andere sjabloon deze uitbreidt, deze de HTML-code die erin is geschreven, kan vervangen. Blokken worden geïdentificeerd door hun naam. Gebruik:
{% block content %} <html_code> {% endblock %}.{% include%} : hiermee wordt een sjabloon in de huidige sjabloon ingevoegd. Houd er rekening mee dat de opgenomen sjabloon de context van het verzoek ontvangt en dat u het ook aangepaste variabelen kunt geven. Basisgebruik:
{% include 'template_name.html' %}, gebruik met variabelen:{% include 'template_name.html' with variable='value' variable2=8 %}
Gids
Stel dat u uw front-side code opbouwt met gemeenschappelijke lay-outs voor alle code en dat u de code niet voor elke sjabloon wilt herhalen. Django geeft je hiervoor ingebouwde tags.
Stel dat we één blogwebsite hebben met 3 sjablonen die dezelfde lay-out delen:
project_directory
..
templates
front-page.html
blogs.html
blog-detail.html
1) Definieer base.html bestand,
<html>
<head>
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>
2) Breid het uit in blog.html zoals,
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% endblock %}
# None of the code written here will be added to the template
Hier hebben we de blog.html out uitgebreid, zodat de HTML-lay-out nu beschikbaar is in het blog.html bestand. Het concept van { % block %} is sjabloonovererving waarmee u een basisskelet voor een skelet kunt maken dat alle gemeenschappelijke elementen van uw site en definieert blokken die onderliggende sjablonen kunnen overschrijven.
3) Stel nu dat al je 3 templates ook met dezelfde HTML div die een aantal populaire posts.Instead van wordt geschreven de 3 keer creëren een nieuwe template definieert 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 %}