---
title: "Comhaid Uaslódála agus Láimhseálaithe"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/files/uploads/
canonical: https://djangodocs.dev/ga/6.1/ref/files/uploads/
---
# Comhaid Uaslódála agus Láimhseálaithe

## comhaid uaslódáil

#### `class UploadedFile`

\<django.http.HttpRequest.FILES\>Le linn uaslódála comhaid, stóráiltear na sonraí comhaid iarbhír in:attr: request.files \`. Is réad \`\`Uploadedfile\` (nó fo-aicme) é gach iontráil sa fhoclóir seo - fillteán timpeall comhad uaslódáilte. De ghnáth úsáidfidh tú ceann de na modhanna seo chun rochtain a fháil ar an ábhar uaslódáil

#### `UploadedFile.read()`

Léigh na sonraí uaslódáilte iomlána ón gcomhad. Bí cúramach leis an modh seo: má tá an comhad uaslódáilte ollmhór féadfaidh sé do chóras a shárú má dhéanann tú iarracht é a léamh isteach i gcuimhne. Is dócha go mbeidh tú ag iarraidh chunks () a úsáid ina ionad; féach thíos.

#### `UploadedFile.multiple_chunks(chunk_size=None)`

Tugann sé ar ais `True` má tá an comhad uaslódáilte mór go leor chun go mbeidh léamh ag teastáil i gcodanna iolracha. De réir réamhshocraithe beidh sé seo aon chomhad níos mó ná 2.5 meigabyte, ach tá sé sin inchumraithe; féach thíos.

#### `UploadedFile.chunks(chunk_size=None)`

Gineadóir ag filleadh codanna den chomhad. Más é ```` `multiple_chunks () ```True ````, ba chóir duit an modh seo a úsáid i lúb in ionad `read ()`.

Go praiticiúil, is minic a bhíonn sé níos éasca ``` `chunks () ``a úsáid an t-am ar fad. Cinntíonn lupáil thar ``chunks () ``in ionad ``read () ``` a úsáid nach gcuireann comhaid mhóra cuimhne do chórais a shárú.

Seo roinnt tréithe úsáideacha de `uploadedfile`:

#### `UploadedFile.name`

Ainm an chomhaid uaslódáilte (m.sh. `my_file.txt`).

#### `UploadedFile.size`

Méid, i mbeátaí, an chomhaid uaslódáilte.

#### `UploadedFile.content_type`

An ceannteideal cineál ábhair a uaslódáil leis an gcomhad (m.sh.: mimetype: text/plain nó: mimetype: application/pdf). Cosúil le haon sonraí a sholáthraíonn an t-úsáideoir, níor chóir duit muinín a bheith agat gurb é an comhad uaslódáilte an cineál seo Beidh ort fós a bhailíochtú go bhfuil an t-ábhar a éilíonn an ceannteideal de chineál ábhair sa chomhad - “muinín a bheith agat ach fíoraigh.”

#### `UploadedFile.content_type_extra`

Foclóir ina bhfuil paraiméadair bhreise curtha ar aghaidh chuig an gceannteideal cineál-ábhair . Is gnách go soláthraíonn seirbhísí seo, mar shampla Google App Engine, a chuireann uaslódálacha comhad a thar do cheann a idirghabháil agus a láimhseáil. \<2388 #section -5.3\>Mar thoradh air sin b'fhéidir nach bhfaighidh do láimhseálaí an t-ábhar comhad uaslódáilte, ach ina ionad sin URL nó pointeoir eile chuig an gcomhad (féach: rfc: RFC 2388).

#### `UploadedFile.charset`

Maidir le: mimetype: téacs/\* cineálacha ábhair, an tacar carachtair (ie `utf8`) a sholáthraíonn an brabhsálaí. Arís, is é “muinín ach fíorú” an beartas is fearr anseo.

> **Note**
>
> Cosúil le comhaid rialta Python, is féidir leat an comhad a léamh líne ar líne trí athrú thar an gcomhad uaslódáilte:
>
> ```
> for line in uploadedfile:
>     do_something_with(line)
> ```
>
> Lines are split using [universal newlines](https://docs.python.org/3/glossary.html#term-universal-newlines). The following are
> recognized as ending a line: the Unix end-of-line convention `'\n'`, the
> Windows convention `'\r\n'`, and the old Macintosh convention `'\r'`.

I measc na bhfo-aicmí de Uploadedfile\` tá:

#### `class TemporaryUploadedFile`

Comhad a uaslódáil chuig suíomh sealadach (ie sruth-go-diosca). Úsáideann an rang seo ag an: class: ~django.core.files.uploadHandler.TemporaryFileUploadHandler. Chomh maith leis na modhanna ó:class: uploadedFile, tá modh breise amháin aige:

#### `TemporaryUploadedFile.temporary_file_path()`

Tugann sé an cosán iomlán ar ais chuig an gcomhad uaslódáilte

#### `class InMemoryUploadedFile`

Comhad a uaslódáiltear i gcuimhne (ie sruth-chuimhne). Úsáideann an rang seo ag an: class: ~django.core.files.uploadHandler.MemoryFileUploadHandler.

## Láimhseálaithe uaslódála

Le chéile soláthraíonn an:class: MemoryFileUploadHandler agus:class: TemporaryFileUploadHandler iompar uaslódála comhaid réamhshocraithe Django maidir le comhaid bheaga a léamh isteach i gcuimhne agus cinn mhóra ar an diosca. Tá siad suite i `django.core.files.uploadhandler`.

#### `class MemoryFileUploadHandler`

Láimhseálaí uaslódála comhad chun uaslódálacha a shruthú isteach i gcuimhne (úsáidtear le haghaidh comh

#### `class TemporaryFileUploadHandler`

Uaslódáil láimhseálaí a sruthaíonn sonraí isteach i gcomhad sealadach ag baint úsáid:class: ~django.core.files.uploadedfile.temporaryUploadedFile.

## Láimhseálaithe uaslódáil saincheaptha

#### `class FileUploadHandler`

Ba chóir go mbeadh fo-aicmí de `Django.Core.Files.uploadHandler.FileUploadHandler` i ngach láimhseálaí uaslódála comhad. Féadfaidh tú láimhseálaithe uaslódála a shainiú cibé áit

### Modhanna riachtanacha

Ní mór do láimhseálaithe uaslódála comhad saincheaptaí\*\* na modhanna seo a leanas a

#### `FileUploadHandler.receive_data_chunk(raw_data, start)`

Faigheann sé “píosa” sonraí ón uaslódáil comhad.

Is bytestring é `raw_data` ina bhfuil na sonraí uaslódáilte.

Is é `start` an suíomh sa chomhad ina dtosaíonn an chuid `raw_data` seo.

Cuirfear na sonraí a chuireann tú ar ais isteach sna modhanna receive\_data\_chunk láimhseálaithe uaslódála ina dhiaidh sin. Ar an mbealach seo, is féidir le láimhseálaí amháin a bheith ina “scagaire” do láimhseálaithe eile.

Fill `None` ó receive\_data\_chunk\` chuig láimhseálaithe uaslódála gearrchiorcad atá fágtha ó an píosa seo a fháil. Tá sé seo úsáideach má tá na sonraí uaslódáilte á stóráil agat féin agus mura dteastaíonn uait go ndéanfaidh láimhseálaithe sa todhchaí cóip de na sonraí a

Má ardaíonn tú eisceacht `StopUpload` nó Skipfile\`, cuirfear deireadh leis an uaslódáil nó scipeánfar an comhad go hiomlán.

#### `FileUploadHandler.file_complete(file_size)`

Glaoigh nuair a bheidh comhad críochnaithe ag uaslódáil.

Ba chóir don láimhseálaí réad `uploadedFile` a chur ar ais a stóráilfear in `Request.Files`. Féadfaidh láimhseálaithe ```None ``a thabhairt ar ais freisin chun a léiriú gur chóir go dtiocfadh an réad ``Uploadedfile``` ó láimhseálaithe uaslódála ina dhiaidh sin.

### Modhanna roghnacha

Féadfaidh láimhseálaithe uaslódála saincheaptha aon cheann de na modhanna nó tréithe roghnacha seo a leanas

#### `FileUploadHandler.chunk_size`

Méid, i mbeátaí, de na “píosaí” ba chóir do Django a stóráil i gcuimhne agus a bheathú isteach sa láimhseálaí. Is é sin, rialaíonn an tréith seo méid na gcodanna a chuirtear isteach i `FileUploadHandler.Receive_Data_Chunk`.

Le haghaidh an fheidhmíochta is mó ba chóir go mbeadh méideanna na píosa inroinnte le `4` agus níor cheart go mbeadh méid níos mó ná 2 GB (2:sup: 31 bytes). Nuair a bhíonn ilmhéideanna píosa ar fáil ag láimhseálaithe iolracha, úsáidfidh Django an méid píosa is lú a shainmhíníonn aon láimhseálaí.

Is é an réamhshocrú 64\* 2:sup: 10 bytes, nó 64 KB.

#### `FileUploadHandler.new_file(field_name, file_name, content_type, content_length, charset, content_type_extra)`

Aisghlaonna ag comharthaíocht go bhfuil uaslódáil comhaid nua ag tosú. Tugtar air seo sula gcuirtear aon sonraí a bheathú d'aon láimhseálaithe uaslódála.

\<input\>Is ainm teaghrán é `field_name` réimse an chomhaid .

Is é `file_name` an t-ainm comhaid a sholáthraíonn an brabhsálaí.

Is é `content_type` an cineál MIME a sholáthraíonn an brabhsálaí -- m.sh. ``` ``íomha/jpeg' ```.

Is é content\_length fad na híomhá a thugann an brabhsálaí. Uaireanta ní chuirfear é seo ar fáil agus beidh sé “None”.

Is é `charset` an tacar carachtair (ie `utf8`) a thugann an brabhsálaí. Cosúil le content\_length \`, ní chuirfear é seo ar fáil uaireanta.

Is faisnéis bhreise é `content_type_extra` faoin gcomhad ón gceannteideal `content-type`. \<django.core.files.uploadedfile.UploadedFile.content\_type\_extra\>Féach: attr: Uploadedfile.content\_type\_extra .

Féadfaidh an modh seo eisceacht StopFutureHandlers a ardú chun cosc a chur ar láimhseálaithe sa todhchaí an comhad seo a láimhseáil.

#### `FileUploadHandler.upload_complete()`

Comharthaíonn glaoch ar ais go bhfuil an t-uaslódáil iomlán (gach comhad) críochnaithe.

#### `FileUploadHandler.upload_interrupted()`

Aisghlaonna a chomharthaíonn gur cuireadh isteach ar an uaslódáil, m.sh. nuair a dhún an t-úsáideoir a bhrabhsálaí

#### `FileUploadHandler.handle_raw_input(input_data, META, content_length, boundary, encoding)`

Ligeann sé don láimhseálaí parsáil an ionchuir amh HTTP a shárú go hiomlán.

Is réad cosúil le comhad é `input_data` a thacaíonn le ``` read () `` ```-ing.

Is é `META` an réad céanna le `request.meta`.

Is é ```content_length ``fad na sonraí in ``input_data```. Ná léigh níos mó ná baite ```content_length ``ó ``input_data```.

Is é `teorainne` an teorainn MIME don iarratas seo.

Is é “ionchódú” ionchódú an iarratais.

Tabhair ar ais `None` más mian leat leanúint ar aghaidh le láimhseáil uaslódála, nó tuple `(POST, FILES)` más mian leat na struchtúir sonraí nua atá oiriúnach don iarraidh a thabhairt ar ais go díreach.