# dokumentasi Django 2.2.9.dev20191202104323

# Menulis tampilan

A view function, or view for short, is simply a Python function that takes a Web request and returns a Web response. This response can be the HTML contents of a Web page, or a redirect, or a 404 error, or an XML document, or an image . . . or anything, really. The view itself contains whatever arbitrary logic is necessary to return that response. This code can live anywhere you want, as long as it's on your Python path. There's no other requirement--no "magic," so to speak. For the sake of putting the code somewhere, the convention is to put views in a file called `views.py`, placed in your project or application directory.

## Tampilan sederhana

Disini adalah tampilan yang mengembalikan data dan waktu saat ini, sebagai sebuah dokumen HTML:

    from django.http import HttpResponse
    import datetime

    def current_datetime(request):
        now = datetime.datetime.now()
        html = "<html><body>It is now %s.</body></html>" % now
        return HttpResponse(html)

Mari kita melangkah melalui kode ini satu baris pada saat bersamaan:

- Pertama, kami impor kelas `HttpResponse` dari modul `django.http`, bersama dengan pustaka `datetime` Python.

- Next, we define a function called `current_datetime`. This is the view function. Each view function takes an `HttpRequest` object as its first parameter, which is typically named `request`.

  Note that the name of the view function doesn't matter; it doesn't have to be named in a certain way in order for Django to recognize it. We're calling it `current_datetime` here, because that name clearly indicates what it does.

- Tampilan mengembalikan sebuah obyek `HttpResponse` yang mengandung tanggapan dibangkitkan. Setiap fungsi tampilan bertanggungjawab untuk mengembalikan sebuah obyek `HttpResponse`. (ada pengecualian, tetapi kita akan kesana nanti.)

Zona Waktu Django

Django menyertakan sebuah pengaturan `TIME_ZONE` yang awalan pada `America/Chicago`. Ini mungkin bukan dimana anda tinggal, jadi anda mungkin ingin merubah itu dalam berkas pengaturan anda.

## Memetakan URL ke tampilan

Jadi, untuk mengikhtisarkan, fungsi tampilan ini mengembalikan sebuah halaman HTML yang menyertakan tanggal dan waktu saat ini. Untuk menampilkan tampilan ini pada URL tertentu, anda akan butuh membuat sebuah URLconf; lihat Pengirim URL untuk petunjuk.

## Mengembalikan kesalahan

Mengembalikan kode-kode kesalahan HTTP dalam Django adalah mudah. Ada subkelas-subkelas dari `HttpResponse` untuk sejumlah kode-kode keadaan HTTP umum selain dari 200 (yang berarti "OK"). Anda dapat menemukan daftar penuh dari subkelas-subkelas tersedia dalam dokumentasi request/response 1. Cukup mengembalikan satu dari subkelas-subkelas tersebut daripada `HttpResponse` biasa untuk menandakan sebuah kesalahan. Sebagai contoh:

    from django.http import HttpResponse, HttpResponseNotFound

    def my_view(request):
        # ...
        if foo:
            return HttpResponseNotFound('<h1>Page not found</h1>')
        else:
            return HttpResponse('<h1>Page was found</h1>')

Tidak ada subkelas khusus untuk setiap kemungkinan kode tanggapan HTTP, sejak banyak dari mereka tidak akan menjadi yang umum. Bagaimanapun, seperti didokumentasikan dalam dokumentasi `HttpResponse`, anda dapat juga melewatkan kode keadaan HTTP kedalam pembangun untuk `HttpResponse` untuk membuat kelas kembalian untuk kode keadaan apapun anda sukai. Sebagai contoh:

    from django.http import HttpResponse

    def my_view(request):
        # ...

        # Return a "created" (201) response code.
        return HttpResponse(status=201)

Karena kesalahan 404 sejauh ini paling umum kesalahan HTTP, ada sebuah cara paling mudah untuk menangani kesalahan-kesalahan tersebut.

### Pengecualian `Http404`

class `django.http.``Http404`

Ketika anda mengembalikan sebuah kesalahan seperti `HttpResponseNotFound`, anda bertanggung jawab untuk menentukan HTML dari menghasilkan halaman kesalahan:

    return HttpResponseNotFound('<h1>Page not found</h1>')

Untuk kenyamanan, dan karena itu adalah ide bagus untuk memiliki halaman kesalahan 404 tetap terhadap situs anda, Django menyediakan sebuah pengecualian `Http404` pada titik apapun dalam fungsi tampilan, Django akan menangkap itu dan mengembalikan halaman kesalahan standar untuk aplikasi anda, bersama dengan sebuah kode kesalahan HTTP 404.

Contoh penggunaan:

    from django.http import Http404
    from django.shortcuts import render
    from polls.models import Poll

    def detail(request, poll_id):
        try:
            p = Poll.objects.get(pk=poll_id)
        except Poll.DoesNotExist:
            raise Http404("Poll does not exist")
        return render(request, 'polls/detail.html', {'poll': p})

Untuk menampilkan HTML disesuaikan ketika Django mengembalikan sebuah 404, anda dapat membuat sebuah cetakan HTML bernama `404.html` dan menempatkan itu dalam tingkat atas dari pohon cetakan anda. Cetakan anda kemudian akan dilayani ketika `DEBUG` disetel menjadi `False`.

Ketika `DEBUG` adalah `True`, anda dapat menyediakan sebuah pesan pada `Http404` dan itu akan muncul dalam cetakan mencari kesalahan 404 standar. Gunakan pesan-pesan ini untuk tujuan mencari kesalahan; mereka umumnya tidak cocok untuk digunakan dalam produksi cetakan 404.

## Menyesuaikan tampilan kesalahan

Tampilan-tampilan kesalahan awalan dalam Django harus cukup untuk kebanyakan aplikasi Jaringan, tetapi dapat dengan mudan ditimpa jika anda butuh penyesuaian perilaku apapun. Cukup menentukan penangan seperti dilihat dibawah dalam URLconf (mengatur mereka dimanapun tidak akan mempunyai pengaruh).

Tampilan `page_not_found()` ditimpa oleh `handler404`:

    handler404 = 'mysite.views.my_custom_page_not_found_view'

Tampilan `server_error()` ditimpa oleh `handler500`:

    handler500 = 'mysite.views.my_custom_error_view'

Tampilan `permission_denied()` ditimpa oleh `handler403`:

    handler403 = 'mysite.views.my_custom_permission_denied_view'

Tampilan `bad_request()` ditimpa oleh `handler400`:

    handler400 = 'mysite.views.my_custom_bad_request_view'

lihat juga

Gunakan pengaturan `CSRF_FAILURE_VIEW` untuk menimpa tampilan kesalahan CSRF.

### Testing custom error views

To test the response of a custom error handler, raise the appropriate exception in a test view. For example:

    from django.core.exceptions import PermissionDenied
    from django.http import HttpResponse
    from django.test import SimpleTestCase, override_settings
    from django.urls import path

    def response_error_handler(request, exception=None):
        return HttpResponse('Error handler content', status=403)

    def permission_denied_view(request):
        raise PermissionDenied

    urlpatterns = [
        path('403/', permission_denied_view),
    ]

    handler403 = response_error_handler

    # ROOT_URLCONF must specify the module that contains handler403 = ...
    @override_settings(ROOT_URLCONF=__name__)
    class CustomErrorHandlerTests(SimpleTestCase):

        def test_handler_renders_template_response(self):
            response = self.client.get('/403/')
            # Make assertions on the response here. For example:
            self.assertContains(response, 'Error handler content', status_code=403)