Django => Templating

Variablen

Auf Variablen, die Sie in Ihrem Ansichtskontext bereitgestellt haben, können Sie in doppelter geschweiften Klammer darauf zugreifen:

In deinen 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>

Die Punktnotation greift zu:

Eigenschaften des Objekts, zB user.username ist {{ user.username }}
Wörterbuchsuche, zB request.GET["search"] wird {{ request.GET.search }}
Methoden ohne Argumente, zB users.count() wird {{ user.count }}

Vorlagenvariablen können nicht auf Methoden zugreifen, die Argumente akzeptieren.

Variablen können auch getestet und übergangen werden:

{% 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 %}

Auf URLs wird im Format {% url 'name' %} zugegriffen, wobei die Namen den Namen in Ihrer urls.py .

{% url 'login' %} - Wird wahrscheinlich als /accounts/login/
{% url 'user_profile' user.id %} - Argumente für URLs werden in der angegebenen Reihenfolge angegeben
{% url next %} - URLs können Variablen sein

Schablonen in klassenbasierten Ansichten

Sie können Daten in einer benutzerdefinierten Variablen an eine Vorlage übergeben.

In deinen 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()

Eine einfache Liste in Ihrer item.html :

{% for item in view.items %}
<ul>        
    <li>{{ item }}</li>
</ul>
{% endfor %}

Sie können auch zusätzliche Eigenschaften der Daten abrufen.

Angenommen , Ihr Modell Item hat einen name Feld:

{% for item in view.certain_items %}
<ul>        
    <li>{{ item.name }}</li>
</ul>
{% endfor %}

Vorlagen in funktionsbasierten Ansichten

Sie können eine Vorlage in einer funktionsbasierten Ansicht wie folgt verwenden:

from django.shortcuts import render

def view(request):
    return render(request, "template.html")

Wenn Sie Vorlagenvariablen verwenden möchten, haben Sie folgende Möglichkeiten:

from django.shortcuts import render

def view(request):
    context = {"var1": True, "var2": "foo"}
    return render(request, "template.html", context=context)

In template.html können Sie dann wie folgt auf Ihre Variablen verweisen:

<html>
{% if var1 %}
    <h1>{{ var2 }}</h1>
{% endif %}
</html>

Vorlagenfilter

Das Django-Schablonensystem verfügt über integrierte Tags und Filter , die Funktionen in der Schablone sind, um Inhalte auf bestimmte Weise darzustellen. Mit Pipes können mehrere Filter angegeben werden, und Filter können wie in der Variablensyntax Argumente enthalten.

{{ "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

Eine Liste der verfügbaren integrierten Filter finden Sie unter https://docs.djangoproject.com/de/dev/ref/templates/builtins/#ref-templates-builtins-filters .

Benutzerdefinierte Filter erstellen

Erstellen Sie zum Hinzufügen eigener Vorlagenfilter einen Ordner namens templatetags in Ihrem App-Ordner. __init__.py dann ein __init__.py und die Datei Ihrer Datei hinzu, die die Filter enthalten wird:

#/myapp/templatetags/filters.py
from django import template

register = template.Library()

@register.filter(name='tostring')
def to_string(value):
    return str(value)

Um den Filter tatsächlich verwenden zu können, müssen Sie ihn in Ihre Vorlage laden:

#templates/mytemplate.html
{% load filters %}
{% if customer_id|tostring = customer %} Welcome back {% endif%}

Tricks

Auch wenn die Filter auf den ersten Blick einfach erscheinen, können Sie einige einfache Dinge tun:

{% for x in ""|ljust:"20" %}Hello World!{% endfor %}    # Hello World!Hello World!Hel...    
{{ user.name.split|join:"_" }} ## replaces whitespace with '_'

Weitere Informationen finden Sie auch unter Vorlagen-Tags .

Verhindern, dass sensible Methoden in Vorlagen aufgerufen werden

Wenn ein Objekt für den Vorlagenkontext verfügbar gemacht wird, sind die Methoden ohne Argumente verfügbar. Dies ist nützlich, wenn diese Funktionen "Getter" sind. Es kann jedoch gefährlich sein, wenn diese Methoden einige Daten ändern oder Nebenwirkungen haben. Obwohl Sie dem Schreiber der Vorlage wahrscheinlich vertrauen, ist er möglicherweise nicht auf die Nebenwirkungen einer Funktion aufmerksam oder meint, das falsche Attribut fälschlicherweise anzurufen.

Gegeben das folgende 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

Wenn Sie dies versehentlich in eine Vorlage schreiben:

 You have {{ foobar.credit_points }} points!

Dadurch wird die Anzahl der Punkte bei jedem Aufruf der Vorlage erhöht. Und Sie bemerken es vielleicht gar nicht.

Um dies zu verhindern, müssen Sie das alters_data Attribut auf True um Methoden zu erhalten, die Nebenwirkungen haben. Dies macht es unmöglich, sie von einer Vorlage aus aufzurufen.

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

Verwendung von {% extend%}, {% include%} und {% blocks%}

Zusammenfassung

{% extend%} : Hiermit wird die als Argument angegebene Vorlage zum übergeordneten Element der aktuellen Vorlage erklärt. Verwendung: {% extends 'parent_template.html' %} .
{% block%} {% endblock%} : Dies wird zum Definieren von Abschnitten in Ihren Vorlagen verwendet. Wenn also eine andere Vorlage diese erweitert, kann sie den in ihr enthaltenen HTML-Code ersetzen. Blöcke werden durch ihren Namen identifiziert. Verwendung: {% block content %} <html_code> {% endblock %} .
{% include%} : Hiermit wird eine Vorlage in die aktuelle Vorlage eingefügt. Beachten Sie, dass die enthaltene Vorlage den Kontext der Anforderung empfängt. Sie können auch benutzerdefinierte Variablen angeben. Grundlegende Verwendung: {% include 'template_name.html' %} , Verwendung mit Variablen: {% include 'template_name.html' with variable='value' variable2=8 %}

Führen

Angenommen, Sie bauen Ihren Front-End-Code mit gemeinsamen Layouts für den gesamten Code auf und möchten den Code nicht für jede Vorlage wiederholen. Django gibt Ihnen dafür eingebaute Tags.
Angenommen, wir haben eine Blog-Website mit drei Vorlagen, die dasselbe Layout haben:

project_directory
    ..
    templates
      front-page.html
      blogs.html
      blog-detail.html

1) base.html Datei definieren,

<html>
  <head>
  </head>

  <body>
        {% block content %}
        {% endblock %}
   </body>
</html>

2) Erweitern Sie es in blog.html wie

{% 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 haben wir das blog.html erweitert, sodass das HTML-Layout nun in der blog.html blog.html zur Verfügung blog.html Das Konzept von { % block %} ist die Vererbung von Vorlagen, mit der Sie eine Basisvorlage mit "Skelett" erstellen können, die alle gängigen Elemente Ihres Systems enthält Site und definiert Blöcke, die untergeordnete Vorlagen überschreiben können.

3) Nehmen Sie nun an, alle Ihre 3 Vorlagen haben das gleiche HTML-Div, das einige beliebte Posts definiert. Statt die 3-mal geschrieben zu werden, erstellen Sie eine neue Vorlage 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 %}

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

Django
Templating

Suche…