Hoe werkt URL-routering?

Question

Accepted Answer

**URL-routering** (URLconf) wijst binnenkomende request-URL's toe aan de **views** die ze afhandelen. Django vergelijkt de aangevraagde URL met een lijst van patronen en roept de overeenkomstige view aan, terwijl alle parameters uit de URL worden geëxtraheerd. ## Waarom het belangrijk is ```python # urls.py from django.urls import path from . import views urlpatterns = [ path("", views.home, name="home"), # / path("articles/", views.article_list, name="article_list"), # /articles/ path("articles//", views.article_detail, name="detail"), # /articles/5/ path("articles//", views.by_slug, name="by_slug"), # /articles/my-post/ ] ``` Elke `path()` wijst een URL-patroon toe aan een view-functie. Django probeert ze van boven naar beneden en gebruikt de eerste match. ## URL-parameters vastleggen ```python path("articles//", views.article_detail) # captures an integer as `pk` # the view receives the captured value as a parameter def article_detail(request, pk): # pk = 5 for /articles/5/ article = Article.objects.get(pk=pk) ``` Pathconverters (``, ``, ``, ``) leggen delen van de URL vast en converteren ze, en geven ze als argumenten aan de view door. ## Benoemde URL's en reverse-resolutie (belangrijk!) ```python path("articles//", views.article_detail, name="detail") # the `name` ``` ```python # generate URLs by NAME instead of hardcoding them — DRY and refactor-safe from django.urls import reverse url = reverse("detail", kwargs={"pk": 5}) # → "/articles/5/" redirect("detail", pk=5) # in views ``` ```html Read more ``` **Benoemde URL's** zijn cruciaal: door naar URL's te verwijzen via hun `name` (via `{% url %}` in templates en `reverse()` in code) in plaats van paden in te coderen, kunt u de URL-structuur op één plek wijzigen zonder elke link te breken — een DRY, refactor-veilige praktijk. ## App-URL's opnemen (modulaire routering) ```python # project urls.py — delegate to each app's URLconf from django.urls import include, path urlpatterns = [ path("blog/", include("blog.urls")), # /blog/... handled by the blog app path("shop/", include("shop.urls")), path("admin/", admin.site.urls), ] ``` `include()` delegeert een URL-voorvoegsel aan het eigen `urls.py`-bestand van een app, waardoor routering modulair blijft en elke app zelfstandig is. ## Waarom het belangrijk is URL-routering is fundamenteel voor elke Django-applicatie — het definieert de URL-structuur van uw site en bepaalt hoe requests de juiste view bereiken. Het begrijpen ervan is essentiële dagelijkse kennis: weten hoe u URL-patronen definieert, parameters uit URL's vastlegt en typeconverteert (pathconverters zoals ``), en routering modulair organiseert met `include()` (delegering naar per-app URLconfs) is noodzakelijk voor het bouwen van elke multi-paginatoepassing of API. Uiterst belangrijk is de praktijk van **benoemde URL / reverse-resolutie** — naar URL's verwijzen via hun `name` via `{% url %}` en `reverse()` in plaats van paden in te coderen — wat Django's DRY-filosofie weerspiegelt en een grote onderhoudswinst is: het stelt u in staat URL's op één plek te herstructureren zonder naar elk hardcoded link over templates en code te hoeven zoeken en deze bij te werken. Dit is een best practice die goed gebouwde Django-projecten onderscheidt van fragiele projecten. URL-routering verbindt het ingangspunt (URL's) met de logica (views) en voltooit het verzoekafhandelingspictogram naast modellen en templates, waardoor het kernmateriaal wordt dat je moet kennen voor het organiseren en onderhouden van elke Django-toepassing.