```
#### `QueryDict.__getitem__(key)`
Returns the last value for the given key; or an empty list (`[]`) if the
key exists but has no values. 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`.)
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.__getitem__("a")
'3'
>>> q.__setitem__("b", [])
>>> q.__getitem__("b")
[]
```
#### `QueryDict.__setitem__(key, value)`
Socraíonn an eochair a thugtar go `[luach]` (liosta a bhfuil a ghné aonair `luach`). Tabhair faoi deara nach féidir é seo, mar fheidhmeanna foclóra eile a bhfuil fo-iarsmaí acu, a ghlaoch ach ar Querydict\` athraithe (mar shampla ceann a cruthaíodh via: meth: Querydict.copy).
#### `QueryDict.__contains__(key)`
Tugann sé ar ais `True` má tá an eochair tugtha socraithe. Ligeann sé seo duit, m.sh., if “foo” in request.get\` a dhéanamh.
#### `QueryDict.get(key, default=None)`
Úsáideann sé an loighic chéanna amha:meth: \_\_getitem\_\_, le crúca chun luach réamhshocraithe a thabhairt ar ais mura bhfuil an eochair ann.
#### `QueryDict.setdefault(key, default=None)`
Cosúil le: Meth: dict.setdefault, ach amháin go n-úsáideann sé: meth: \_\_setitem\_\_ go hinmheánach.
#### `QueryDict.update(other_dict)`
Tógann sé `Querydict` nó foclóir. Cosúil le: Meth: dict.update, seachas aigh\* cuireann sé leis na míreanna foclóra reatha seachas iad a chur in ionad. Mar shampla:
```pycon
>>> q = QueryDict("a=1", mutable=True)
>>> q.update({"a": "2"})
>>> q.getlist("a")
['1', '2']
>>> q["a"] # returns the last
'2'
```
#### `QueryDict.items()`
Cosúil le: Meth: dict.items, ach amháin go n-úsáideann sé seo an loighic luach deiridh céanna mar: meth: \_\_getitem\_\_ agus filleann sé réad athraitheora in ionad réad amharc. Mar shampla:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.items())
[('a', '3')]
```
#### `QueryDict.values()`
Cosúil le: Meth: dict.values, ach amháin go n-úsáideann sé seo an loighic luach deiridh céanna mar: meth: \_\_getitem\_\_ agus filleann sé athraitheoir in ionad réad amharc. Mar shampla:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.values())
['3']
```
Ina theannta sin, tá na modhanna seo a leanas ag `Querydict`:
#### `QueryDict.copy()`
Tugann cóip den réad ar ais ag baint úsáid:func: copy.deepcopy. Beidh an cóip seo inathraithe fiú mura raibh an bunaidh.
#### `QueryDict.getlist(key, default=None)`
Tugann liosta de na sonraí ar ais leis an eochair iarrtha. Tugann liosta folamh ar ais mura bhfuil an eochair ann agus is é `réamhshocraithe` `None`. Ráthaítear liosta a thabhairt ar ais mura bhfuil liosta an luach réamhshocraithe a chuirtear ar fáil.
#### `QueryDict.setlist(key, list_)`
Socraíonn an eochair a thugtar go `list_` (gan cosúil: meth: \_\_setitem\_\_).
#### `QueryDict.appendlist(key, item)`
Cuireann sé mír leis an liosta inmheánach a bhaineann leis an eochair.
#### `QueryDict.setlistdefault(key, default_list=None)`
Cosúil le: Meth: setdefault, ach amháin go dtógann sé liosta luachanna in ionad luach amháin.
#### `QueryDict.lists()`
Cosúil le: Meth: items () , ach amháin go n-áirítear leis na luachanna go léir, mar liosta, do gach ball den fhoclóir. Mar shampla:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> q.lists()
[('a', ['1', '2', '3'])]
```
#### `QueryDict.pop(key)`
Tugann liosta luachanna ar ais don eochair a thugtar agus baineann sé iad ón bhfoclóir. Ardaíonn sé `Keyerror` mura bhfuil an eochair ann. Mar shampla:
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.pop("a")
['1', '2', '3']
```
#### `QueryDict.popitem()`
Baineann sé ball treallach den fhoclóir (ós rud é nach bhfuil aon choincheap ordaithe ann), agus tugann sé tuple dhá luach ina bhfuil an eochair agus liosta de na luachanna go léir don eochair. Ardaíonn sé `Keyerror` nuair a ghairtear ar fhoclóir folamh. Mar shampla:
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
```
#### `QueryDict.dict()`
Tugann sé ionadaíocht `dict` ar `Querydict` ar ais. I gcás gach péire (eochair, liosta) i QueryDict\`, beidh (eochair, mír) ag `dict`, áit a bhfuil mír eilimint amháin den liosta, ag baint úsáide as an loighic chéanna amha:meth: QueryDict. \_\_getitem\_\_:
```pycon
>>> q = QueryDict("a=1&a=3&a=5")
>>> q.dict()
{'a': '5'}
```
#### `QueryDict.urlencode(safe=None)`
Filleann sreang de na sonraí i bhformáid sreangán fiosrúcháin. Mar shampla:
```pycon
>>> q = QueryDict("a=2&b=3&b=5")
>>> q.urlencode()
'a=2&b=3&b=5'
```
Úsáid an paraiméadar `sábháilte` chun carachtair nach dteastaíonn ionchódú uathu a rith. Mar shampla:
```pycon
>>> q = QueryDict(mutable=True)
>>> q["next"] = "/a&b/"
>>> q.urlencode(safe="/")
'next=/a%26b/'
```
## `HttpResponse` rudaí
#### `class HttpResponse`
I gcodarsnacht le:class: rudaí HttpRequest, a chruthaíonn Django go huathoibríoch, :class: Is iad rudaí HttpResponse freagracht ort. Tá gach radharc a scríobhann tú freagrach as: class: HttpResponse a chur ar aghaidh, a dhaonrú agus a thabhairt ar ais.
Tá an rang:class: HttpResponse ina gcónaí sa mhodúl:mod: django.http.
### Úsáid
#### Steaghráin a rith
Is é an úsáid tipiciúil ná ábhar an leathanaigh, mar shreang, bytestring, nó:class: memoryview, a chur chuig an tógálaí:class: HttpResponse:
```pycon
>>> from django.http import HttpResponse
>>> response = HttpResponse("Here's the text of the web page.")
>>> response = HttpResponse("Text only, please.", content_type="text/plain")
>>> response = HttpResponse(b"Bytestrings are also accepted.")
>>> response = HttpResponse(memoryview(b"Memoryview as well."))
```
Ach más mian leat ábhar a chur le chéile, is féidir leat freagra a úsáid mar réad cosúil le comhad:
```pycon
>>> response = HttpResponse()
>>> response.write("Here's the text of the web page.
")
>>> response.write("Here's another paragraph.
")
```
#### Athraitheoirí a rith
Faoi dheireadh, is féidir leat HttpResponse\` a chur ar athraitheoir seachas teaghráin. Itheoidh `HttpResponse` an t-athraitheoir láithreach, stóráilfidh sé a ábhar mar shreang, agus caitheann sé é. Dúntar rudaí le modh close () mar shampla comhaid agus gineadóirí láithreach.
Más gá duit an freagra a shruthú ón iterator chuig an gcliant, ní mór duit an rang:class: StreamInghttPresponse a úsáid ina ionad.
#### Réimsí ceanntásc a shoc
Chun réimse ceanntásc a shocrú nó a bhaint i do fhreagra, bain úsáid:attr: HttpResponse.headers:
```pycon
>>> response = HttpResponse()
>>> response.headers["Age"] = 120
>>> del response.headers["Age"]
```
Is féidir leat ceanntásca a ionramháil freisin trí do fhreagra a chóireáil mar fhoclóir:
```pycon
>>> response = HttpResponse()
>>> response["Age"] = 120
>>> del response["Age"]
```
Cuireann sé seo seachfhálaí chuig HttpResponse.Headers\`, agus is é an comhéadan bunaidh a thairgeann HttpResponse\`.
Nuair a bhíonn an comhéadan seo á úsáid agat, murab ionann agus foclóir, ní ardaíonn `del` Keyerror\` mura bhfuil an réimse ceannteideal ann.
Is féidir leat ceanntásca a shocrú freisin ar instantiation:
```pycon
>>> response = HttpResponse(headers={"Age": 120})
```
Chun na réimsí ceanntásc `Cache-Control` agus `Vary` a shocrú, moltar na modhanna: func: ~django.utils.cache.patch\_cache\_control agus:func: ~django.utils.cache.patch\_vary\_headers a úsáid ó:mod: django.utils.cache, ós rud é gur féidir luachanna iolracha, scartha le camóg a bheith ag na réimsí seo. Cinntíonn na modhanna “paiste” nach mbaintear luachanna eile, m.sh. a chuireann meán-earraí leis.
Ní féidir línte nua a bheith i réimsí ceanntásc HTTP. Ardóidh iarracht réimse ceanntásc ina bhfuil carachtar líne nua (CR nó LF) a shocrú `BadHeaderROR`
#### Ag rá leis an mbrabhsálaí an freagra a chaitheamh mar cheangaltán comhad
Chun a rá don bhrabhsálaí caitheamh leis an bhfreagra mar cheangaltán comhad, socraigh na ceannteidil `Content-Type` agus Content-Disposition\`. Mar shampla, seo mar a d'fhéadfá scarbhileog Microsoft Excel a thabhairt ar ais:
```pycon
>>> response = HttpResponse(
... my_data,
... headers={
... "Content-Type": "application/vnd.ms-excel",
... "Content-Disposition": 'attachment; filename="foo.xls"',
... },
... )
```
Níl aon rud Django-sonrach faoin gceannteideal Content-Disposition\`, ach is furasta dearmad a dhéanamh ar an gcomhréir, mar sin tá sé curtha san áireamh anseo.
### tréithe
#### `HttpResponse.content`
Bytestring a léiríonn an t-ábhar, ionchódaithe ó shreang más gá.
#### `HttpResponse.text`
> **New in Django 5.2**
A string representation of [`HttpResponse.content`](#django.http.HttpResponse.content), decoded using the
response's [`HttpResponse.charset`](#django.http.HttpResponse.charset) (defaulting to `UTF-8` if empty).
#### `HttpResponse.cookies`
A: py:obj: réad http.cookies.simplecookie a choinníonn na fianáin san áireamh sa fhreagra.
#### `HttpResponse.headers`
Rud cás-neamhíogair, cosúil le dict a sholáthraíonn comhéadan do gach ceannteideal HTTP ar an bhfreagra, seachas ceannteideal Set-Cookie. Féach: Ref: socruithe ceanncheadr-fields agus:attr: HttpResponse.cookies.
#### `HttpResponse.charset`
Sreang a léiríonn an tacar charta ina ndéanfar an freagra a ionchódú. Mura dtugtar é ag am institiúcháin `HttpResponse`, bainfear as content\_type\` é agus mura n-éireoidh leis sin, úsáidfear an socrú:setting: DEFAULT\_CHARSET.
#### `HttpResponse.status_code`
\<9110 #section -15\>An: RFC: Cód stádais HTTP don fhreagra.
Unless:attr: Socraítear réasúna\_phrase go sainráite, modhnófar luach `` `status_code `` lasmuigh den tógálaí luach `réas_phrase` a mhodhnú freisin.
#### `HttpResponse.reason_phrase`
An frása chúis HTTP don fhreagra. \<9110 #section -15.1\>Úsáideann sé na frásaí cúis réamhshocraithe: rfc: HTTP caighdeán' s.
Mura bhfuil sé socraithe go sainráite, socraítear `réas_phrase` ag luach: attr: status\_code.
#### `HttpResponse.streaming`
Tá sé seo i gcónaí `bréag`.
Tá an tréith seo ann ionas gur féidir le middleware freagraí sruthú a chaitheamh go difriúil ó fhreagairtí rialta
#### `HttpResponse.closed`
`Fíor` má tá an freagra dúnta.
### Modhanna
#### `HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None, headers=None)`
Cuireann sé réad `HttpResponse` leis an ábhar leathanaigh, an cineál ábhair agus na ceannteidil a thugtar.
Is minic gurb é `content` ná iterator, bytestring, :class: memoryview, nó teaghrán. Déanfar cineálacha eile a thiontú go bytestring tríd a n-ionadaíocht teaghrán a ionchódú. Ba chóir d'athraitheoirí teaghráin nó bytestrings a thabhairt ar ais agus déanfar iad sin a cheangal le chéile chun ábhar an fhreagra a fhoirmiú.
Is é `content_type` an cineál MIME a chomhlánann go roghnach ag ionchódú tacar carachtair agus úsáidtear é chun an ceannteideal HTTP `Content-Type` a líonadh. Mura sonraítear é, cruthaítear é le `'text/html'` agus socruithe: DEFAULT\_CHARSET agus socruithe: ```DEFAULT_CHARSET`, de réir réamhshocraithe: ``"text/html; charset = utf-8"```.
\<9110 #section -15\>Is é ```status ``an:rfc: `cód stádais HTTP` don fhreagra. Is féidir leat úsáid a bhaint as Python's:py:class: `http.httpStatus` le haghaidh ainmneacha bríocha, mar shampla ``HttpStatus.no_content```.
Is é `réas` an frása freagartha HTTP. Mura gcuirtear ar fáil, úsáidfear abairt réamhshocraithe.
Is é `charset` an charset ina ndéanfar an freagra a ionchódú. Mura dtugtar é bainfear as content\_type\`, agus mura n-éiríonn leis sin, úsáidfear an socrú: setting: DEFAULT\_CHARSET.
Is é `headers` a: aicme: dict ceannteidil HTTP don fhreagra.
#### `HttpResponse.__setitem__(header, value)`
Socraíonn an t-ainm ceanntásc tugtha don luach tugtha. Ba chóir go mbeadh `ceannteannair` agus luach\` araon teaghráin.
#### `HttpResponse.__delitem__(header)`
Scriosann sé an ceanntásc leis an ainm tugtha. Teipeann sé go ciúin mura bhfuil an ceanntásc ann. Cás-neamh-íogair.
#### `HttpResponse.__getitem__(header)`
Tugann sé an luach don ainm ceanntásc tugtha ar ais. Cás-neamh-íogair.
#### `HttpResponse.get(header, alternate=None)`
Tugann sé an luach don cheanntásc a thugtar, nó `malart` mura bhfuil an ceannteideal ann.
#### `HttpResponse.has_header(header)`
Tugann sé “True\`\` nó False\` bunaithe ar sheiceáil cás-neamh-íogair do cheanntásc leis an ainm tugtha.
#### `HttpResponse.items()`
Gníomhartha cosúil:meth: dict.items do cheanntásca HTTP ar an bhfreagra.
#### `HttpResponse.setdefault(header, value)`
Socraíonn sé ceanntásc mura bhfuil sé socraithe cheana féin.
#### `HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)`
Socraíonn fianán. Tá na paraiméadair mar an gcéanna le réad fianáin: class: ~http.cookies.morsel sa leabharlann caighdeánach Python.
- Ba chóir go mbeadh `max_age` a:class: ~datetime.timedelta réad, líon sláireach soicind, nó `None` (réamhshocraithe) más chóir go mairfeadh an fianán ach chomh fada agus seisiún brabhsálaí an chliaint. Mura sonraítear deigh', ríomhfar é.
- Ba chóir go mbeadh `expires` ina shreang sa fhormáid ```"Wdy, DD-mon-yy HH:MM:SS GMT"` nó réad ``datetime.datetime``` i UTC. Más réad `datetime` é `scaipe`, ríomhfar an `max_age`.
- Úsáid `domain` más mian leat fianán tras-fearainn a shocrú. Mar shampla, socraíonn `domain="example.com"` fianán atá inléite ag na fearainn www.example.com, blog.example.com, srl. Seachas sin, ní bheidh fianán inléite ach ag an bhfearann a shocraigh é.
- Úsáid `secure=true` mura dteastaíonn uait nach seolfar an fianán chuig an bhfreastalaí ach nuair a dhéantar iarratas leis an scéim `https`.
- Úsáid HttpOnly=True\` más mian leat JavaScript taobh an chliaint a chosc ó rochtain a bheith agat ar an bhfianán.
Is bratach é [HTTPOnly](https://owasp.org/www-community/HttpOnly) atá san áireamh i gceannteideal freagartha Set-Cookie HTTP. Tá sé mar chuid den \<6265 #section -4.1.2.6\> chaighdeán:rfc: RFC 6265 le haghaidh fianáin agus féadann sé a bheith ina bhealach úsáideach chun an baol go bhfaighidh script taobh an chliaint rochtain ar na sonraí cosanta fianán a mhaolú.
- Úsáid `sameSite='strict'` nó `sameSite='Lax'` chun a rá don bhrabhsálaí gan an fianán seo a sheoladh agus iarratas tras-bhunús á dhéanamh agat. Ní thacaíonn gach brabhsálaí le [SameSite](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value), mar sin ní athsholáthar é ar chosaint CSRF Django, ach beart cosanta domhain é.
Úsáid `sameSite='none'` (teaghrán) chun a rá go sainráite go seoltar an fianán seo le gach iarratas ar an láithreán céanna agus tras-láithreán.
> **Warning**
>
> [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-6.1) states 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=False, httponly=False, samesite=None)`
Like [`set_cookie()`](#django.http.HttpResponse.set_cookie), but
[cryptographic signing](/ga/5.2/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 to put the cookie into a
separate signature namespace, 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, samesite=None)`
Scriosann sé an fianán leis an eochair a thugtar. Teipeann sé go ciúin mura bhfuil an eochair ann.
Mar gheall ar an mbealach a oibríonn fianáin, ba chóir go mbeadh path\` agus `domain` na luachanna céanna a d'úsáid tú i `set_cookie ()` \- ar shlí eile ní fhéadfar an fianán a scriosadh.
#### `HttpResponse.close()`
Glaonn an freastalaí WSGI ar an modh seo go díreach ag deireadh an iarratais.
#### `HttpResponse.write(content)`
Déanann an modh seo réad cosúil le comhad mar shampla an:class: HttpResponse.
#### `HttpResponse.flush()`
Déanann an modh seo réad cosúil le comhad mar shampla an:class: HttpResponse.
#### `HttpResponse.tell()`
Déanann an modh seo réad cosúil le comhad mar shampla an:class: HttpResponse.
#### `HttpResponse.getvalue()`
Tugann luach: attr: HttpResponse.content ar ais. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.
#### `HttpResponse.readable()`
I gcónaí `Bréag`. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.
#### `HttpResponse.seekable()`
I gcónaí `Bréag`. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.
#### `HttpResponse.writable()`
“Fíor” i gcónaí. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.
#### `HttpResponse.writelines(lines)`
Scríobhann liosta línte don fhreagra. Ní chuirtear deighilteoirí líne leis. Déanann an modh seo réad cosúil le sruth mar shampla an:class: HttpResponse.
### Fo-aicmí HttpResponse\`
Cuimsíonn Django roinnt fo-aicmí HttpResponse a láimhseálann cineálacha éagsúla freagraí HTTP. Cosúil le HttpResponse\`, tá na fo-aicmí seo ina gcónaí in:mod: 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.
The constructor accepts an optional `preserve_request` keyword argument
that defaults to `False`, producing a response with a 302 status code. If
`preserve_request` is `True`, the status code will be 307 instead.
See [`HttpResponse`](#django.http.HttpResponse) for other optional constructor arguments.
#### `url`
Léiríonn an tréith léite amháin seo an URL a atreoróidh an freagra chuig (comhionann leis an gceannteideal freagartha Suíomh ).
> **Changed in Django 5.2**
>
> The `preserve_request` argument was added.
#### `class HttpResponsePermanentRedirect`
Like [`HttpResponseRedirect`](#django.http.HttpResponseRedirect), but it returns a permanent redirect
(HTTP status code 301) instead of a "found" redirect (status code 302).
When `preserve_request=True`, the response's status code is 308.
> **Changed in Django 5.2**
>
> The `preserve_request` argument was added.
#### `class HttpResponseNotModified`
Ní ghlacann an tógálaí aon argóintí agus níor cheart aon ábhar a chur leis an bhfreagra seo. Úsáid é seo chun a ainmniú nár modhnaíodh leathanach ó iarratas deireanach an úsáideora (cód stádais 304).
#### `class HttpResponseBadRequest`
Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 400.
#### `class HttpResponseNotFound`
Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 404.
#### `class HttpResponseForbidden`
Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 403.
#### `class HttpResponseNotAllowed`
Cosúil le: class: HttpResponse, ach úsáideann sé cód stádais 405. Teastaíonn an chéad argóint don tógálaí: liosta de na modhanna ceadaithe (m.sh. `['GET', 'POST']`).
#### `class HttpResponseGone`
Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 410.
#### `class HttpResponseServerError`
Gníomhaíonn sé díreach cosúil:class: HttpResponse ach úsáideann sé cód stádais 500.
> **Note**
>
> Má chuireann fo-aicme saincheaptha de:class: HttpResponse modh `render` i bhfeidhm, caithfidh Django é mar aithris a: a:class: ~django.template.response.simpletemplateResponse, agus caithfidh an modh `render` réad freagartha bailí a thabhairt ar ais féin.
#### Ranganna freagartha saincheaptha
Má bhíonn rang freagartha ag teastáil uait nach soláthraíonn Django, is féidir leat é a chruthú le cabhair ó:py:class: http.httpStatus. Mar shampla:
```
from http import HTTPStatus
from django.http import HttpResponse
class HttpResponseNoContent(HttpResponse):
status_code = HTTPStatus.NO_CONTENT
```
## `JSONResponse` rudaí
#### `class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)`
An:class: fo-aicme HttpResponse a chabhraíonn le freagra ionchódaithe JSON a chruthú. Oidhreacht aige an chuid is mó d'iompar óna sáraicme le lánúin difríochtaí:
Tá a cheanntásc réamhshocraithe `Content-Type` socraithe ag:mimetype: application/json.
Ba chóir go mbeadh an chéad pharaiméadar, ```sonraí ``, mar shampla ``dict```. Má tá an paraiméadar ```sábháilte ``socraithe go ``False``` (féach thíos) is féidir é a bheith ar aon réad inserializable JSON.
Úsáidfear an `encoder`, atá réamhshocraithe to:class: django.core.serializers.json.djangojsonEncoder, chun na sonraí a shraitheadh. Féach: Ref: JSON sraitheoireacht \\`le haghaidh tuilleadh sonraí faoin sraitheoir seo.
Tá an paraiméadar boolean ```sábháilte ``réamhshocraithe go ``True```. Má tá sé socraithe go `False`, is féidir aon rud a chur ar aghaidh le haghaidh sraitheadh (ar shlí eile ní cheadaítear ach cásanna `dict`). Má tá `sábháilte` `True` agus má chuirtear réad neamh-`dict` ar aghaidh mar an chéad argóint, ardófar a:exc: TypeError.
Is foclóir argóintí eochairfhocal é an paraiméadar `json_dumps_params` le dul chuig an nglao json.dumps () a úsáidtear chun an freagra a ghiniúint.
### Úsáid
D'fhéadfadh cuma a bheith ar úsáid tipiciúil:
```pycon
>>> from django.http import JsonResponse
>>> response = JsonResponse({"foo": "bar"})
>>> response.content
b'{"foo": "bar"}'
```
#### Rud neamh-fhoclóra a shraitheadh
D'fhonn rudaí seachas dict\` a shraitheadh ní mór duit an paraiméadar `sábháilte` a shocrú go `False`:
```pycon
>>> response = JsonResponse([1, 2, 3], safe=False)
```
Gan dul ar `safe=False`, ardófar a:exc: TypeError.
Tabhair faoi deara go bhfuil API bunaithe ar rudaí `dict` níos leathnaithe, níos solúbtha, agus go ndéanann sé níos éasca comhoiriúnacht ar aghaidh a choinneáil. Dá bhrí sin, ba cheart duit rudaí neamh-dict a sheachaint i bhfreagra ionchódaithe JSON.
> **Warning**
>
> Roimh an bhí sé indéanta an tógálaí JavaScript \< \> Array\` a nimhiú. Ar an gcúis seo, ní cheadaíonn Django rudaí neamh-dict a chur chuig an tógálaí: class: ~django.http.jsonResponse de réir réamhshocraithe. Mar sin féin, cuireann mórchuid na bhrabhsálaithe nua-aimseartha ECMAScript 5 i bhfeidhm a bhaineann leis an veicte Dá bhrí sin is féidir an réamhchúram slándála seo a dhíchumasú.
#### An t-ionchódóir JSON réamhshocraithe a
Más gá duit rang ionchódóra JSON difriúil a úsáid is féidir leat an paraiméadar encoder\` a chur ar aghaidh chuig an modh tógálaí:
```pycon
>>> response = JsonResponse(data, encoder=MyJSONEncoder)
```
## `Streaminghttpreresponse` rudaí
#### `class StreamingHttpResponse`
Úsáidtear an rang:class: StreamInghttPresponse chun freagra a shruthlú ó Django chuig an mbrabhsálaí.
> **Úsáid chun cinn**
>
> [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) is somewhat advanced, in that it is
> important to know whether you'll be serving your application synchronously
> under WSGI or asynchronously under ASGI, and adjust your usage
> appropriately.
>
> Léigh na nótaí seo go cúramach le do thoil.
Úsáid shamplach de:class: StreamInghttPresponse faoi WSGI is ea ábhar a shruthlú nuair a thógfadh an freagra rófhada nó úsáideadh an iomarca cuimhne. \Mar shampla, tá sé úsáideach le haghaidh: ref: comhaid mhóra CSV a ghiniúint .
Tá breithnithe feidhmíochta ann agus é seo á dhéanamh agat, áfach. Tá Django, faoi WSGI, deartha le haghaidh iarratais ghearrshaoil. Ceanglóidh freagraí sruthú próiseas oibrithe ar feadh tréimhse iomlán na freagartha. D'fhéadfadh droch-fheidhmíocht a bheith mar thoradh air seo
Go ginearálta, déanfá tascanna daor lasmuigh den timthriall iarrata-freagartha, seachas dul i ngleic le freagra sruthaithe.
Agus tú ag freastalú faoi ASGI, áfach, ní gá a: class: StreamInghttPrésponse stop a chur ar iarratais eile a sheirbheáil agus iad ag fanacht le I/O. Osclaíonn sé seo an fhéidearthacht iarratais fadré ar ábhar sruthú agus patrúin a chur i bhfeidhm mar vótaíocht fhada, agus imeachtaí a sheoltar ó fhreastalaí.
Fiú amháin faoi nóta ASGI, níor cheart: StreamInghttPresponse a úsáid ach amháin i gcásanna ina bhfuil sé riachtanach go hiomlán nach ndéantar an t-ábhar iomlán a athrú sula n-aistrítear na sonraí chuig an gcliant. Toisc nach féidir rochtain a fháil ar an ábhar, ní féidir le go leor middleware feidhmiú de ghnáth. Mar shampla ní féidir na ceannteidil `Etag` agus `Content-Length` a ghiniúint le haghaidh freagraí sruthú.
Ní fo-aicme de:class: HttpResponse é an:class: HttpResponse, toisc go bhfuil API beagán difriúil aige. Mar sin féin, tá sé beagnach comhionann, leis na difríochtaí suntasacha seo a leanas:
- Ba chóir athraitheoir a thabhairt dó a thugann bytestrings, :class: memoryview, nó teaghráin mar ábhar. Agus tú ag freastal faoi WSGI, ba chóir go mbeadh sé seo ina athraitheoir sioncronaithe. Agus tú ag freastal faoi ASGI, ba chóir go mbeadh sé ina athraitheoir async.
- Ní féidir leat rochtain a fháil ar a ábhar, ach amháin tríd an réad freagartha féin a athrá. Níor chóir go dtarlódh sé seo ach nuair a chuirtear an freagra ar ais chuig an gcliant: níor cheart duit an freagra a athrú duit féin.
Faoi WSGI déanfar an freagra a athdhéanamh go sioncrónach. Faoi ASGI déanfar an freagra a athrá go asincrónach. (Sin é an fáth go gcaithfidh an cineál iterator an prótacal atá á úsáid agat a mheaitseáil.)
Chun timpiste a sheachaint, déanfar cineál athraitheora mícheart a mhapáil leis an gcineál ceart le linn athraithe, agus ardófar rabhadh, ach chun é seo a dhéanamh caithfear an t-athraitheoir a ithe go hiomlán, rud a sháraíonn an cuspóir a: class: StreamInghttPresponse a úsáid ar chor ar bith.
- Níl aon tréith ábhar aige. Ina áit sin, tá a: attr: ~StreamInghttPresponse.streaming\_content tréith aige. Is féidir é seo a úsáid i lár earraí chun an freagra a fhilleadh in-athrá, ach níor cheart é a ithe.
- It has no `text` attribute, as it would require iterating the response
object.
- Ní féidir leat na modhanna réad cosúil le comhad ```tell () ``nó `scríobh ()``` a úsáid. Má dhéantar é sin, beidh eisceacht ann.
Tá an bunaicme: Class: HttpResponseBase coitianta idir: aicme: HttpResponse agus:class: StreamInghttPresponse.
### tréithe
#### `StreamingHttpResponse.streaming_content`
Athraitheoir ar an ábhar freagartha, ionchódaithe bytestring de réir: attr: HttpResponse.charSet.
#### `StreamingHttpResponse.status_code`
\<9110 #section -15\>An: RFC: Cód stádais HTTP don fhreagra.
Unless:attr: Socraítear réasúna\_phrase go sainráite, modhnófar luach `` `status_code `` lasmuigh den tógálaí luach `réas_phrase` a mhodhnú freisin.
#### `StreamingHttpResponse.reason_phrase`
An frása chúis HTTP don fhreagra. \<9110 #section -15.1\>Úsáideann sé na frásaí cúis réamhshocraithe: rfc: HTTP caighdeán' s.
Mura bhfuil sé socraithe go sainráite, socraítear `réas_phrase` ag luach: attr: status\_code.
#### `StreamingHttpResponse.streaming`
Tá sé seo i gcónaí Fíor\`.
#### `StreamingHttpResponse.is_async`
Boolean a léiríonn an bhfuil: attr: StreamInghttPresponse.streaming\_content is iterator asincrónach nó nach bhfuil.
Tá sé seo úsáideach do mheánearraí a theastaíonn uathu fillte:attr: StreamInghttPresponse.streaming\_content.
### Dícheangail láimhseáil
Má dhícheanglaíonn an cliant le linn freagra sruthú, cuirfidh Django an coroutine atá ag láimhseáil an freagra ar ceal. Más mian leat acmhainní a ghlanadh de láimh, is féidir leat é sin a dhéanamh tríd an Asyncio.CancelleDerror\` a ghabháil:
```
async def streaming_response():
try:
# Do some work here
async for chunk in my_streaming_iterator():
yield chunk
except asyncio.CancelledError:
# Handle disconnect
...
raise
async def my_streaming_view(request):
return StreamingHttpResponse(streaming_response())
```
Ní thaispeánann an sampla seo ach conas dícheangal cliant a láimhseáil agus an freagra ag sruthú. \Má dhéanann tú oibríochtaí fadtéarmacha i do thuairim sula bhfilleann tú an réad `StreaminghttPresponse` ar ais, ansin b'fhéidir gur mhaith leat freis:ref: dícheangail a láimhseáil sa radharc féin.
## Rudaí `FileResponse`
#### `class FileResponse(open_file, as_attachment=False, filename='', **kwargs)`
[`FileResponse`](#django.http.FileResponse) is a subclass of [`StreamingHttpResponse`](#django.http.StreamingHttpResponse)
optimized for binary files. It uses [**wsgi.file\_wrapper**](https://peps.python.org/pep-3333/#optional-platform-specific-file-handling) if provided by the wsgi
server, otherwise it streams the file out in small chunks.
Má tá `as_attachment=True`, socraítear an ceannteideal ```Content-Disposition` go ``attachment```, a iarrann ar an mbrabhsálaí an comhad a thairiscint don úsáideoir mar íoslódáil. Seachas sin, ní shocrófar ceanntásc ```Content-Disposition` le luach ``inline``` (réamhshocraithe an bhrabhsálaí) ach amháin má tá ainm comhaid ar fáil.
Mura bhfuil ainm ag `open_file` nó mura bhfuil ainm open\_file\` oiriúnach, tabhair ainm comhaid saincheaptha ag baint úsáide as an paraiméadar `file`. Tabhair faoi deara má chuireann tú réad cosúil le comhad cosúil le `IO.Bytesio`, is é do chúram ```search () ``é sula ndéantar é a chur chuig `FileResponse```.
Socraítear an ceannteideal `Content-Length` go huathoibríoch nuair is féidir é a thuairisciú ó ábhar `open_file`.
Socraítear an ceannteideal `Content-Type` go huathoibríoch nuair is féidir é a thuairisciú ón ```ainm comhad ``, nó ainm `open_file```.
Glacann `FileResponse` le haon rud cosúil le comhad le hábhar dénártha, mar shampla comhad oscailte i mód dénártha mar sin:
```pycon
>>> from django.http import FileResponse
>>> response = FileResponse(open("myfile.png", "rb"))
```
Dúnfar an comhad go huathoibríoch, mar sin ná oscail é le bainisteoir comhthéacs.
> **Úsáid faoi ASGI**
>
> Tá API comhad Python sioncrónach. Ciallaíonn sé seo go gcaithfear an comhad a ithe go hiomlán chun é a sheirbheáil faoi ASGI.
>
> \< \>D'fhonn comhad a shruthú go hincrónach ní mór duit pacáiste tríú páirtí a úsáid a sholáthraíonn API comhad asincrónach, mar shampla [aiofiles](#aiofiles).
### Modhanna
#### `FileResponse.set_headers(open_file)`
Glaofar an modh seo go huathoibríoch le linn an tionscnamh freagartha agus socraítear ceannteidil éagsúla (```Content-Fad ``, `Content-Type```, agus\`\` Content-Disposition ```) ag brath ar ``oscailte_comhad```.
## Aicme `HttpResponseBase`
#### `class HttpResponseBase`
Tá an rang:class: HttpResponseBase coitianta do gach freagra Django. Níor chóir é a úsáid chun freagraí a chruthú go díreach, ach d'fhéadfadh sé a bheith úsáideach chun cineál-sheiceáil.