```
#### `QueryDict.__getitem__(key)`
Returnerar det senaste värdet för den angivna nyckeln; eller en tom lista (`[]`) om nyckeln finns men inte har några värden. Utlöser `django.utils.datastructures.MultiValueDictKeyError` om nyckeln inte finns. (Detta är en subklass av Pythons standard [`KeyError`](https://docs.python.org/3/library/exceptions.html#KeyError), så du kan hålla dig till att fånga `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)`
Sätter den angivna nyckeln till `[value]` (en lista vars enda element är `value`). Observera att denna, liksom andra ordboksfunktioner som har bieffekter, endast kan anropas på en föränderlig `QueryDict` (t.ex. en som skapades via [`QueryDict.copy()`](#django.http.QueryDict.copy)).
#### `QueryDict.__contains__(key)`
Returnerar `True` om den angivna nyckeln är inställd. Detta låter dig göra, t.ex., `if "foo" in request.GET`.
#### `QueryDict.get(key, default=None)`
Använder samma logik som [`__getitem__()`](#django.http.QueryDict.__getitem__), med en hook för att returnera ett standardvärde om nyckeln inte finns.
#### `QueryDict.setdefault(key, default=None)`
Som [`dict.setdefault()`](https://docs.python.org/3/library/stdtypes.html#dict.setdefault), förutom att den använder [`__setitem__()`](#django.http.QueryDict.__setitem__) internt.
#### `QueryDict.update(other_dict)`
Tar antingen en `QueryDict` eller en ordbok. Som [`dict.update()`](https://docs.python.org/3/library/stdtypes.html#dict.update), förutom att den *tillägger* till de aktuella ordboksobjekten i stället för att ersätta dem. Till exempel:
```pycon
>>> q = QueryDict("a=1", mutable=True)
>>> q.update({"a": "2"})
>>> q.getlist("a")
['1', '2']
>>> q["a"] # returns the last
'2'
```
#### `QueryDict.items()`
Som [`dict.items()`](https://docs.python.org/3/library/stdtypes.html#dict.items), men använder samma logik för sista värde som [`__getitem__()`](#django.http.QueryDict.__getitem__) och returnerar ett iteratorobjekt i stället för ett vyobjekt. Till exempel:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.items())
[('a', '3')]
```
#### `QueryDict.values()`
Som [`dict.values()`](https://docs.python.org/3/library/stdtypes.html#dict.values), men använder samma logik för sista värde som [`__getitem__()`](#django.http.QueryDict.__getitem__) och returnerar en iterator i stället för ett vyobjekt. Till exempel:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.values())
['3']
```
Dessutom har `QueryDict` följande metoder:
#### `QueryDict.copy()`
Returnerar en kopia av objektet med hjälp av [`copy.deepcopy()`](https://docs.python.org/3/library/copy.html#copy.deepcopy). Denna kopia kommer att vara mutabel även om originalet inte var det.
#### `QueryDict.getlist(key, default=None)`
Returnerar en lista över data med den begärda nyckeln. Returnerar en tom lista om nyckeln inte finns och `default` är `None`. Det är garanterat att en lista returneras om inte det angivna standardvärdet inte är en lista.
#### `QueryDict.setlist(key, list_)`
Ställer in den angivna nyckeln till `list_` (till skillnad från ``__setitem__`()``).
#### `QueryDict.appendlist(key, item)`
Lägger till ett objekt i den interna lista som är kopplad till nyckeln.
#### `QueryDict.setlistdefault(key, default_list=None)`
Som [`setdefault()`](#django.http.QueryDict.setdefault), men den tar en lista med värden i stället för ett enda värde.
#### `QueryDict.lists()`
Som [`items()`](#django.http.QueryDict.items), men innehåller alla värden, i form av en lista, för varje medlem i ordlistan. Till exempel:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> q.lists()
[('a', ['1', '2', '3'])]
```
#### `QueryDict.pop(key)`
Returnerar en lista med värden för den angivna nyckeln och tar bort dem från ordlistan. Ger `KeyError` om nyckeln inte finns. Till exempel:
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.pop("a")
['1', '2', '3']
```
#### `QueryDict.popitem()`
Tar bort en godtycklig medlem i ordboken (eftersom det inte finns något begrepp för ordning) och returnerar en tupel med två värden som innehåller nyckeln och en lista över alla värden för nyckeln. Orsakar `KeyError` när den anropas på en tom ordbok. Till exempel:
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
```
#### `QueryDict.dict()`
Returnerar en `dict` representation av `QueryDict`. För varje (nyckel, lista) par i `QueryDict`, kommer `dict` att ha (nyckel, objekt), där objektet är ett element i listan, med samma logik som ``QueryDict.__getitem__`()``:
```pycon
>>> q = QueryDict("a=1&a=3&a=5")
>>> q.dict()
{'a': '5'}
```
#### `QueryDict.urlencode(safe=None)`
Returnerar en sträng med data i frågesträngformat. Till exempel:
```pycon
>>> q = QueryDict("a=2&b=3&b=5")
>>> q.urlencode()
'a=2&b=3&b=5'
```
Använd parametern `safe` för att skicka tecken som inte behöver kodas. Till exempel:
```pycon
>>> q = QueryDict(mutable=True)
>>> q["next"] = "/a&b/"
>>> q.urlencode(safe="/")
'next=/a%26b/'
```
## objekt för `HttpResponse`
#### `class HttpResponse`
I motsats till [`HttpRequest`](#django.http.HttpRequest)-objekt, som skapas automatiskt av Django, är [`HttpResponse`](#django.http.HttpResponse)-objekt ditt ansvar. Varje vy du skriver är ansvarig för att instansiera, fylla i och returnera en [`HttpResponse`](#django.http.HttpResponse).
Klassen [`HttpResponse`](#django.http.HttpResponse) finns i modulen [`django.http`](#module-django.http).
### Användning
#### Överföring av strängar
Typisk användning är att skicka innehållet på sidan, som en sträng, bytestring eller [`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview), till [`HttpResponse`](#django.http.HttpResponse)-konstruktören:
```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."))
```
Men om du vill lägga till innehåll stegvis kan du använda `response` som ett filliknande objekt:
```pycon
>>> response = HttpResponse()
>>> response.write("Here's the text of the web page.
")
>>> response.write("Here's another paragraph.
")
```
#### Överföra iteratorer
Slutligen kan du skicka `HttpResponse` en iterator i stället för strängar. `HttpResponse` kommer att konsumera iteratorn omedelbart, lagra dess innehåll som en sträng och kasta den. Objekt med en `close()`-metod, t.ex. filer och generatorer, stängs omedelbart.
Om du vill att svaret ska strömmas från iteratorn till klienten måste du använda klassen [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) istället.
#### Ställa in rubrikfält
Om du vill ange eller ta bort ett rubrikfält i svaret använder du [`HttpResponse.headers`](#django.http.HttpResponse.headers):
```pycon
>>> response = HttpResponse()
>>> response.headers["Age"] = 120
>>> del response.headers["Age"]
```
Du kan också manipulera rubriker genom att behandla ditt svar som en ordbok:
```pycon
>>> response = HttpResponse()
>>> response["Age"] = 120
>>> del response["Age"]
```
Detta proxy till `HttpResponse.headers`, och är det ursprungliga gränssnittet som erbjuds av `HttpResponse`.
När du använder detta gränssnitt, till skillnad från en ordbok, ger inte `del` upphov till `KeyError` om rubrikfältet inte finns.
Du kan också ställa in rubriker vid instansiering:
```pycon
>>> response = HttpResponse(headers={"Age": 120})
```
För att ställa in rubrikfälten `Cache-Control` och `Vary` rekommenderas det att använda metoderna [`patch_cache_control()`](/sv/5.2/ref/utils/#django.utils.cache.patch_cache_control) och [`patch_vary_headers()`](/sv/5.2/ref/utils/#django.utils.cache.patch_vary_headers) från [`django.utils.cache`](/sv/5.2/ref/utils/#module-django.utils.cache), eftersom dessa fält kan ha flera kommaseparerade värden. ”Patch”-metoderna säkerställer att andra värden, t.ex. som lagts till av ett mellanprogram, inte tas bort.
HTTP-headerfält kan inte innehålla nya rader. Ett försök att ställa in ett rubrikfält som innehåller ett tecken för nya rader (CR eller LF) kommer att ge upphov till `BadHeaderError`
#### Tala om för webbläsaren att behandla svaret som en bifogad fil
Om du vill att webbläsaren ska behandla svaret som en bifogad fil anger du rubrikerna `Content-Type` och `Content-Disposition`. Så här kan du t.ex. returnera ett Microsoft Excel-kalkylblad:
```pycon
>>> response = HttpResponse(
... my_data,
... headers={
... "Content-Type": "application/vnd.ms-excel",
... "Content-Disposition": 'attachment; filename="foo.xls"',
... },
... )
```
Det finns inget Django-specifikt med `Content-Disposition`-headern, men det är lätt att glömma syntaxen, så vi har inkluderat den här.
### Attribut
#### `HttpResponse.content`
En bytestring som representerar innehållet, kodad från en sträng om så behövs.
#### `HttpResponse.text`
> **New in Django 5.2**
En strängrepresentation av [`HttpResponse.content`](#django.http.HttpResponse.content), avkodad med hjälp av svarets [`HttpResponse.charset`](#django.http.HttpResponse.charset) (standard är `UTF-8` om den är tom).
#### `HttpResponse.cookies`
Ett [`http.cookies.SimpleCookie`](https://docs.python.org/3/library/http.cookies.html#http.cookies.SimpleCookie)-objekt som innehåller de cookies som ingår i svaret.
#### `HttpResponse.headers`
Ett diktliknande objekt som inte skiljer på skiftlägeskod och som ger ett gränssnitt till alla HTTP-rubriker i svaret, utom en `Set-Cookie`-rubrik. Se [Ställa in rubrikfält](#setting-header-fields) och [`HttpResponse.cookies`](#django.http.HttpResponse.cookies).
#### `HttpResponse.charset`
En sträng som anger den teckenuppsättning som svaret kommer att kodas med. Om den inte anges vid instantiering av `HttpResponse` kommer den att extraheras från `content_type` och om det inte lyckas kommer inställningen `` DEFAULT_CHARSET` `` att användas.
#### `HttpResponse.status_code`
Den [**HTTP-statuskod**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15) för svaret.
Om inte [`reason_phrase`](#django.http.HttpResponse.reason_phrase) uttryckligen har angetts, kommer en ändring av värdet för `status_code` utanför konstruktören också att ändra värdet för `reason_phrase`.
#### `HttpResponse.reason_phrase`
HTTP-anledningsfras för svaret. Den använder [**HTTP-standardens**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15.1) standardanledningsfraser.
Om det inte uttryckligen anges bestäms `reason_phrase` av värdet på [`status_code`](#django.http.HttpResponse.status_code).
#### `HttpResponse.streaming`
Detta är alltid `False`.
Detta attribut finns för att middleware ska kunna behandla strömmande svar på ett annat sätt än vanliga svar.
#### `HttpResponse.closed`
`True` om svaret har avslutats.
### Metoder
#### `HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None, headers=None)`
Instansierar ett `HttpResponse`-objekt med det angivna sidinnehållet, innehållstypen och sidhuvudena.
`content` är oftast en iterator, bytestring, [`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview), eller sträng. Andra typer konverteras till en bytestring genom att deras strängrepresentation kodas. Iteratorer bör returnera strängar eller bytestringar och dessa kommer att sammanfogas för att bilda innehållet i svaret.
`content_type` är MIME-typen som eventuellt kompletteras med en teckenuppsättningskodning och används för att fylla HTTP `Content-Type`-headern. Om den inte specificeras, bildas den av `'text/html'` och [`DEFAULT_CHARSET`](/sv/5.2/ref/settings/#std-setting-DEFAULT_CHARSET)-inställningarna, som standard: `"text/html; charset=utf-8"`.
`status` är [**HTTP statuskod**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15) för svaret. Du kan använda Pythons [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus) för meningsfulla alias, till exempel `HTTPStatus.NO_CONTENT`.
`reason` är HTTP-svarsfrasen. Om det inte anges kommer en standardfras att användas.
`charset` är den teckenuppsättning som svaret kommer att kodas med. Om det inte anges kommer det att extraheras från `content_type`, och om det inte lyckas kommer inställningen `` DEFAULT_CHARSET` `` att användas.
`headers` är en [`dict`](https://docs.python.org/3/library/stdtypes.html#dict) av HTTP-rubriker för svaret.
#### `HttpResponse.__setitem__(header, value)`
Sätter det angivna headernamnet till det angivna värdet. Både `header` och `value` bör vara strängar.
#### `HttpResponse.__delitem__(header)`
Raderar sidhuvudet med det angivna namnet. Misslyckas tyst om rubriken inte finns. Känslig för skiftlägesändringar.
#### `HttpResponse.__getitem__(header)`
Returnerar värdet för det angivna rubriknamnet. Saknar hänsyn till versaler.
#### `HttpResponse.get(header, alternate=None)`
Returnerar värdet för det angivna sidhuvudet, eller ett `alternativ` om sidhuvudet inte finns.
#### `HttpResponse.has_header(header)`
Returnerar `True` eller `False` baserat på en skiftlägesokänslig kontroll av en header med det angivna namnet.
#### `HttpResponse.items()`
Fungerar som [`dict.items()`](https://docs.python.org/3/library/stdtypes.html#dict.items) för HTTP-rubriker i svaret.
#### `HttpResponse.setdefault(header, value)`
Ställer in en header om den inte redan har ställts in.
#### `HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)`
Ställer in en cookie. Parametrarna är desamma som i [`Morsel`](https://docs.python.org/3/library/http.cookies.html#http.cookies.Morsel) cookie-objektet i Pythons standardbibliotek.
- `max_age` ska vara ett [`timedelta`](https://docs.python.org/3/library/datetime.html#datetime.timedelta)-objekt, ett heltal i sekunder eller `None` (standard) om cookien bara ska vara lika länge som klientens webbläsarsession. Om `expires` inte anges kommer den att beräknas.
- `expires` ska antingen vara en sträng i formatet `"Wdy, DD-Mon-YY HH:MM:SS GMT"` eller ett `datetime.datetime`-objekt i UTC. Om `expires` är ett `datetime`-objekt kommer `max_age` att beräknas.
- Använd `domain` om du vill ställa in en cookie för flera domäner. Till exempel: kommer `domain="example.com"` att ställa in en cookie som kan läsas av domänerna www.example.com, blog.example.com, etc. I annat fall kan en cookie endast läsas av den domän som satte den.
- Använd `secure=True` om du vill att cookien endast ska skickas till servern när en begäran görs med `https`-schema.
- Använd `httponly=True` om du vill förhindra att JavaScript på klientsidan får tillgång till cookien.
[HttpOnly](https://owasp.org/www-community/HttpOnly) är en flagga som ingår i en Set-Cookie HTTP-svarshuvud. Det är en del av [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-4.1.2.6)-standarden för cookies och kan vara ett användbart sätt att minska risken för att ett skript på klientsidan får tillgång till skyddade cookie-data.
- Använd `samesite='Strict'` eller `samesite='Lax'` för att tala om för webbläsaren att inte skicka denna cookie när du utför en cross-origin begäran. [SameSite](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value) stöds inte av alla webbläsare, så det är inte en ersättning för Djangos CSRF-skydd, utan snarare en åtgärd för djupförsvar.
Använd `samesite='None'` (sträng) för att uttryckligen ange att denna cookie skickas med alla förfrågningar på samma webbplats och mellan webbplatser.
> **Warning**
>
> [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-6.1) anger att användaragenter bör stödja cookies på minst 4096 byte. För många webbläsare är detta också den maximala storleken. Django kommer inte att göra ett undantag om det finns ett försök att lagra en cookie på mer än 4096 byte, men många webbläsare kommer inte att ställa in cookien korrekt.
#### `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](/sv/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)`
Raderar cookien med den angivna nyckeln. Misslyckas tyst om nyckeln inte finns.
På grund av hur cookies fungerar bör `path` och `domain` vara samma värden som du använde i `set_cookie()` \- annars kanske cookien inte raderas.
#### `HttpResponse.close()`
Denna metod anropas i slutet av begäran direkt av WSGI-servern.
#### `HttpResponse.write(content)`
Denna metod gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett filliknande objekt.
#### `HttpResponse.flush()`
Denna metod gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett filliknande objekt.
#### `HttpResponse.tell()`
Denna metod gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett filliknande objekt.
#### `HttpResponse.getvalue()`
Returnerar värdet av [`HttpResponse.content`](#django.http.HttpResponse.content). Den här metoden gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett strömliknande objekt.
#### `HttpResponse.readable()`
Alltid `False`. Denna metod gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett strömliknande objekt.
#### `HttpResponse.seekable()`
Alltid `False`. Denna metod gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett strömliknande objekt.
#### `HttpResponse.writable()`
Alltid `True`. Denna metod gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett strömliknande objekt.
#### `HttpResponse.writelines(lines)`
Skriver en lista med rader till svaret. Linjeseparatorer läggs inte till. Den här metoden gör en [`HttpResponse`](#django.http.HttpResponse)-instans till ett strömliknande objekt.
### underklasser till `HttpResponse`
Django innehåller ett antal underklasser av `HttpResponse` som hanterar olika typer av HTTP-svar. Precis som `HttpResponse` finns dessa underklasser i [`django.http`](#module-django.http).
#### `class HttpResponseRedirect`
Det första argumentet till konstruktören är obligatoriskt - sökvägen som ska omdirigeras till. Detta kan vara en fullständigt kvalificerad URL (t.ex. `'https://www.yahoo.com/search/'`), en absolut sökväg utan domän (t.ex. `'/search/'`) eller till och med en relativ sökväg (t.ex. `'search/'`). I det sista fallet kommer klientens webbläsare att rekonstruera den fullständiga URL:en själv enligt den aktuella sökvägen.
Konstruktören accepterar ett valfritt nyckelordsargument `preserve_request` som standard är `False`, vilket ger ett svar med en 302-statuskod. Om `preserve_request` är `True` blir statuskoden 307 istället.
Se [`HttpResponse`](#django.http.HttpResponse) för andra valfria konstruktörsargument.
#### `url`
Detta skrivskyddade attribut representerar den URL som svaret kommer att omdirigera till (motsvarande svarshuvudet `Location`).
> **Changed in Django 5.2**
>
> Argumentet `preserve_request` lades till.
#### `class HttpResponsePermanentRedirect`
Som [`HttpResponseRedirect`](#django.http.HttpResponseRedirect), men den returnerar en permanent omdirigering (HTTP-statuskod 301) i stället för en ”hittad” omdirigering (statuskod 302). När `preserve_request=True` är statuskoden för svaret 308.
> **Changed in Django 5.2**
>
> Argumentet `preserve_request` lades till.
#### `class HttpResponseNotModified`
Konstruktören tar inte emot några argument och inget innehåll ska läggas till i detta svar. Använd detta för att ange att en sida inte har ändrats sedan användarens senaste begäran (statuskod 304).
#### `class HttpResponseBadRequest`
Fungerar precis som [`HttpResponse`](#django.http.HttpResponse) men använder en 400-statuskod.
#### `class HttpResponseNotFound`
Fungerar precis som [`HttpResponse`](#django.http.HttpResponse) men använder en 404-statuskod.
#### `class HttpResponseForbidden`
Fungerar precis som [`HttpResponse`](#django.http.HttpResponse) men använder en 403-statuskod.
#### `class HttpResponseNotAllowed`
Som [`HttpResponse`](#django.http.HttpResponse), men använder en 405-statuskod. Det första argumentet till konstruktören är obligatoriskt: en lista över tillåtna metoder (t.ex. `['GET', 'POST']`).
#### `class HttpResponseGone`
Fungerar precis som [`HttpResponse`](#django.http.HttpResponse) men använder en 410-statuskod.
#### `class HttpResponseServerError`
Fungerar precis som [`HttpResponse`](#django.http.HttpResponse) men använder en 500-statuskod.
> **Note**
>
> Om en anpassad underklass av [`HttpResponse`](#django.http.HttpResponse) implementerar en `render`-metod, kommer Django att behandla den som en emulering av en [`SimpleTemplateResponse`](/sv/5.2/ref/template-response/#django.template.response.SimpleTemplateResponse), och `render`-metoden måste själv returnera ett giltigt svarsobjekt.
#### Anpassade svarsklasser
Om du behöver en svarsklass som Django inte tillhandahåller kan du skapa den med hjälp av [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus). Till exempel:
```
from http import HTTPStatus
from django.http import HttpResponse
class HttpResponseNoContent(HttpResponse):
status_code = HTTPStatus.NO_CONTENT
```
## objekt för `JsonResponse`
#### `class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)`
En [`HttpResponse`](#django.http.HttpResponse)-underklass som hjälper till att skapa ett JSON-kodat svar. Den ärver de flesta beteenden från sin superklass med ett par skillnader:
Dess standardrubrik `Content-Type` är inställd på `application/json`.
Den första parametern, `data`, bör vara en `dict`-instans. Om parametern `afe` är satt till `False` (se nedan) kan det vara vilket JSON-serialiserbart objekt som helst.
`encoder`, som som standard är [`django.core.serializers.json.DjangoJSONEncoder`](/sv/5.2/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder), kommer att användas för att serialisera data. Se [JSON serialization](/sv/5.2/topics/serialization/#serialization-formats-json) för mer information om denna serialiserare.
Den booleska parametern `safe` är som standard inställd på `True`. Om den är inställd på `False` kan vilket objekt som helst skickas för serialisering (annars är endast `dict`-instanser tillåtna). Om `afe` är `True` och ett objekt som inte är `dict` skickas som första argument, kommer ett `` TypeError` `` att uppstå.
Parametern `json_dumps_params` är en ordlista med nyckelordsargument som ska skickas till anropet `json.dumps()` som används för att generera svaret.
### Användning
Typisk användning kan se ut som:
```pycon
>>> from django.http import JsonResponse
>>> response = JsonResponse({"foo": "bar"})
>>> response.content
b'{"foo": "bar"}'
```
#### Serialisering av objekt som inte är ordböcker
För att kunna serialisera andra objekt än `dict` måste du ställa in parametern `afe` till `False`:
```pycon
>>> response = JsonResponse([1, 2, 3], safe=False)
```
Utan att ange `safe=False` kommer ett [`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) att uppstå.
Observera att ett API som baseras på `dict`-objekt är mer utbyggbart, flexibelt och gör det lättare att upprätthålla framåtkompatibilitet. Därför bör du undvika att använda icke-dict-objekt i JSON-kodade svar.
> **Warning**
>
> Före den [5:e upplagan av ECMAScript](https://262.ecma-international.org/5.1/#sec-11.1.4) var det möjligt att förgifta JavaScript `Array`-konstruktören. Av denna anledning tillåter Django inte att skicka icke-dict-objekt till [`JsonResponse`](#django.http.JsonResponse)-konstruktören som standard. De flesta moderna webbläsare implementerar dock ECMAScript 5 som tar bort denna attackvektor. Därför är det möjligt att inaktivera denna säkerhetsåtgärd.
#### Ändra standard JSON-kodare
Om du behöver använda en annan JSON-kodningsklass kan du skicka parametern `encoder` till konstruktörsmetoden:
```pycon
>>> response = JsonResponse(data, encoder=MyJSONEncoder)
```
## `StreamingHttpResponse`-objekt
#### `class StreamingHttpResponse`
Klassen [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) används för att strömma ett svar från Django till webbläsaren.
> **Avancerad användning**
>
> [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) är något avancerad, eftersom det är viktigt att veta om du kommer att servera din applikation synkront under WSGI eller asynkront under ASGI, och anpassa din användning på lämpligt sätt.
>
> Läs dessa anvisningar med försiktighet.
Ett exempel på användning av [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) under WSGI är att strömma innehåll när generering av svaret skulle ta för lång tid eller använda för mycket minne. Det är till exempel användbart för [generering av stora CSV-filer](/sv/5.2/howto/outputting-csv/#streaming-csv-files).
Det finns dock prestandaöverväganden när du gör detta. Django, under WSGI, är utformad för kortlivade förfrågningar. Strömmande svar kommer att binda en arbetsprocess under hela svarets varaktighet. Detta kan resultera i dålig prestanda.
Generellt sett skulle du utföra dyra uppgifter utanför begäran-svar-cykeln, snarare än att tillgripa ett strömmat svar.
Vid servering under ASGI behöver dock en [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) inte stoppa andra förfrågningar från att serveras medan de väntar på I/O. Detta öppnar upp för möjligheten till långlivade förfrågningar för strömmande innehåll och implementering av mönster som lång polling och server-sända händelser.
Även enligt ASGI note bör [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) endast användas i situationer där det är absolut nödvändigt att hela innehållet inte itereras innan data överförs till klienten. Eftersom innehållet inte kan nås kan många mellanprogram inte fungera normalt. Till exempel: kan inte rubrikerna `ETag` och `Content-Length` genereras för strömmande svar.
Klassen [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) är inte en underklass till [`HttpResponse`](#django.http.HttpResponse), eftersom den har ett något annorlunda API. Den är dock nästan identisk, med följande anmärkningsvärda skillnader:
- Den bör ges en iterator som ger bytestrings, [`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview), eller strängar som innehåll. Vid servering under WSGI bör detta vara en sync-iterator. När det används under ASGI bör det vara en async-iterator.
- Du kan inte komma åt dess innehåll, förutom genom att iterera själva svarsobjektet. Detta bör endast ske när svaret returneras till klienten: du bör inte iterera svaret själv.
Under WSGI kommer svaret att itereras synkront. Under ASGI kommer svaret att itereras asynkront. (Det är därför iterator-typen måste matcha det protokoll du använder)
För att undvika en krasch kommer en felaktig iteratortyp att mappas till rätt typ under iterationen och en varning kommer att utfärdas, men för att göra detta måste iteratorn konsumeras helt och hållet, vilket motverkar syftet med att använda en [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) överhuvudtaget.
- Den har inget `content`-attribut. Istället har den ett [`streaming_content`](#django.http.StreamingHttpResponse.streaming_content)-attribut. Detta kan användas i middleware för att omsluta svarets iterabel, men bör inte konsumeras.
- Det har inget `text`-attribut, eftersom det skulle kräva iterering av svarsobjektet.
- Du kan inte använda de filliknande objekten `tell()` eller `write()` metoderna. Om du gör det kommer ett undantag att uppstå.
Basklassen [`HttpResponseBase`](#django.http.HttpResponseBase) är gemensam för [`HttpResponse`](#django.http.HttpResponse) och [`StreamingHttpResponse`](#django.http.StreamingHttpResponse).
### Attribut
#### `StreamingHttpResponse.streaming_content`
En iterator av svarsinnehållet, bytestringskodat enligt [`HttpResponse.charset`](#django.http.HttpResponse.charset).
#### `StreamingHttpResponse.status_code`
Den [**HTTP-statuskod**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15) för svaret.
Om inte [`reason_phrase`](#django.http.StreamingHttpResponse.reason_phrase) uttryckligen har angetts, kommer en ändring av värdet för `status_code` utanför konstruktören också att ändra värdet för `reason_phrase`.
#### `StreamingHttpResponse.reason_phrase`
HTTP-anledningsfras för svaret. Den använder [**HTTP-standardens**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15.1) standardanledningsfraser.
Om det inte uttryckligen anges bestäms `reason_phrase` av värdet på [`status_code`](#django.http.StreamingHttpResponse.status_code).
#### `StreamingHttpResponse.streaming`
Detta är alltid `True`.
#### `StreamingHttpResponse.is_async`
Boolean som anger om [`StreamingHttpResponse.streaming_content`](#django.http.StreamingHttpResponse.streaming_content) är en asynkron iterator eller inte.
Detta är användbart för mellanprogram som behöver omsluta [`StreamingHttpResponse.streaming_content`](#django.http.StreamingHttpResponse.streaming_content).
### Hantering av frånkopplingar
Om klienten kopplar bort sig under ett strömmande svar kommer Django att avbryta den coroutine som hanterar svaret. Om du vill städa upp resurser manuellt kan du göra det genom att fånga `asyncio.CancelledError`:
```
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())
```
Detta exempel visar bara hur man hanterar frånkoppling av klienten medan svaret strömmas. Om du utför långvariga operationer i din vy innan du returnerar objektet `StreamingHttpResponse` kanske du också vill [hantera frånkopplingar i vyn](/sv/5.2/topics/async/#async-handling-disconnect) själv.
## `FileResponse`-objekt
#### `class FileResponse(open_file, as_attachment=False, filename='', **kwargs)`
[`FileResponse`](#django.http.FileResponse) är en underklass till [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) som är optimerad för binära filer. Den använder [**wsgi.file\_wrapper**](https://peps.python.org/pep-3333/#optional-platform-specific-file-handling) om den tillhandahålls av wsgi-servern, annars strömmar den ut filen i små bitar.
Om `as_attachment=True`, sätts `Content-Disposition` rubriken till `attachment`, vilket ber webbläsaren att erbjuda filen till användaren som en nedladdning. I annat fall kommer ett `Content-Disposition`-huvud med värdet `inline` (webbläsarens standard) att anges endast om ett filnamn finns tillgängligt.
Om `open_file` inte har något namn eller om namnet på `open_file` inte är lämpligt, ange ett eget filnamn med hjälp av parametern `filename`. Observera att om du skickar ett filliknande objekt som `io.BytesIO`, är det din uppgift att `seek()` det innan du skickar det till `FileResponse`.
Rubriken `Content-Length` sätts automatiskt när den kan gissas från innehållet i `open_file`.
Rubriken `Content-Type` ställs in automatiskt när den kan gissas från `filnamnet` eller namnet på `open_file`.
`FileResponse` accepterar alla filliknande objekt med binärt innehåll, till exempel en fil som öppnas i binärt läge så här:
```pycon
>>> from django.http import FileResponse
>>> response = FileResponse(open("myfile.png", "rb"))
```
Filen kommer att stängas automatiskt, så öppna den inte med en kontexthanterare.
> **Användning under ASGI**
>
> Pythons fil-API är synkront. Detta innebär att filen måste vara helt förbrukad för att kunna serveras under ASGI.
>
> För att strömma en fil asynkront måste du använda ett tredjepartspaket som tillhandahåller ett API för asynkrona filer, t.ex. [aiofiles](https://github.com/Tinche/aiofiles).
### Metoder
#### `FileResponse.set_headers(open_file)`
Denna metod anropas automatiskt under initieringen av svaret och ställer in olika rubriker (`Content-Length`, `Content-Type` och `Content-Disposition`) beroende på `open_file`.
## klassen HttpResponseBase
#### `class HttpResponseBase`
Klassen [`HttpResponseBase`](#django.http.HttpResponseBase) är gemensam för alla Django-svar. Den bör inte användas för att skapa svar direkt, men den kan vara användbar för typkontroll.