# Dokumentasi Django 6.0.7

# Fungsi jalan pintas Django

The package `django.shortcuts` collects helper functions and classes that "span" multiple levels of MVC. In other words, these functions/classes introduce controlled coupling for convenience's sake.

## `render()`

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

  Combines a given template with a given context dictionary and returns an `HttpResponse` object with that rendered text.

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

### Argumen dibutuhkan

`request`

  Objek peminta digunakan untuk membangkitkan tanggapa ini.

`template_name`

  The full name of a template to use or sequence of template names. If a sequence is given, the first template that exists will be used. See the template loading documentation for more information on how templates are found.

### Argumen pilihan

`context`

  Nilai kamus untuk ditambah ke konteks cetakan. Secara awalan, ini adalah kamus kosong. Jika nilai di kamus adalah callable, tampilan akan memanggilnya sesaat sebelum membangun cetakan.

`content_type`

  Jenis MIME digunakan untuk menghasilkan dokumen. Awalan menjadi `'text/html'`.

`status`

  Kode status untuk tanggapan. Awalan menjadi `200`.

`using`

  `NAME` dari mesin cetakan untuk digunakan untuk memuat cetakan.

### Contoh

Contoh berikut membangun cetakan `myapp/index.html` dengan jenis MIME 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",
        )

Contoh ini setara pada:

    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")

## `redirect()`

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

  Mengembalikan `HttpResponseRedirect` ke URL yang sesuai untuk argument dilewatkan.

  Argumen dapat menjadi:

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

  - Nama tampilan, kemungkinan dengan argumen: `reverse()` akan digunakan untuk membalikkan-menyelesaikan nama.

  - Sebuah URL mutlak atau relatif, yang akan digunakan dengan adanya untuk pengalihan lokasi.

  By default, a temporary redirect is issued with a 302 status code. If `permanent=True`, a permanent redirect is issued with a 301 status code.

  If `preserve_request=True`, the response instructs the user agent to preserve the method and body of the original request when issuing the redirect. In this case, temporary redirects use a 307 status code, and permanent redirects use a 308 status code. This is better illustrated in the following table:

  permanent | preserve_request | HTTP status code
  --- | --- | ---
  `True` | `False` | 301
  `False` | `False` | 302
  `False` | `True` | 307
  `True` | `True` | 308

  An optional `max_length` keyword argument can be provided to override the maximum allowed length for the redirect URL. Set it to `None` to disable the length check.

  Changed in Django 6.1:

  `max_length` was added.

### Contoh

Anda dapat menggunakan fungsi `redirect()` dalam sejumlah cara.

1. Dengan melewatkan beberapa objek; metode objek `get_absolute_url()` akan dipanggil untuk mencari tahu URL pengalihan:

       from django.shortcuts import redirect

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

2. Dengan melewatkan nama dari tampilan dan pilihan beberapa popsisi atau argumen kata kunci; URL akan dibalikkan menggunakan metode `reverse()`:

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

3. Dengan melewatkan URL kode keras ke pengalihan pada:

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

   Ini juga bekerja dengan URL penuh:

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

Secara awalan, `redirect()` mengembalikan peralihan sementara. Semua dari formulir diatas menerima argumen `permanent`; jika disetel menjadi `True` pengalihan tetap akan dikembalikan:

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

Additionally, the `preserve_request` argument can be used to preserve the original HTTP method:

    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.

### Contoh

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

   `models.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])

   `views.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)

  Asynchronous version: `aget_object_or_404()`

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

### Argumen

`klass`

  Kelas `Model`, a `Manager`, atau instance `QuerySet` dari mana untuk mendapatkan objek.

`*args`

  Obyek Q().

`**kwargs`

  Parameter pencarian, yang harus berupa dalam bentuk diterima oleh `get()` dan `filter()`.

### Contoh

Contoh berikut mendapatkan objek dengan primary key 1 dari `MyModel`:

    from django.shortcuts import get_object_or_404

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

Contoh ini setara pada:

    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.")

Kasus penggunaan paling umum adalah melewatkan `Model`, seperti ditunjukkan diatas. Bagaimanapun, anda dapat juga melewatkan instance `QuerySet`:

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

Contoh di atas agak dibuat-buat karena setara dengan melakukan:

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

tetapi itu dapat berguna jika anda melewati variabel `queryset` dari tempat lain.

Akhirnya, anda dapat juga menggunakan `Manager`. Ini berguna untuk contoh jika anda mempunyai custom manager:

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

Anda dapat juga menggunakan `related managers`:

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

Catat: Seperti `get()`, eksepsi `MultipleObjectsReturned` akan dimunculkan jika lebih dari satu objek ditemukan.

## `get_list_or_404()`

get_list_or_404(klass, *args, **kwargs)

aget_list_or_404(klass, *args, **kwargs)

  Asynchronous 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.

### Argumen

`klass`

  Instance `Model`, `Manager` atau `QuerySet` dimana mendapatkan list.

`*args`

  Obyek Q().

`**kwargs`

  Parameter pencarian, yang harus berupa dalam bentuk diterima oleh `get()` dan `filter()`.

### Contoh

Contoh berikut mendapatkan semua objek diterbitkan dari `MyModel`:

    from django.shortcuts import get_list_or_404

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

Contoh ini setara pada:

    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.")