```
#### `QueryDict.__getitem__(key)`
Returns the value for the given key. If the key has more than one value,
it returns the last value. Raises
`django.utils.datastructures.MultiValueDictKeyError` if the key does not
exist. (This is a subclass of Python's standard [`KeyError`](https://docs.python.org/3/library/exceptions.html#KeyError), so you can
stick to catching `KeyError`.)
#### `QueryDict.__setitem__(key, value)`
Sets the given key to `[value]` (a list whose single element is
`value`). Note that this, as other dictionary functions that have side
effects, can only be called on a mutable `QueryDict` (such as one that
was created via [`QueryDict.copy()`](#django.http.QueryDict.copy)).
#### `QueryDict.__contains__(key)`
Mengembalikan `True` jika kunci yang diberikan disetel. Ini membuat anda melakukan, misalnya `if "foo" dalam request.GET`.
#### `QueryDict.get(key, default=None)`
Menggunakan logika sama seperti [`__getitem__()`](#django.http.QueryDict.__getitem__), dengan kaitan untuk mengembalikan nilai awalan jika kunci tidak ada.
#### `QueryDict.setdefault(key, default=None)`
Seperti [`dict.setdefault()`](https://docs.python.org/3/library/stdtypes.html#dict.setdefault), kecuai itu menggunakan [`__setitem__()`](#django.http.QueryDict.__setitem__) secara internal.
#### `QueryDict.update(other_dict)`
Takes either a `QueryDict` or a dictionary. Like [`dict.update()`](https://docs.python.org/3/library/stdtypes.html#dict.update),
except it *appends* to the current dictionary items rather than replacing
them. For example:
```
>>> q = QueryDict('a=1', mutable=True)
>>> q.update({'a': '2'})
>>> q.getlist('a')
['1', '2']
>>> q['a'] # returns the last
'2'
```
#### `QueryDict.items()`
Like [`dict.items()`](https://docs.python.org/3/library/stdtypes.html#dict.items), except this uses the same last-value logic as
[`__getitem__()`](#django.http.QueryDict.__getitem__) and returns an iterator object instead of a view object.
For example:
```
>>> q = QueryDict('a=1&a=2&a=3')
>>> list(q.items())
[('a', '3')]
```
#### `QueryDict.values()`
Like [`dict.values()`](https://docs.python.org/3/library/stdtypes.html#dict.values), except this uses the same last-value logic as
[`__getitem__()`](#django.http.QueryDict.__getitem__) and returns an iterator instead of a view object. For
example:
```
>>> q = QueryDict('a=1&a=2&a=3')
>>> list(q.values())
['3']
```
Sebagai tambahan, `QueryDict` mempunyai metode berikut:
#### `QueryDict.copy()`
Mengembalikan salinan dari obyek menggunakan [`copy.deepcopy()`](https://docs.python.org/3/library/copy.html#copy.deepcopy). Salinan ini tidak tetap bahkan jika aslinya tidak.
#### `QueryDict.getlist(key, default=None)`
Returns a list of the data with the requested key. Returns an empty list if
the key doesn't exist and a default value wasn't provided. It's guaranteed
to return a list unless the default value provided isn't a list.
#### `QueryDict.setlist(key, list_)`
Mensetel kunci diberikan pada `list_` (unlike [`__setitem__()`](#django.http.QueryDict.__setitem__)).
#### `QueryDict.appendlist(key, item)`
Menambahkan sebuah barang pada daftar internal terkait dengan kunci.
#### `QueryDict.setlistdefault(key, default_list=None)`
Seperti [`setdefault()`](#django.http.QueryDict.setdefault), kecuali itu mengambil daftar dari nilai-nilai daripada nilai tunggal.
#### `QueryDict.lists()`
Like [`items()`](#django.http.QueryDict.items), except it includes all values, as a list, for each
member of the dictionary. For example:
```
>>> q = QueryDict('a=1&a=2&a=3')
>>> q.lists()
[('a', ['1', '2', '3'])]
```
#### `QueryDict.pop(key)`
Returns a list of values for the given key and removes them from the
dictionary. Raises `KeyError` if the key does not exist. For example:
```
>>> q = QueryDict('a=1&a=2&a=3', mutable=True)
>>> q.pop('a')
['1', '2', '3']
```
#### `QueryDict.popitem()`
Removes an arbitrary member of the dictionary (since there's no concept
of ordering), and returns a two value tuple containing the key and a list
of all values for the key. Raises `KeyError` when called on an empty
dictionary. For example:
```
>>> q = QueryDict('a=1&a=2&a=3', mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
```
#### `QueryDict.dict()`
Returns a `dict` representation of `QueryDict`. For every (key, list)
pair in `QueryDict`, `dict` will have (key, item), where item is one
element of the list, using the same logic as [`QueryDict.__getitem__()`](#django.http.QueryDict.__getitem__):
```
>>> q = QueryDict('a=1&a=3&a=5')
>>> q.dict()
{'a': '5'}
```
#### `QueryDict.urlencode(safe=None)`
Mengembalikan string dari data dalam bentuk string permintaan. Sebagai contoh:
```
>>> q = QueryDict('a=2&b=3&b=5')
>>> q.urlencode()
'a=2&b=3&b=5'
```
Menggunakan parameter `safe` untuk melewatkan karakter yang tidak membutuhkan penyandian. Sebagai contoh:
```
>>> q = QueryDict(mutable=True)
>>> q['next'] = '/a&b/'
>>> q.urlencode(safe='/')
'next=/a%26b/'
```
## Obyek `HttpResponse`
#### `class HttpResponse`
In contrast to [`HttpRequest`](#django.http.HttpRequest) objects, which are created automatically by
Django, [`HttpResponse`](#django.http.HttpResponse) objects are your responsibility. Each view you
write is responsible for instantiating, populating, and returning an
[`HttpResponse`](#django.http.HttpResponse).
Kelas [`HttpResponse`](#django.http.HttpResponse) berada di modul [`django.http`](#module-django.http)
### Penggunaan
#### Melewatkan string
Typical usage is to pass the contents of the page, as a string, to the
[`HttpResponse`](#django.http.HttpResponse) constructor:
```
>>> from django.http import HttpResponse
>>> response = HttpResponse("Here's the text of the Web page.")
>>> response = HttpResponse("Text only, please.", content_type="text/plain")
```
Tetapi jika anda ingin menambahkan isi secara menaik, anda dapat menggunakan `response` sebagai obyek seperti-berkas:
```
>>> response = HttpResponse()
>>> response.write("Here's the text of the Web page.
")
>>> response.write("Here's another paragraph.
")
```
#### Melewatkan perulangan
Finally, you can pass `HttpResponse` an iterator rather than strings.
`HttpResponse` will consume the iterator immediately, store its content as a
string, and discard it. Objects with a `close()` method such as files and
generators are immediately closed.
If you need the response to be streamed from the iterator to the client, you
must use the [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) class instead.
#### Mengatur bidang kepala
Untuk menyetel atau memindahkan bidang kepala dalam tanggapan anda, perlakukan itu seperti sebuah dictionary:
```
>>> response = HttpResponse()
>>> response['Age'] = 120
>>> del response['Age']
```
Note that unlike a dictionary, `del` doesn't raise `KeyError` if the header
field doesn't exist.
For setting the `Cache-Control` and `Vary` header fields, it is recommended
to use the [`patch_cache_control()`](/id/2.1/ref/utils/#django.utils.cache.patch_cache_control) and
[`patch_vary_headers()`](/id/2.1/ref/utils/#django.utils.cache.patch_vary_headers) methods from
[`django.utils.cache`](/id/2.1/ref/utils/#module-django.utils.cache), since these fields can have multiple, comma-separated
values. The "patch" methods ensure that other values, e.g. added by a
middleware, are not removed.
HTTP header fields cannot contain newlines. An attempt to set a header field
containing a newline character (CR or LF) will raise `BadHeaderError`
#### memberitahu peramban untuk memperlakukan tanggapan sebagai sebuah berkas lampiran
To tell the browser to treat the response as a file attachment, use the
`content_type` argument and set the `Content-Disposition` header. For example,
this is how you might return a Microsoft Excel spreadsheet:
```
>>> response = HttpResponse(my_data, content_type='application/vnd.ms-excel')
>>> response['Content-Disposition'] = 'attachment; filename="foo.xls"'
```
There's nothing Django-specific about the `Content-Disposition` header, but
it's easy to forget the syntax, so we've included it here.
### Atribut
#### `HttpResponse.content`
Sebuah bytestring mewakili isi, disandikan dari string jika dibutuhkan.
#### `HttpResponse.charset`
A string denoting the charset in which the response will be encoded. If not
given at `HttpResponse` instantiation time, it will be extracted from
`content_type` and if that is unsuccessful, the
[`DEFAULT_CHARSET`](/id/2.1/ref/settings/#std-setting-DEFAULT_CHARSET) setting will be used.
#### `HttpResponse.status_code`
[**HTTP status code**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6) untuk tanggapan.
Unless [`reason_phrase`](#django.http.HttpResponse.reason_phrase) is explicitly set, modifying the value of
`status_code` outside the constructor will also modify the value of
`reason_phrase`.
#### `HttpResponse.reason_phrase`
Ungkapan alasan HTTP untuk tanggapan. Itu menggunakan ungkapan tanggapan awalan [**HTTP standard's**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6.1).
Meskipun secara tegas mensetel, `reason_phrase` ditentukan oleh nilai [`status_code`](#django.http.HttpResponse.status_code).
#### `HttpResponse.streaming`
Ini selalu `False`.
Atribut ini ada sehingga middleware dapat memperlakukan aliran tanggapan berbeda dari tanggapan biasanya.
#### `HttpResponse.closed`
`True` jika tanggapan telah ditutup.
### Cara
#### `HttpResponse.__init__(content='', content_type=None, status=200, reason=None, charset=None)`
Memakai sebuah obyek `HttpResponse` dengan isi halaman diberikan dan jenis isi.
`content` should be an iterator or a string. If it's an
iterator, it should return strings, and those strings will be
joined together to form the content of the response. If it is not
an iterator or a string, it will be converted to a string when
accessed.
`content_type` is the MIME type optionally completed by a character set
encoding and is used to fill the HTTP `Content-Type` header. If not
specified, it is formed by the [`DEFAULT_CONTENT_TYPE`](/id/2.1/ref/settings/#std-setting-DEFAULT_CONTENT_TYPE) and
[`DEFAULT_CHARSET`](/id/2.1/ref/settings/#std-setting-DEFAULT_CHARSET) settings, by default: "text/html; charset=utf-8".
`status` adalah [**HTTP status code**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6) untuk tanggapan.
`reason` adalah ungkapan tanggapan HTTP. Jika tidak disediakan, ungkapan awalan akan digunakan.
`charset` is the charset in which the response will be encoded. If not
given it will be extracted from `content_type`, and if that
is unsuccessful, the [`DEFAULT_CHARSET`](/id/2.1/ref/settings/#std-setting-DEFAULT_CHARSET) setting will be used.
#### `HttpResponse.__setitem__(header, value)`
Setel nama kepala diberikan pada nilai diberikan. Kedua `header` dan `value` harus berupa string.
#### `HttpResponse.__delitem__(header)`
Hapus kepala dengan nama diberikan. Gagal diam jika kepala tidak ada. kasus-tidak-peka.
#### `HttpResponse.__getitem__(header)`
Mengembalikan nilai untk nama kepala diberikan. Kasus-tidak-peka.
#### `HttpResponse.has_header(header)`
Mengembalikan `True` atau `False` berdasarkan pada pemeriksaan kasus-tidak-peka untuk kepala dengan nama diberikan.
#### `HttpResponse.setdefault(header, value)`
Setel sebuah kepala meskipun itu sudah dikirim.
#### `HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False, samesite=None)`
Setel sebuah kue. Parameter sama seperti dalam obyek kue [`Morsel`](https://docs.python.org/3/library/http.cookies.html#http.cookies.Morsel) dalam pustaka standar Python.
- `max_age` harus berupa angka detik, atau `None` (awalan) jika kue harus hanya berada selama sesi peramban klien. Jika `expires` tidak ditentukan, itu akan dihitung.
- `expires` harus salah satu berupa string dalam bentuk `"Wdy, DD-Mon-YY HH:MM:SS GMT"` atau obyek `datetime.datetime` dalam UTC. Jika `expires` adalah obyek `datetime`, `max_age` akan dihitung.
- Gunakan\`\`domain\`\` jika anda ingi mensetel kue lintas-ranah. Sebagai contoh, `domain="example.com"` akan mensetel sebuah kue yang dapat dibaca oleh ranah www.example.com, blog.example.com, dll. Sebaliknya, sebuah kue akan hanya dapat dibaca oleh ranah yang mensetel nya.
- Gunakan `httponly=True` jika anda ingin mencegah javaScript sisi-klien dari memiliki akses ke kue.
[HTTPOnly](https://www.owasp.org/index.php/HTTPOnly) adalah sebuah bendera disertakan dalam sebuah kepala penangan HTTP Set-Cookie. Itu bukan bagian dari standar [**RFC 2109**](https://datatracker.ietf.org/doc/html/rfc2109.html) untuk kue, dan itu tidak dihormati secara konsisten oleh semua peramban. Bagaimanapun, ketika itu dihormati, itu dapat berguna cara untuk mengurangi resiko dari tulisan sisi-klien dari mengakses data kue terlindungi.
- Use `samesite='Strict'` or `samesite='Lax'` to tell the browser not
to send this cookie when performing a cross-origin request. [SameSite](https://www.owasp.org/index.php/SameSite)
isn't supported by all browsers, so it's not a replacement for Django's
CSRF protection, but rather a defense in depth measure.
> **Changed in Django 2.1**
>
> Argumen `samesite` telah ditambahkan.
> **Warning**
>
> Both [**RFC 2109**](https://datatracker.ietf.org/doc/html/rfc2109.html) and [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html) state that user agents should support
> cookies of at least 4096 bytes. For many browsers this is also the
> maximum size. Django will not raise an exception if there's an attempt
> to store a cookie of more than 4096 bytes, but many browsers will not
> set the cookie correctly.
#### `HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False, samesite=None)`
Like [`set_cookie()`](#django.http.HttpResponse.set_cookie), but
[cryptographic signing](/id/2.1/topics/signing/) the cookie before setting
it. Use in conjunction with [`HttpRequest.get_signed_cookie()`](#django.http.HttpRequest.get_signed_cookie).
You can use the optional `salt` argument for added key strength, but
you will need to remember to pass it to the corresponding
[`HttpRequest.get_signed_cookie()`](#django.http.HttpRequest.get_signed_cookie) call.
#### `HttpResponse.delete_cookie(key, path='/', domain=None)`
Menghapus kue dengan kunci yang diberikan. Gagal secara diam jika kunci tidak ada.
Dikarenakan cara kue bekerja, `path` dan `domain` harus berupa nilai sama anda gunakan dalam `set_cookie()` -- sebaliknya kue mungkin tidak dihapus.
#### `HttpResponse.write(content)`
Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) sebuah obyek seperti-berkas.
#### `HttpResponse.flush()`
Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) sebuah obyek seperti-berkas.
#### `HttpResponse.tell()`
Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) sebuah obyek seperti-berkas.
#### `HttpResponse.getvalue()`
Mengembalikan nilai dari [`HttpResponse.content`](#django.http.HttpResponse.content). Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) sebuah obyek seperti-aliran.
#### `HttpResponse.readable()`
Selalu `False`. Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) obyek seperti-aliran.
#### `HttpResponse.seekable()`
Selalu `False`. Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) obyek seperti-aliran.
#### `HttpResponse.writable()`
Selalu `True`. Metode ini membuat sebuah instance [`HttpResponse`](#django.http.HttpResponse) obyek seperti-aliran.
#### `HttpResponse.writelines(lines)`
Tulis sebuah baris pada tanggapan. Pemisah baris tidak ditambahkan. Metode ini membuat sebuah contoh [`HttpResponse`](#django.http.HttpResponse) sebuah obyek seperti-aliran.
### Subkelas `HttpResponse`
Django menyertakan sebuah angka dari subkelas-subkelas `HttpResponse` yang menangani jenis-jenis berbeda dari tanggapan HTTP. Seperti `HttpResponse`, subkelas-subkelas ini tinggal dalam [`django.http`](#module-django.http).
#### `class HttpResponseRedirect`
The first argument to the constructor is required -- the path to redirect
to. This can be a fully qualified URL
(e.g. `'https://www.yahoo.com/search/'`), an absolute path with no domain
(e.g. `'/search/'`), or even a relative path (e.g. `'search/'`). In that
last case, the client browser will reconstruct the full URL itself
according to the current path. See [`HttpResponse`](#django.http.HttpResponse) for other optional
constructor arguments. Note that this returns an HTTP status code 302.
#### `url`
Ini atribut hanya-baca mewakili tanggapan URL akan mengalihkan ke (setara pada kepala tanggapan `Location`).
#### `class HttpResponsePermanentRedirect`
Seperti [`HttpResponseRedirect`](#django.http.HttpResponseRedirect), tetapi itu mengembalikan pengalihan tetap (kode keadaan HTTP 301) daripada pengalihan "found" (kode keadaan 302).
#### `class HttpResponseNotModified`
Pembangun tidak mengambil argumen apapun dan tidak ada isi harus ditambahkan pada tanggapan ini. Gunakan ini untuk merancang bahwa sebuah halaman belum dirubah sejak permintaan terakhir pengguna (kode keadaan 304).
#### `class HttpResponseBadRequest`
Bertindak seperti [`HttpResponse`](#django.http.HttpResponse) tetapi menggunakan kode keadaan 400.
#### `class HttpResponseNotFound`
Bertindak seperti [`HttpResponse`](#django.http.HttpResponse) tetapi menggunakan kode keadaan 404.
#### `class HttpResponseForbidden`
Bertindak seperti [`HttpResponse`](#django.http.HttpResponse) tetapi menggunakan kode keadaan 403.
#### `class HttpResponseNotAllowed`
Seperti [`HttpResponse`](#django.http.HttpResponse), tetapi menggunakan kode keadaan 405. Argumen pertama pada pembangun adalah dibutuhkan: sebuah daftar metode-metode diizinkan (misalnya `['GET', 'POST']`).
#### `class HttpResponseGone`
Bertindak seperti [`HttpResponse`](#django.http.HttpResponse) tetapi menggunakan kode keadaan 410.
#### `class HttpResponseServerError`
Bertindak seperti [`HttpResponse`](#django.http.HttpResponse) tetapi menggunakan kode keadaan 500.
> **Note**
>
> If a custom subclass of [`HttpResponse`](#django.http.HttpResponse) implements a `render`
> method, Django will treat it as emulating a
> [`SimpleTemplateResponse`](/id/2.1/ref/template-response/#django.template.response.SimpleTemplateResponse), and the
> `render` method must itself return a valid response object.
## Obyek `JsonResponse`
#### `class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)`
An [`HttpResponse`](#django.http.HttpResponse) subclass that helps to create a JSON-encoded
response. It inherits most behavior from its superclass with a couple
differences:
Kepala awalannya `Content-Type` disetel menjadi `application/json`.
Parameter pertama, `data`, harus berupa sebuah contoh `dict`. Jika parameter `safe` disetel menjadi `False` (lihat dibawah) itu dapat berupa obyek JSON-dapat-diserialisasi apapun.
`encoder`, yang awalan pada [`django.core.serializers.json.DjangoJSONEncoder`](/id/2.1/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder), akan digunakan untuk menserialkan data. Lihat [JSON serialization](/id/2.1/topics/serialization/#serialization-formats-json) untuk rincian lebih tentang penserial ini.
Parameter boolean `safe` awalan pada `True`. Jika itu disetel menjadi `False`, obyek apapun dapat dilewatkan untuk serialisasi (sebaliknya hanya contoh `dict` diizinkan). Jika `safe` adalah `True` dan obyek bukan-`dict` dilewatkan sebagai argumen pertama, sebuah [`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) akan dimunculkan.
Parameter `json_dumps_params` adalah sebuah dictionary dari argumen kata kunci untuk dilewatkan ke panggilan `json.dumps()` digunakan untuk membangkitkan tanggapan.
### Penggunaan
Penggunaan tertentu dapat terlihat seperti:
```
>>> from django.http import JsonResponse
>>> response = JsonResponse({'foo': 'bar'})
>>> response.content
b'{"foo": "bar"}'
```
#### Menserialkan obyek bukan-dictionary
Untuk menserialkan obyek selain dari `dict` anda harus mensetel parameter `safe` menjadi `False`:
```
>>> response = JsonResponse([1, 2, 3], safe=False)
```
Tanpa melewatkan `safe=False`, sebuah [`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) akan dimunculkan.
> **Warning**
>
> Sebelum [5th edition of ECMAScript](https://www.ecma-international.org/ecma-262/5.1/index.html#sec-11.1.4) itu memungkinkan meracuni pembangun `Array` JavaScript. Untuk alasan ini, Django tidak mengizinkan obyek bukan-dict ke pembangun [`JsonResponse`](#django.http.JsonResponse) secara awalan. Bagaimanapun, kebanyakan peramban modern menerapkan EcmaScript 5 yang memindahkan serangan vektor ini. Karena itu memungkinkan untuk meniadakan pencegahan keamanan ini.
#### Merubah penyandi JSON awalan
Anda butuh menggunakan kelas penyandi JSON berbeda anda dapat lewatkan parameter `encoder` ke metode pembangun:
```
>>> response = JsonResponse(data, encoder=MyJSONEncoder)
```
## Obyek `StreamingHttpResponse`
#### `class StreamingHttpResponse`
Kelas [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) digunakan untuk aliran tanggapan dari Django ke peramban. Anda mungkin ingin melakukan ini jika membangkitkan tanggapan terlalu alam atau terlalu banyak menggunakan memori. Sebagai contoh, itu berguna untuk [generating large CSV files](/id/2.1/howto/outputting-csv/#streaming-csv-files).
> **Pertimbangan penampilan**
>
> Django is designed for short-lived requests. Streaming responses will tie
> a worker process for the entire duration of the response. This may result
> in poor performance.
>
> Generally speaking, you should perform expensive tasks outside of the
> request-response cycle, rather than resorting to a streamed response.
The [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) is not a subclass of [`HttpResponse`](#django.http.HttpResponse),
because it features a slightly different API. However, it is almost identical,
with the following notable differences:
- Itu seharusnya memberikan sebuah perulangan yang menghasilkan string sebagai isi.
- You cannot access its content, except by iterating the response object
itself. This should only occur when the response is returned to the client.
- Itu tidak mempunyai atribut `content`. Sebagai gantinya, itu memiliki atribut [`streaming_content`](#django.http.StreamingHttpResponse.streaming_content).
- Anda tidak dapat menggunakan obyek seperti-berkas metode `tell()` atau `write()`. Melakukan itu akan memunculkan sebuah pengecualian.
[`StreamingHttpResponse`](#django.http.StreamingHttpResponse) should only be used in situations where it is
absolutely required that the whole content isn't iterated before transferring
the data to the client. Because the content can't be accessed, many
middleware can't function normally. For example the `ETag` and
`Content-Length` headers can't be generated for streaming responses.
### Atribut
#### `StreamingHttpResponse.streaming_content`
Sebuah perulang dari string mewakili isi.
#### `StreamingHttpResponse.status_code`
[**HTTP status code**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6) untuk tanggapan.
Unless [`reason_phrase`](#django.http.StreamingHttpResponse.reason_phrase) is explicitly set, modifying the value of
`status_code` outside the constructor will also modify the value of
`reason_phrase`.
#### `StreamingHttpResponse.reason_phrase`
Ungkapan alasan HTTP untuk tanggapan. Itu menggunakan ungkapan tanggapan awalan [**HTTP standard's**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6.1).
Meskipun secara tegas mensetel, `reason_phrase` ditentukan oleh nilai [`status_code`](#django.http.StreamingHttpResponse.status_code).
#### `StreamingHttpResponse.streaming`
Ini selalu `True`.
## Obyek `FileResponse`
#### `class FileResponse(open_file, as_attachment=False, filename='', **kwargs)`
[`FileResponse`](#django.http.FileResponse) adalah subkelas dari [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) dioptimalkan untuk berkas biner. Itu menggunakan [wsgi.file\_wrapper](https://www.python.org/dev/peps/pep-3333/#optional-platform-specific-file-handling) jika disediakan oleh peladen wsgi, sebaliknya itu mengalir berkas keluar dalam potongan kecil.
Jika `as_attachment=True`, kepala Content-Disposition\`\`disetel, yang meminta peramban menawarkan berkas ke pengguna sebagai unduhan.
If `open_file` doesn't have a name or if the name of `open_file` isn't
appropriate, provide a custom file name using the `filename` parameter.
The `Content-Length`, `Content-Type`, and `Content-Disposition`
headers are automatically set when they can be guessed from contents of
`open_file`.
> **New in Django 2.1**
>
> The `as_attachment` and `filename` keywords argument were added.
> Also, `FileResponse` sets the `Content` headers if it can guess
> them.
`FileResponse` menerima obyek seperti-berkas apapun dengan isi biner, sebagai contoh sebuah berkas dibuka dalam suasana biner sebagai berikut:
```
>>> from django.http import FileResponse
>>> response = FileResponse(open('myfile.png', 'rb'))
```
Berkas akan ditutup otomatis, jadi jangan membuka itu dengan pengelola konteks.
### Cara
#### `FileResponse.set_headers(open_file)`
> **New in Django 2.1**
This method is automatically called during the response initialization and
set various headers (`Content-Length`, `Content-Type`, and
`Content-Disposition`) depending on `open_file`.