# Django 6.0.5 documentation

# Django genvägsfunktioner

Paketet `django.shortcuts` samlar hjälpfunktioner och klasser som ”spänner över” flera nivåer av MVC. Med andra ord introducerar dessa funktioner/klasser kontrollerad koppling för bekvämlighetens skull.

## `render()`

render(request, template_name, context=None, content_type=None, status=None, using=None)

  Kombinerar en given mall med en given kontextordbok och returnerar ett `HttpResponse`-objekt med den återgivna texten.

  Django does not provide a shortcut function which returns a `TemplateResponse` because the constructor of `TemplateResponse` offers the same level of convenience as `render()`.

### Nödvändiga argument

`begäran`

  Det request-objekt som används för att generera detta svar.

`template_name`

  Det fullständiga namnet på en mall som ska användas eller en sekvens av mallnamn. Om en sekvens anges kommer den första mallen som finns att användas. Se dokumentation för laddning av mallar för mer information om hur mallar hittas.

### Valfria argument

`kontext`

  En ordlista med värden som ska läggas till i mallkontexten. Som standard är detta en tom ordbok. Om ett värde i ordlistan är anropsbart kommer vyn att anropa det precis innan mallen renderas.

`innehållstyp`

  Den MIME-typ som ska användas för det resulterande dokumentet. Standardvärdet är `'text/html'`.

`status`

  Statuskoden för svaret. Standardvärdet är `200`.

`använder`

  `NAME` för en mallmotor som ska användas för att ladda mallen.

### Exempel

I följande exempel återges mallen `myapp/index.html` med MIME-typen application/xhtml+xml:

    from django.shortcuts import render

    def my_view(request):
        # View code here...
        return render(
            request,
            "myapp/index.html",
            {
                "foo": "bar",
            },
            content_type="application/xhtml+xml",
        )

Detta exempel är likvärdigt med:

    from django.http import HttpResponse
    from django.template import loader

    def my_view(request):
        # View code here...
        t = loader.get_template("myapp/index.html")
        c = {"foo": "bar"}
        return HttpResponse(t.render(c, request), content_type="application/xhtml+xml")

## `omdirigera()`

redirect(to, *args, permanent=False, preserve_request=False, **kwargs)

  Returnerar en `HttpResponseRedirect` till lämplig URL för de argument som skickas.

  Argumenten skulle kunna vara:

  - A model: the model’s `get_absolute_url()` function will be called.

  - Ett namn på vyn, eventuellt med argument: `reverse()` kommer att användas för att lösa upp namnet bakåt.

  - En absolut eller relativ URL, som kommer att användas som den är för omdirigeringsplatsen.

  Som standard utfärdas en tillfällig omdirigering med en 302-statuskod. Om `permanent=True` utfärdas en permanent omdirigering med en 301-statuskod.

  Om `preserve_request=True`, instruerar svaret användaragenten att bevara metoden och innehållet i den ursprungliga begäran när omdirigeringen utfärdas. I det här fallet används statuskod 307 för tillfälliga omdirigeringar och statuskod 308 för permanenta omdirigeringar. Detta illustreras bättre i följande tabell:

  permanent | bevara_begäran | HTTP-statuskod
  --- | --- | ---
  `True` | `False` | 301
  `False` | `False` | 302
  `False` | `True` | 307
  `True` | `True` | 308

  Changed in Django 5.2:

  Argumentet `preserve_request` lades till.

### Exempel

Du kan använda funktionen `redirect()` på flera olika sätt.

1. Genom att skicka något objekt kommer objektets `get_absolute_url()`-metod att anropas för att räkna ut omdirigeringsadressen:

       from django.shortcuts import redirect

       def my_view(request):
           ...
           obj = MyModel.objects.get(...)
           return redirect(obj)

2. Genom att skicka namnet på en vy och eventuellt några positionella eller nyckelordsargument; URL:en kommer att lösas omvänt med hjälp av `reverse()`-metoden:

       def my_view(request):
           ...
           return redirect("some-view-name", foo="bar")

3. Genom att ange en hårdkodad URL att omdirigera till:

       def my_view(request):
           ...
           return redirect("/some/url/")

   Detta fungerar även med fullständiga webbadresser:

       def my_view(request):
           ...
           return redirect("https://example.com/")

Som standard returnerar `redirect()` en tillfällig omdirigering. Alla ovanstående formulär accepterar ett `permanent` argument; om det sätts till `True` kommer en permanent omdirigering att returneras:

    def my_view(request):
        ...
        obj = MyModel.objects.get(...)
        return redirect(obj, permanent=True)

Dessutom kan argumentet `preserve_request` användas för att bevara den ursprungliga HTTP-metoden:

    def my_view(request):
        # ...
        obj = MyModel.objects.get(...)
        if request.method in ("POST", "PUT"):
            # Redirection preserves the original request method.
            return redirect(obj, preserve_request=True)
        # ...

## `resolve_url()`

resolve_url(to, *args, **kwargs)

  Returns a URL string by resolving and normalizing the given `to` argument into a concrete URL. The parameter `to` may be:

  - An object implementing `get_absolute_url()`, in which case the method will be called and its result returned.

  - A view name, view function, or view class, possibly with arguments passed as `*args` and `**kwargs`, in which case `reverse()` will be used to reverse-resolve the view.

  - A URL string, which will be returned unchanged.

  This function is used internally by the `redirect()` shortcut to determine the target URL for the redirect location.

### Exempel

1. Resolving a URL for a model that defines `get_absolute_url()`:

   `modeller.py`

       from django.db import models
       from django.urls import reverse

       class Article(models.Model):
           title = models.CharField(max_length=100)

           def get_absolute_url(self):
               return reverse("article-detail", args=[self.pk])

   `Vyer.py`

       from django.http import JsonResponse
       from django.shortcuts import get_object_or_404, resolve_url
       from .models import Article

       def article_api_view(request, pk):
           """Return metadata about an article, including its canonical URL."""
           article = get_object_or_404(Article, pk=pk)
           return JsonResponse(
               {
                   "id": article.pk,
                   "title": article.title,
                   "url": resolve_url(article),
               }
           )

2. Resolving a target URL for use outside of a redirect, such as in an HTTP response header:

       from django.conf import settings
       from django.http import HttpResponse
       from django.shortcuts import resolve_url

       def login_success(request):
           response = HttpResponse("Login successful")
           response["X-Next-URL"] = resolve_url(settings.LOGIN_REDIRECT_URL)
           return response

## `get_object_or_404()`

get_object_or_404(klass, *args, **kwargs)

aget_object_or_404(klass, *args, **kwargs)

  Asynkron version: `aget_object_or_404()`

  Calls `get()` on a given model manager, but it raises `Http404` instead of the model’s `DoesNotExist` exception.

### Argument

`klass`

  En `Model`-klass, en `Manager`- eller en `QuerySet`-instans från vilken objektet ska hämtas.

`*args`

  `Q-objekt`.

`**kwargs`

  Uppslagsparametrar, som bör vara i det format som accepteras av `get()` och `filter()`.

### Exempel

Följande exempel hämtar objektet med primärnyckeln 1 från `MyModel`:

    from django.shortcuts import get_object_or_404

    def my_view(request):
        obj = get_object_or_404(MyModel, pk=1)

Detta exempel är likvärdigt med:

    from django.http import Http404

    def my_view(request):
        try:
            obj = MyModel.objects.get(pk=1)
        except MyModel.DoesNotExist:
            raise Http404("No MyModel matches the given query.")

Det vanligaste användningsfallet är att skicka en `Model`, som visas ovan. Men du kan också skicka en `QuerySet`-instans:

    queryset = Book.objects.filter(title__startswith="M")
    get_object_or_404(queryset, pk=1)

Exemplet ovan är lite konstruerat eftersom det motsvarar att göra:

    get_object_or_404(Book, title__startswith="M", pk=1)

men det kan vara användbart om du får variabeln `queryset` från någon annanstans.

Slutligen kan du också använda en `Manager`. Detta är användbart till exempel om du har en custom manager:

    get_object_or_404(Book.dahl_objects, title="Matilda")

Du kan också använda `related managers`:

    author = Author.objects.get(name="Roald Dahl")
    get_object_or_404(author.book_set, title="Matilda")

Observera: Precis som med `get()` kommer ett `MultipleObjectsReturned` undantag att uppstå om mer än ett objekt hittas.

## `get_list_or_404()`

get_list_or_404(klass, *args, **kwargs)

aget_list_or_404(klass, *args, **kwargs)

  Asynkron version: `aget_list_or_404()`

  Returns the result of `filter()` on a given model manager cast to a list, raising `Http404` if the resulting list is empty.

### Argument

`klass`

  En `Model`, `Manager` eller `QuerySet` instans från vilken listan ska hämtas.

`*args`

  `Q-objekt`.

`**kwargs`

  Uppslagsparametrar, som bör vara i det format som accepteras av `get()` och `filter()`.

### Exempel

Följande exempel hämtar alla publicerade objekt från `MyModel`:

    from django.shortcuts import get_list_or_404

    def my_view(request):
        my_objects = get_list_or_404(MyModel, published=True)

Detta exempel är likvärdigt med:

    from django.http import Http404

    def my_view(request):
        my_objects = list(MyModel.objects.filter(published=True))
        if not my_objects:
            raise Http404("No MyModel matches the given query.")