Comment fonctionne le routage des URL ?

Question

Accepted Answer

**URL routing** (le URLconf) mappe les URL de requête entrantes aux **vues** qui les traitent. Django compare l'URL demandée à une liste de motifs et appelle la vue correspondante, en extrayant tous les paramètres de l'URL. ## Définir des motifs d'URL ```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/ ] ``` Chaque `path()` mappe un motif d'URL à une fonction de vue. Django les essaie de haut en bas et utilise le premier qui correspond. ## Capturer les paramètres d'URL ```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) ``` Les convertisseurs de chemin (``, ``, ``, ``) capturent et convertissent le type de parties de l'URL, en les passant à la vue comme arguments. ## URLs nommées et résolution inverse (important !) ```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 ``` **Les URLs nommées** sont cruciales : en faisant référence aux URLs par leur `name` (via `{% url %}` dans les templates et `reverse()` dans le code) au lieu de coder en dur les chemins, vous pouvez changer la structure d'URL au même endroit sans casser tous les liens — une pratique DRY et sûre pour la refactorisation. ## Inclure les URLs de l'app (routage modulaire) ```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()` délègue un préfixe d'URL au propre `urls.py` d'une app, gardant le routage modulaire et chaque app autonome. ## Pourquoi c'est important Le routage des URL est fondamental pour chaque application Django — il définit la structure d'URL de votre site et c'est comment les requêtes atteignent la bonne vue. Le comprendre est une connaissance essentielle au quotidien : savoir comment définir des motifs d'URL, capturer et convertir le type de paramètres à partir des URLs (convertisseurs de chemin comme ``), et organiser le routage de manière modulaire avec `include()` (en déléguant à des URLconfs par app) est nécessaire pour construire n'importe quelle app multi-pages ou API. Critiquement important est la pratique **des URLs nommées / résolution inverse** — faire référence aux URLs par leur `name` via `{% url %}` et `reverse()` plutôt que de coder en dur les chemins — qui incarne la philosophie DRY de Django et est un gain de maintenabilité majeur : cela vous permet de restructurer les URLs en un seul endroit sans chercher et mettre à jour chaque lien codé en dur dans les templates et le code. C'est une bonne pratique qui distingue les projets Django bien construits de ceux fragiles. Le routage des URL connecte le point d'entrée (URLs) à la logique (vues), complétant le tableau de traitement des requêtes aux côtés des modèles et templates, ce qui en fait une matière centrale et essentielle à connaître pour organiser et maintenir n'importe quelle application Django.