En av de kraftigste funksjonene til Django er dens evne til å gjenbruke kode dynamisk. Malarv tillater deling av kode mellom overordnede og underordnede maler. Det reduserer duplisering av innsats betraktelig.
Django har malspråket designet for å blande seg med HTML. Du vil finne det enkelt å jobbe med Djangos maler hvis du har jobbet med HTML-kode før. Andre tekstbaserte malspråk som Smarty eller Jinja2 har lignende syntaks.
La oss lære mer om malarv ved å bygge et Django-prosjekt.
Hva er en Django-mal?
I Django er en mal en tekstfil som kan generere et hvilket som helst tekstbasert format, for eksempel HTML, XML eller CSV.
Django mal-tagger kontrollere logikken som omslutter variabler og verdier i malen. Taggene hjelper til med å skille programlogikk fra malpresentasjon. De bidrar også til å holde malene dine rene og organiserte.
Django har mange innebygde tagger, som ser ut som
{% stikkord %}. Tagger er nyttige på mange måter. De kan lage tekst i utdataene, utføre looper og laste informasjon inn i malen.Du vil bruke tagger i dette prosjektet for å demonstrere malarv.
Lag et Django-prosjekt
For å komme i gang, lage et Django-prosjekt. Lag en app som heter maler. Når du har gjort det, er du klar til å lage en visningsfunksjon for appen, en URL-bane og maler for å demonstrere malarv.
Opprett en visningsfunksjon
Lag først en utsikt funksjon som gjengir malene. I dette tilfellet vil du gjengi index.html mal. Importer gjengi metode fra Django-snarveier. Lag deretter en visningsfunksjon kalt indeks som returnerer og gjengir indeksmalen.
fra django.snarveier import gjengi
# Lag dine synspunkter her.
defindeks(be om):
returnere gjengivelse (forespørsel,'index.html')Opprett en URL-bane
Deretter oppretter du en URL-bane for visningsfunksjonen for å vise malene. Importer sti funksjon fra django.urls og utsikt funksjon fra views.py fil. Importer deretter innstillinger og statisk for å gjengi bilder og medier du måtte ha i malene.
fra django.urls import sti
fra. import visninger
fra django.conf import innstillinger
fra django.conf.urls.static importstatisk
urlpatterns=[
sti('',views.index, name='indeks'),
]
hvisinnstillinger.DEBUG:
urlpatterns+=statisk(innstillinger. MEDIA_URL, document_root=innstillinger. MEDIA_ROOT)Lag maler
Nå som du har utsikt og URL bane, lag malene. For å demonstrere malarv, lag en base.html som en overordnet mal. De base.html filen vil ha generelle elementer du ønsker å dele med index.html,barnemalen.
{% load bootstrap5 %}
{% belastning statisk %}
<!DOCTYPE html>
<html lang="no">
<hode>
<metategnsett="UTF-8">
<meta http-equiv="X-UA-kompatibel" innhold="IE = kant">
<metanavn="viewport" innhold="width=enhetsbredde, initial-skala=1,0">
<!-- titler -->
{% if title %}
<tittel> Arvede maler {{title}}</title>
{% ellers %}
<tittel> Arvede maler </title>
{% slutt om %}
{% blokkstiler %}
{% bootstrap_css %}
<link rel="stilark" href="{% statisk 'css/style.css' %}">
{% sluttblokk %}
</head>
<kropp>
{% inkluderer 'navbar.html' %}
{% block content %} {% endblock %}
<!-- Bootstrap-lenker -->
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integritet="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonym"></script>
</body>
</html>Først laster du Bootstrap og statiske avhengigheter på base.html mal. Du kan bruk Bootstrap-rammeverket med ditt Django-prosjekt for å style HTML-sidene. Den statiske avhengigheten som er lastet øverst, vil laste eiendeler som er inkludert i den statiske mappen.
Django-maler lar deg sende logikk som er ansvarlig for visning av innhold. Maletiketter består av tekst omgitt av "{%" og "%}" tegn. De hvis/annet statement sjekker for forhold i visningsfunksjonen. Hvis betingelsen er sann, gjengir den innholdet i den første blokken; hvis falsk, vil det gjengi innholdet i den andre.
De base.html filen vil også gjengi innholdet i navbar.html akkurat der du plasserer malkodene. Det betyr at når du utvider base.html, navbar.html er også arvet. Enhver mal som utvider base.html vil arve et hvilket som helst element med en {% inkluderer %} stikkord.
Enhver tekst omgitt av {{}} er en malvariabel. Malvariabler er dynamiske data levert av visningsfunksjoner. Django bruker også blokkkoder som bruker en åpen tag, som {% blokker innhold %}, og en avsluttende kode, som {% sluttblokk %}.
Blokktagger lar de underordnede malene overstyre innholdet i de overordnede malene. I dette tilfellet index.html kan erstatte innholdet i området som er omgitt av blokkmerker. Det vil ikke forstyrre den andre base.html komponenter.
La oss bruke logikken på index.html
{% strekker 'base.html' %}
{% blokker innhold %}
<div klasse="container tekst-senter" stil="farge: hvit">
<h1>Jeg er indeksmalen</h1>
<s>Jeg arvet Bootstrap og navbaren fra base.html</s>
</div>
{% sluttblokk %}
I index.html mal, bruk {% utvide %} tag for å utvide komponenter i base.html. Inne i blokkmerkene {% blokker innhold %}, skriv all koden din.
I index.html mal, har du et H1- og et avsnittselement. Du kan bruke malkodene inne i divene til å kalle variabler fra utsikt funksjon.
Test malarv i nettleseren
Du kan nå kjøre serveren. Når du har gjort det, sjekk i nettleseren for å se om index.html filen arvet elementene til base.html. Det inkluderer Bootstrap-koblinger og navbar.html mal.
De index.html filen skal arve navbar- og Bootstrap-stilene fra basismalen. I så fall har du brukt malarv riktig. Uten den ville du ha måttet legge til navigasjonslinjen og Bootstrap-lenker der du trengte dem.
Også eventuelle endringer du gjør i base.html vil reflektere på tvers av alle malene den strekker seg til. Dette prinsippet er viktig ved feilhåndtering. Du kan enkelt identifisere maler med feil.
Malarv er en av mange måter Django implementerer Don't Repeat Yourself (DRY)-prinsippet. Det vil gjøre utviklingen din mye enklere og enklere.
Hvorfor du bør bruke Django Template Inheritance
Djangos malarv er en av dens mest komplekse funksjoner. Det kan ta litt tid å forstå det, men når du først gjør det, sparer det mye utviklingsinnsats.
Malarv lar deg dele kode mellom overordnede og underordnede maler. Dette sikrer at du ikke skriver repeterende kode i malene dine.
Malarv er viktig i store Django-prosjekter. I slike tilfeller er det mange applikasjoner og mange maler å designe. Overordnede maler gir deg mye kontroll over applikasjonens andre komponenter.
Ved å lære Django-malsystemet kan du glede deg over å skrive ren og kraftig kode.