Django
mall
Sök…
variabler
Variabler som du har tillhandahållit i ditt visningssammanhang kan nås med dubbelstångsnotation:
I dina 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
I user.html :
<h1>{{ user.username }}</h1>
<div class="email">{{ user.email }}</div>
Punktnotationen kommer åt:
- objektets egenskaper, t.ex.
user.usernamekommer att vara{{ user.username }} - ordboksökningar, t.ex.
request.GET["search"]kommer att{{ request.GET.search }} - metoder utan argument, t.ex.
users.count()kommer att{{ user.count }}
Mallvariabler kan inte komma åt metoder som tar argument.
Variabler kan också testas och slingas över:
{% 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 %}
Webbadresser öppnas med formatet {% url 'name' %} , där namnen motsvarar namnen i din urls.py
{% url 'login' %} - Kommer förmodligen att visas som /accounts/login/
{% url 'user_profile' user.id %} - Argument för webbadresser levereras i ordning
{% url next %} - URL: er kan vara variabler
Templera i klassbaserade vyer
Du kan skicka data till en mall i en anpassad variabel.
I dina 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()
En enkel lista i item.html :
{% for item in view.items %}
<ul>
<li>{{ item }}</li>
</ul>
{% endfor %}
Du kan också hämta ytterligare egenskaper för data.
Förutsatt din modell Item har ett name fält:
{% for item in view.certain_items %}
<ul>
<li>{{ item.name }}</li>
</ul>
{% endfor %}
Templera i funktionsbaserade vyer
Du kan använda en mall i en funktionsbaserad vy enligt följande:
from django.shortcuts import render
def view(request):
return render(request, "template.html")
Om du vill använda mallvariabler kan du göra det enligt följande:
from django.shortcuts import render
def view(request):
context = {"var1": True, "var2": "foo"}
return render(request, "template.html", context=context)
Sedan kan du i template.html referera till dina variabler så:
<html>
{% if var1 %}
<h1>{{ var2 }}</h1>
{% endif %}
</html>
Mallfilter
Django-mallssystemet har inbyggda taggar och filter , som är funktioner i mallen för att återge innehåll på ett specifikt sätt. Flera filter kan specificeras med rör och filter kan ha argument, precis som i variabel syntax.
{{ "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
En lista över tillgängliga inbyggda filter finns på https://docs.djangoproject.com/sv/dev/ref/templates/builtins/#ref-templates-builtins-filters .
Skapa anpassade filter
Om du vill lägga till dina egna mallfilter skapar du en mapp med namnet templatetags i din appmapp. Lägg sedan till en __init__.py och filen din fil som kommer att innehålla filtren:
#/myapp/templatetags/filters.py
from django import template
register = template.Library()
@register.filter(name='tostring')
def to_string(value):
return str(value)
För att faktiskt använda filtret måste du ladda det i din mall:
#templates/mytemplate.html
{% load filters %}
{% if customer_id|tostring = customer %} Welcome back {% endif%}
tricks
Även om filtren verkar enkla till en början gör det några fina saker:
{% for x in ""|ljust:"20" %}Hello World!{% endfor %} # Hello World!Hello World!Hel...
{{ user.name.split|join:"_" }} ## replaces whitespace with '_'
Se även malltaggar för mer information.
Förhindra att känsliga metoder kallas i mallar
När ett objekt exponeras för mallens sammanhang, är dess metoder utan argument tillgängliga. Detta är användbart när dessa funktioner är "getters". Men det kan vara farligt om dessa metoder förändrar vissa data eller har vissa biverkningar. Även om du förmodligen litar på mallen författare, kanske han inte är medveten om en funktions biverkningar eller tror att fel fel attribut av misstag.
Följande modell:
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
Om du skriver detta, av misstag, i en mall:
You have {{ foobar.credit_points }} points!
Detta ökar antalet poäng varje gång mallen anropas. Och du kanske inte ens märker det.
För att förhindra detta måste du ställa alters_data attributet alters_data till True till metoder som har biverkningar. Detta kommer att göra det omöjligt att ringa dem från en mall.
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
Användning av {% extends%}, {% include%} och {% blocks%}
sammanfattning
{% extends%} : detta förklarar den mall som ges som ett argument som den aktuella mallens överordnade. Användning:
{% extends 'parent_template.html' %}.{% block%} {% endblock%} : Detta används för att definiera avsnitt i dina mallar, så att om en annan mall utökar den här, kommer den att kunna ersätta vilken HTML-kod som har skrivits inuti den. Block identifieras med deras namn. Användning:
{% block content %} <html_code> {% endblock %}.{% include%} : detta kommer att infoga en mall i den nuvarande. Var medveten om att den medföljande mallen kommer att få förfrågningens sammanhang, och du kan också ge den anpassade variabler. Grundläggande användning:
{% include 'template_name.html' %}, användning med variabler:{% include 'template_name.html' with variable='value' variable2=8 %}
Guide
Anta att du bygger upp din front-end-sidkod med gemensamma layouter för all kod och du vill inte upprepa koden för varje mall. Django ger dig inbyggda taggar för att göra det.
Anta att vi har en bloggsida med tre mallar som delar samma layout:
project_directory
..
templates
front-page.html
blogs.html
blog-detail.html
1) Definiera base.html fil,
<html>
<head>
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>
2) Utöka det i blog.html som,
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% endblock %}
# None of the code written here will be added to the template
Här utvidgade vi baslayouten så att dess HTML-layout nu är tillgänglig i blog.html filen. Konceptet med { % block %} är mallarv som gör att du kan bygga en basskelettmall som innehåller alla vanliga element i din webbplats och definierar block som mallar för barn kan åsidosätta.
3) Anta nu att alla dina tre mallar också har samma HTML-div som definierar några populära inlägg. Istället för att skrivas de tre gångerna skapar du en ny mall- 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 %}