Oktatóanyag: Django-alkalmazás létrehozása nézetekkel és lapsablonokkal a Visual Studióban

Cikk
01/27/2025

Ez a cikk a 2. lépést mutatja be a A Django webes keretrendszer használata a Visual Studiocímű oktatóanyag-sorozatában.

A Visual Studio lehetővé teszi Django-alkalmazások létrehozását projektsablonokból, amelyek átfogóbb kiindulópontot biztosítanak a projektekhez. oktatóanyag-sorozat 1. lépése azt ismerteti, hogyan hozhat létre webhelyszintű konfigurációs fájlokat egy Django-webprojekthez egy vagy több Django-webalkalmazás támogatásához. A 2. lépésben tartalmat ad hozzá a Django webes projektjéhez, hogy létrehozhassa az első Django-webalkalmazást egyetlen, több renderelt nézetet tartalmazó oldallal.

Az oktatóanyag 2. lépésében megtanulhatja, hogyan:

Django-alkalmazás létrehozása egyetlen oldallal
Az alkalmazás futtatása a Django-projektből
Nézet renderelése HTML használatával
Nézet megjelenítése Django-oldalsablon használatával

Előfeltételek

Az 1. lépésben létrehozott Visual Studio-megoldás és Django-projekt: Visual Studio-megoldás és Django-projekt létrehozása.
Tekintse át az oktatóanyag-sorozat 1. lépésének Előfeltételek szakaszát a Django-sablonverziókkal, a Visual Studio-projektekkel és a Django-projektekkel és a Mac Python-fejlesztéssel kapcsolatos részletekért.

Django-alkalmazás létrehozása alapértelmezett struktúrával

A Django-alkalmazás egy különálló Python-csomag, amely egy adott célra kapcsolódó fájlokat tartalmaz. A Django-projektek számos alkalmazást tartalmazhatnak, amelyek segítenek a webgazda számára, hogy egyetlen tartománynévből több különböző belépési pontot (vagy útvonalakat) szolgáljon ki. Például egy olyan tartomány Django-projektje, mint contoso.com tartalmazhat egy alkalmazást a www.contoso.com útvonalhoz, egy második alkalmazást a support.contoso.com útvonalhoz, egy harmadik alkalmazást az docs.contoso.com útvonalhoz. Ebben a forgatókönyvben a Django-projekt kezeli a webhelyszintű URL-útválasztást, valamint a urls.py és settings.py fájlok beállításait. Minden alkalmazás saját egyedi stílussal és viselkedéssel rendelkezik a belső útválasztáson, nézeteken, modelleken, statikus fájlokon és felügyeleti felületen keresztül.

A Django-alkalmazások fejlesztése általában szabványos fájlkészlettel kezdődik. A Visual Studio sablonokat biztosít egy Django-alkalmazás inicializálásához ezekkel a fájlokkal egy Django-projektben. Van egy integrált menüparancs is, amely ugyanazt a célt szolgálja.

Alkalmazás létrehozása sablonnal

Kövesse az alábbi lépéseket az alkalmazás sablonból való létrehozásához:

A Megoldáskezelőkattintson a jobb gombbal a Visual Studio-projektre (BasicProject), és válassza >Új elem hozzáadásalehetőséget.
Az Új elem hozzáadása párbeszédpanelen válassza a Django 1.9 Alkalmazás sablont:
1. Adja meg az alkalmazást NeveHelloDjangoApp.
2. Válassza ki a -t, adja hozzá a-et.

Az alkalmazás létrehozásához kövesse az alábbi lépéseket az integrált Django menüparancs használatával:

A Megoldáskezelőbenkattintson a jobb gombbal a Visual Studio projektre (BasicProject), és válassza >Django-alkalmazás hozzáadásalehetőséget.
A Django alkalmazás hozzáadása párbeszédpanelen adja meg az alkalmazás nevét HelloDjangoApp:
Válassza OKlehetőséget.

A Django alkalmazásmappa felfedezése

A HelloDjangoApp alkalmazás létrehozásakor a Visual Studio létrehoz egy azonos nevű mappát a Visual Studio-projektben:

A mappa a következő elemeket tartalmazza:

Cikk	Leírás
migrálások	Egy mappa, amelyben a Django olyan szkripteket tárol, amelyek frissítik az adatbázist, hogy igazodjanak a modellek változásaihoz. A Django migrálási eszközei ezután az adatbázis bármely korábbi verziójára alkalmazzák a szükséges módosításokat az aktuális modelleknek megfelelően. Migrálások használatakor a modellekre összpontosíthat, és lehetővé teszi a Django számára az alapul szolgáló adatbázisséma kezelését. Az oktatóanyag-sorozat gyakorlataihoz a mappa egy __init__.py fájlt tartalmaz, amely azt jelzi, hogy a mappa meghatározza a saját Python-csomagját. További információ: Django dokumentáció.
__init__.py	A init fájl jelenléte csomagként azonosítja a Django alkalmazást.
sablonok	Egy mappa a Django oldal sablonokhoz, amely egy index.html fájlt tartalmaz. A index.html fájl ugyanabba a mappába kerül, amelynek neve megegyezik az alkalmazás nevével. A sablonok HTML-blokkok, amelyekbe a nézetek információkat adhatnak a lap dinamikus megjelenítéséhez. A lapsablon "változói", például `{{ content }}` a index.html fájlban a dinamikus értékek helyőrzői, amint azt a cikk későbbi részében ismertetjük. A Django-alkalmazások általában létrehoznak egy névteret a sablonjaikhoz úgy, hogy egy olyan almappába helyezik őket, amely megfelel az alkalmazás nevének.
admin.py	Az a Python-fájl, amelyben kiterjeszti az alkalmazás felügyeleti felületét, amely egy adatbázisban lévő adatok megtekintésére és szerkesztésére szolgál. Kezdetben ez a fájl csak a `from django.contrib import admin`utasítást tartalmazza. A Django alapértelmezés szerint egy szabványos felügyeleti felületet tartalmaz a Django-projekt settings.py fájljában található bejegyzéseken keresztül. A felület bekapcsolásához megszüntetheti a urls.py fájl meglévő bejegyzéseinek megjegyzését.
apps.py	Egy Python-fájl, amely meghatározza az alkalmazás konfigurációs osztályát. (Lásd a táblázatot követő példát.)
models.py	A modellek függvények által azonosított adatobjektumok, amelyeken keresztül a nézetek interakcióba lépnek az alkalmazás alapjául szolgáló adatbázissal. A Django biztosítja az adatbázis-kapcsolati réteget, hogy az alkalmazások ne törődjenek a modellek részleteivel. A models.py fájl az alapértelmezett hely a modellek létrehozásához. Kezdetben a models.py fájl csak az utasítást tartalmazza, `from django.db import models`.
tests.py	Egy Python-fájl, amely az egységtesztek alapszintű szerkezetét tartalmazza.
views.py	A nézetek hasonlóak a weblapokhoz, amelyek HTTP-kérést fogadnak, és HTTP-választ adnak vissza. A nézetek általában HTML-ként jelennek meg, és a webböngészők tudják, hogyan jelenjenek meg, de a nézetnek nem feltétlenül kell láthatónak lennie (például köztes űrlapnak). Egy Python-függvény határozza meg azt a nézetet, amely a HTML-t jeleníti meg a böngészőben. A views.py fájl az alapértelmezett hely a nézetek létrehozásához. Kezdetben a views.py fájl csak az utasítást tartalmazza, `from django.shortcuts import render`.

Ha a "HelloDjangoApp" nevet használja, a apps.py fájl tartalma a következőképpen jelenik meg:

from django.apps import AppConfig

class HelloDjangoAppConfig(AppConfig):
    name = 'HelloDjangoApp'

Alkalmazás létrehozása a Visual Studióban vagy parancssorból

A >Django alkalmazás hozzáadása parancs és a >Új elem hozzáadása parancs (Django-alkalmazássablonnal kombinálva) ugyanazokat a fájlokat hozza létre, mint a Django CLI parancs manage.py startapp <app_name>. A Django alkalmazás Visual Studióban való létrehozásának előnye, hogy az alkalmazásmappa és annak összes fájlja automatikusan integrálva lesz a projektbe. Ugyanezzel a Visual Studio-paranccsal tetszőleges számú alkalmazást hozhat létre a projektben.

Alkalmazásspecifikus oldalnézetek hozzáadása

Ha az aktuális projektet a Visual Studióban futtatja, válassza Hibakeresési>Hibakeresés indítása (F5) vagy webkiszolgáló a fő eszköztáron, akkor megjelenik az alapértelmezett Django-lap. A webalkalmazások általában több különböző nézettel rendelkező oldallal rendelkeznek. Az alkalmazás URL-címének egyedi útvonala azonosítja az alkalmazás minden lapját.

Kövesse az alábbi lépéseket az alkalmazásspecifikus oldalmegtekintések meghatározásához, és adja hozzá az alkalmazást a Django-projekthez:

A Visual Studio-projekt HelloDjangoApp almappájában cserélje le a views.py fájl tartalmát a következő kódra:
```
from django.shortcuts import render
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, Django!")
```
Ez a kód importálja a szükséges renderelési és HTTP-definíciókat, és definiál egy indexnevű nézetet.

A Visual Studio-projekt BasicProject almappájában módosítsa a urls.py fájlt az alábbi kódnak megfelelően. A tanulságos megjegyzéseket a kívánt módon megtarthatja az aktuális fájlban.

from django.urls import include, re_path
import HelloDjangoApp.views

# Django processes URL patterns in the order they appear in the array
urlpatterns = [
    re_path(r'^$', HelloDjangoApp.views.index, name='index'),
    re_path(r'^home$', HelloDjangoApp.views.index, name='home')
]

Az egyes URL-minták azokat a nézeteket írják le, amelyekhez a Django az oldalhoz viszonyított specifikus URL-eket (vagyis az URL-címet követő útvonalrészt https://www.domain.com/) irányítja.

A urlPatterns definíció első olyan bejegyzése, amely a ^$ reguláris kifejezéssel kezdődik, a webhely gyökéroldalának útválasztása, /.
A második bejegyzés, ^home$az alkalmazás /home lapjára irányítja.

Figyelje meg, hogy a jelen példakód definíciója azt mutatja be, hogy több útválasztást is használhat ugyanahhoz a nézethez.

Nyers útvonal sztringek definiálása (r) előtaggal

A Python útvonalsztringjének r előtagja "nyers" értéket jelent. Ez az előtag arra utasítja a Pythont, hogy ne meneküljön el az útvonalsztringben lévő karakterek elől. Az útvonalsztringek reguláris kifejezései számos speciális karaktert használnak. A r előtag az útvonalsztringben könnyebben olvasható, mint a feloldó karakter \.

Használja a (^) és a dollár ($) karaktereket az útvonalakban.

Az URL-mintákat definiáló reguláris kifejezésekben a ^ simogató szimbólum "sorkezdetet" jelent, a dollárjel $ pedig a "sor végét" jelenti. Ezeknek a karaktereknek az URL-címeken több felhasználási módja is van a webhelygyökérhez képest (az alkalmazás címét követő rész https://www.domain.com/):

A reguláris kifejezés ^$ gyakorlatilag "üres" kifejezést jelent, és megfelel az alkalmazás webhelygyökérének teljes URL-címének, https://www.domain.com/.
A minta ^home$ pontosan megegyezik a https://www.domain.com/home/-gyel, amely a /homeáltal követett útvonal. (Django nem használja a záró /-t mintázat egyezéskor.)
Ha nem használ záró dollárjelet $ egy reguláris kifejezésben, például a ^home útvonal sztringjében, akkor az URL-mintaegyezés minden olyan URL-címre vonatkozik, amely home kezdődik, például home, homework, homestead, home192837stb.

A különböző reguláris kifejezések kipróbálásához próbálkozzon online eszközökkel, például regex101.com pythex.org.

Alkalmazás futtatása Django-projektből

Alkalmazásspecifikus tartalom hozzáadása után futtassa újra az alkalmazást, és ellenőrizze az útvonalnézeteket a böngészőben:

Amikor az alkalmazás megnyílik a böngészőben, ellenőrizze a böngészőben a / (webhelygyökér) és a /home URL-útvonalakhoz tartozó oldalmegtekintéseket. Mindkét útvonal esetében az alkalmazás megjeleníti a Hello, Django! a böngészőben.
Ha elkészült, válassza a Ctrl+C billentyűkombinációt a konzolablakban, majd az alkalmazás leállításához nyomjon meg bármelyik billentyűt. A Debug>Hibakeresés leállításalehetőséget is választhatja.
Zárja be az alkalmazás megnyitott böngészőablakait.

Módosítások véglegesítése a forrásvezérlőben

A Django-alkalmazás kódjának frissítése és a frissítések tesztelése után áttekintheti és véglegesítheti a módosításokat a forrásvezérlőben:

Mentse a projektfájlok módosításait, például a Ctrl+S billentyűparanccsal.
A Git vezérlősávján válassza a nem véglegesített módosításokat (ceruza 11) a Git-módosítások ablak megnyitásához:
A Git-változások ablakban írjon be egy véglegesítési üzenetet, és válassza a Mindent véglegesítlehetőséget.

A véglegesítés befejezésekor a Visual Studio megjeleníti az commit <hash> helybenlétrehozott üzenetet.
(Nem kötelező) A véglegesített módosítások leküldése a távoli adattárba:
1. A Git vezérlősávján válassza ki a kimenő/bejövő véglegesítéseket (1/0 nyíl).
2. Válassza a Szinkronizálás (Lekérés, majd leküldés) vagy a Leküldéslehetőséget.
Több helyi véglegesítést is halmozhat fel, mielőtt leküldené őket a távoli adattárba.

Mentse a projektfájlok módosításait, például a Ctrl+S billentyűparanccsal.
Válassza ki a nem véglegesített módosításokat (ceruza 11) a jobb alsó sarokban a Visual Studióban, amely megnyitja Team Explorer:
A Team Explorermezőbe írjon be egy véglegesítési üzenetet, például "Django alkalmazásspecifikus oldal létrehozása", majd válassza Véglegesítéslehetőséget.

A véglegesítés befejezése után a Visual Studio megjeleníti a helyileg létrehozott> véglegesítési <kivonatot üzenetet. Szinkronizálás a módosítások kiszolgálóval való megosztásához.
(Nem kötelező) A véglegesített módosítások leküldése a távoli adattárba:
1. A Team Explorerablakban válassza ki a Szinkronizáláslehetőséget.
2. Bontsa ki a Küldésre váró commitok, és válassza a Leküldéslehetőséget.
Több helyi véglegesítést is halmozhat fel, mielőtt leküldené őket a távoli adattárba.

Az oktatóanyag-sorozat további eljárásait ebben a szakaszban találja a forráskövetés módosításainak véglegesítéséhez szükséges lépésekről.

Lapok és nézetek megjelenítése sablonok használatával

A views.py fájlban található index függvény egyszerű szöveges HTTP-választ hoz létre a Django alkalmazáslaphoz. A legtöbb valós weblap gazdag HTML-lapokkal válaszol, amelyek gyakran tartalmaznak élő adatokat. A fejlesztők elsősorban azért definiálnak nézeteket egy függvény használatával, hogy dinamikusan generálják a tartalmat.

A HttpResponse metódus argumentuma csak egy karakterlánc. Dinamikus tartalommal bármilyen HTML-t létrehozhat egy sztringen belül. Mivel a legjobb, ha elkülöníti a korrektúrát az adatoktól, jobb, ha a korrektúrát egy sablonban helyezi el, és kódban tartja az adatokat.

Állítsd be a nézeteket inline HTML használatára

Konvertálja a nézetfeldolgozást úgy, hogy beágyazott HTML-t használjon a laphoz néhány dinamikus tartalommal:

A Visual Studio-projekt HelloDjangoApp almappájában nyissa meg a views.py fájlt.

Cserélje le a index függvényt a következő kódra (tartsa meg a meglévő from utasításokat):

from datetime import datetime

def index(request):
   now = datetime.now()

   html_content = "<html><head><title>Hello, Django</title></head><body>"
   html_content += "<strong>Hello Django!</strong> on " + now.strftime("%A, %d %B, %Y at %X")
   html_content += "</body></html>"

   return HttpResponse(html_content)

A módosított index függvény html-választ hoz létre a lap minden frissítésekor frissülő dinamikus tartalommal.

Mentse a módosításokat, és futtassa újra az alkalmazást. Az oldalon most az aktuális dátum és idő látható az "Hello Django!" üzenettel.
Frissítse a lapot néhányszor, hogy meggyőződjön arról, hogy a dátum és az idő frissül. Ha végzett, állítsa le az alkalmazást.

HTML-sablon létrehozása lapmegtekintésekhez

A HTML kódban való létrehozása kis oldalak esetén jól működik. A lapok kifinomultabb használata esetén azonban a lap statikus HTML-részeit (a CSS- és JavaScript-fájlokra mutató hivatkozásokkal együtt) "lapsablonokként" kell karbantartania. Ezután beszúrhatja a dinamikus, kód által generált tartalmat a lapsablonokba. Az előző szakaszban csak az now.strftime hívás dátuma és ideje dinamikus, ami azt jelenti, hogy az összes többi tartalom elhelyezhető egy lapsablonban.

A Django-lapsablon egy HTML-blokk, amely több helyettesítő tokeneket, úgynevezett "változókat" tartalmaz. A kapcsos zárójelek {{ és }} jelölik a változókat, mint például {{ content }}. A Django sablonmodulja ezután a változókat a kódban megadott dinamikus tartalomra cseréli.

Kövesse az alábbi lépéseket a lapmegjelenítési folyamat HTML-sablon használatára való konvertálásához:

A Visual Studio-projekt HelloDjangoApp almappájában nyissa meg a settings.py fájlt.
Frissítse az alkalmazáshivatkozásokat a INSTALLED_APPS definícióban, hogy tartalmazza az alkalmazás nevét HelloDjangoApp. Adja hozzá az alkalmazás nevét a lista első bejegyzéseként:
```
INSTALLED_APPS = [
    'HelloDjangoApp',
    # Existing entries in the list ...
]
```
Ha hozzáadja az alkalmazást a listához, arról tájékoztatja a Django-projektet, hogy van egy HelloDjangoApp nevű mappa, amely egy alkalmazást tartalmaz.
Erősítse meg, hogy a TEMPLATES objektum beállítása APP_DIRS-et True-re állítja be:
```
'APP_DIRS': True,
```
Ez az utasítás arra utasítja a Django-t, hogy keressen sablonokat a telepített alkalmazások sablonok mappájában. (Ennek az utasításnak alapértelmezés szerint szerepelnie kell a definícióban.)
A HelloDjangoApp almappában nyissa meg a sablonok/HelloDjangoApp/index.html lapsablonfájlt.
Győződjön meg arról, hogy a fájl csak egy változót tartalmaz, {{ content }}:
```
<html>
 <head>
 <title></title>
 </head>

 <body>
 {{ content }}
 </body>
</html>
```
A {{ content }} kijelentés egy helyőrző vagy helyettesítő token (más néven sablonváltozó), amelyhez értéket ad meg a kódban.
A Visual Studio-projekt HelloDjangoApp almappájában nyissa meg a views.py fájlt.
Cserélje le a index függvényt a következő kódra, amely a django.shortcuts.render segédfüggvényt használja (tartsa meg a meglévő from utasításokat):
```
def index(request):
 now = datetime.now()

 return render(
 request,
 "HelloDjangoApp/index.html", # Relative path from the 'templates' folder to the template file
 {
 'content': "Hello Django! on " + now.strftime("%A, %d %B, %Y at %X")
 }
 )
```
A render segédfüggvény egyszerűsített felületet biztosít a lapsablonok használatához. Ennek a függvénynek három argumentuma van:
- A kérelemobjektum.
- Az alkalmazás sablonok mappáján belüli fájl relatív elérési útja. A sablonfájl neve adott esetben a támogatott nézethez tartozik.
- A sablon által hivatkozott változók szótára. A szótárba felvehet objektumokat, ahol a sablon egyik változója hivatkozhat {{ object.property }}-ra.
Mentse a projekt módosításait, és futtassa újra az alkalmazást.

Figyelje meg, hogy a beágyazott HTML-szintaxis (\ ...) az content értéken belül nem jeleníti meg HTML-ként, mert a templatáló motor (Jinja) automatikusan kikerüli a HTML-tartalmat. Az automatikus menekülés megakadályozza a véletlen biztonsági réseket az injektálási támadásokhoz.

A fejlesztők gyakran gyűjtenek adatokat az egyik oldalról, és egy sablon helyőrző használatával használják azt értékként egy másikban. A menekülés arra is emlékeztet, hogy a HTML-t érdemes a kódból kivenni.

Ha végzett, állítsa le az alkalmazást.

Eltérő helyőrzők használata

A HTML-jelölőnyelv minden adateleméhez különálló helyőrzőket használhat. Ezután módosítsa ismét a index függvényt a megadott helyőrző értékek megadásához:

Cserélje ki a sablonok/HelloDjangoApp/index.html oldalsablon fájl tartalmát a következő jelölőnyelvre:
```
<html>
 <head>
 <title>{{ title }}</title>
 </head>
 <body>
 {{ message }}{{ content }}
 </body>
</html>
```
Ez a HTML-jelölés hozzáad egy lapcímet, és megtartja az összes formázást a sablonban.

A HelloDjangoApp/views.py fájlban cserélje le a index függvényt a következő kódra:

def index(request):
    now = datetime.now()

    return render(
        request,
        "HelloDjangoApp/index.html",  # Relative path from the 'templates' folder to the template file
        # "index.html", # Use this code for VS 2017 15.7 and earlier
        {
            'title' : "Hello Django",
            'message' : "Hello Django!",
            'content' : " on " + now.strftime("%A, %d %B, %Y at %X")
        }
    )

Ez a kód a lapsablon összes változójának értékeit tartalmazza.

Mentse a módosításokat, és futtassa újra az alkalmazást. Ezúttal a megfelelően renderelt kimenetnek kell megjelennie:
Véglegesítheti a módosításokat a forráskövetésben, és frissítheti a távoli adattárat. További információért lásd: A forrásvezérlési módosítások véglegesítése.

Oldalsablonok elkülönítése

A sablonok általában külön HTML-fájlokban vannak fenntartva, de beágyazott sablonokat is használhat. A korrektúra és a kód tiszta elkülönítésének fenntartása érdekében ajánlott külön fájlokat létrehozni.

.html bővítmény használata sablonokhoz

A lapsablonfájlok .html bővítménye nem kötelező. A render_template függvény első argumentumában mindig meghatározhatja a fájl pontos relatív elérési útját. A Visual Studio (és más szerkesztők) azonban általában olyan funkciókat biztosítanak, mint a kódkiegészítés és a szintaxis színezése .html fájlokkal, ami meghaladja azt a tényt, hogy a lapsablonok nem HTML-fájlok.

Django-projekt használatakor a Visual Studio automatikusan észleli, hogy a szerkesztett HTML-fájl valójában Django-sablon-e, és bizonyos automatikus kiegészítési funkciókat biztosít. Ha elkezdi beírni a Django-lapsablon megjegyzését ({#), a Visual Studio automatikusan beírja a záró #} karaktereket. A Megjegyzéskijelölés és a Megjegyzés eltávolítása kiválasztásnál parancsok (a Szerkesztés>Speciális menüben) szintén sablon-kommenteket használnak HTML-megjegyzések helyett.

Problémák elhárítása

Az alkalmazás futtatásakor problémákat tapasztalhat az alkalmazás sablonfájljához kapcsolódóan. Tekintse át a következő pontokat, és győződjön meg arról, hogy a Django-projekt konfigurációja helyes.

A sablon nem található

Ha a Django vagy a Visual Studio "Sablon nem található" hibát jelez, ellenőrizze, hogy az alkalmazása szerepel-e a INSTALLED_APPS listán. Ez a lista a Visual Studio-projekt alkalmazásalmappájának settings.py fájljában található (például HelloDjangoApp). Ha a lista nem tartalmaz bejegyzést az alkalmazáshoz, a Django nem tudja, hogy az alkalmazás sablonjaiban mappában kell keresnie.

Duplikált sablonstruktúra

Amikor a Django a render függvényben említett sablont keres, az első fájlt használja, amely megfelel a relatív elérési útnak. Ha több Django-alkalmazás is van ugyanabban a projektben, és ugyanazokkal a mappastruktúrákkal rendelkezik a sablonokhoz, valószínű, hogy az egyik alkalmazás akaratlanul is használhat egy másik alkalmazásból származó sablont. Az ilyen hibák elkerülése érdekében mindig hozzon létre egy almappát az alkalmazás sablonjai alatt mappa alatt, amely megfelel az alkalmazás nevének a duplikációk elkerülése érdekében.

Következő lépés

3. lépés: Statikus fájlok kiszolgálása, lapok hozzáadása és sablonöröklés használata

Megosztás a következőn keresztül: