---
title: "Uaslódálacha Comhad"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/topics/http/file-uploads/
canonical: https://djangodocs.dev/ga/6.1/topics/http/file-uploads/
---
# Uaslódálacha Comhad

Nuair a láimhseálann Django uaslódáil comhad, críochnaíonn sonraí \</ref/request-response\> \<django.http.HttpRequest.FILES\>na gcomhad cuirtear in:attr: request.files (le haghaidh tuilleadh eolais ar an réad iarraidh féach an doiciméadú le haghaidh: doc: earraí iarratais agus freagartha'). Míníonn an doiciméad seo conas a stóráiltear comhaid ar dhiosca agus i gcuimhne, agus conas an t-iompar réamhshocraithe a shain

> **Warning**
>
> Tá rioscaí slándála ann má tá tú ag glacadh le hábhar uaslódáilte ó úsáideoirí neam Féach ábhar an treoir slándála ar:ref: user-uploaded-content-security le haghaidh sonraí maolaithe.

## Uaslódálacha comhaid bunúsacha

Smaoinigh ar fhoirm ina bhfuil a:class: ~django.forms.filefield:

*`foirme.py`*

```python
from django import forms

class UploadFileForm(forms.Form):
    title = forms.CharField(max_length=50)
    file = forms.FileField()
```

Gheobhaidh amharc ag láimhseáil an fhoirm seo na sonraí comhad in:attr: Request.File\`\<django.http.HttpRequest.FILES\>, ar foclóir é ina bhfuil eochair do gach ceach:class: \`~django.forms.filefield (nó:class: ~django.forms.imagefield nó eile:class: ~django.forms.filefield) sa fhoirm. Mar sin bheadh na sonraí ón bhfoirm thuas inrochtana mar request.files \['file'\] .

\<form\>Tabhair faoi deara nach m \<django.http.HttpRequest.FILES\>beidh sonraí: attr: Request.files \`ach mura raibh an modh iarratais \`\`POST \`, cuireadh réimse comhad amháin ar a laghad a phostáil i ndáiríre, agus tá an tréith `enctype="multipart/form-data"` ag an\`\` ```a chuir an iarraidh. Seachas sin, beidh ``request.files``` folamh.

An chuid is mó den am, cuirfidh tú na sonraí comhad ó `request` isteach sa fhoirm mar a thuairiscítear in:ref: binding-uploaded-files. Bheadh cuma rud éigin air seo:

*`views.py`*

```python
from django.http import HttpResponseRedirect
from django.shortcuts import render
from .forms import UploadFileForm

# Imaginary function to handle an uploaded file.
from somewhere import handle_uploaded_file

def upload_file(request):
    if request.method == "POST":
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            handle_uploaded_file(request.FILES["file"])
            return HttpResponseRedirect("/success/url/")
    else:
        form = UploadFileForm()
    return render(request, "upload.html", {"form": form})
```

Tabhair faoi deara go gcaithfimid: attr: Request.files \<django.http.HttpRequest.FILES\>\`a chur isteach i dtógálaí na foirme; seo mar a chuirtear sonraí comhad ceangailte i bhfoirm.

Seo bealach coitianta a d'fhéadfá comhad uaslódáilte a láimhseáil:

```
def handle_uploaded_file(f):
    with open("some/file/name.txt", "wb+") as destination:
        for chunk in f.chunks():
            destination.write(chunk)
```

Cinntíonn lupáil thar ```uploadedfile.chunks () ``in ionad ``read ()``` a úsáid nach gcuireann comhaid mhóra cuimhne do chórais a shárú.

Tá cúpla modh agus tréithe eile ar fáil ar rudaí `uploadedfile`; féach:class: UploadedFile le haghaidh tagartha iomlán.

### Comhaid uaslódáilte a láimhseáil

Má tá comhad á shábháil agat ar a:class: ~django.db.models.model le a:class: ~django.db.models.filefield, déanann an próiseas seo i bhfad níos éasca ag baint úsáide as a:class: ~django.forms.ModelForm. Sábhálfar réad an chomhaid chuig an suíomh a shonraítear leis an:attr: ~django.db.models.filefield.upload\_to argóint an chomhfhreagraí:class: ~django.db.models.filefield nuair a ghlaoch form.save () :

```
from django.http import HttpResponseRedirect
from django.shortcuts import render
from .forms import ModelFormWithFileField

def upload_file(request):
    if request.method == "POST":
        form = ModelFormWithFileField(request.POST, request.FILES)
        if form.is_valid():
            # file is saved
            form.save()
            return HttpResponseRedirect("/success/url/")
    else:
        form = ModelFormWithFileField()
    return render(request, "upload.html", {"form": form})
```

Má tá réad á thógáil agat de láimh, is féidir leat an réad comhaid a shannadh ó:attr: request.files \<django.http.HttpRequest.FILES\>\`chuig an réimse comhaid sa tsamhail:

```
from django.http import HttpResponseRedirect
from django.shortcuts import render
from .forms import UploadFileForm
from .models import ModelWithFileField

def upload_file(request):
    if request.method == "POST":
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            instance = ModelWithFileField(file_field=request.FILES["file"])
            instance.save()
            return HttpResponseRedirect("/success/url/")
    else:
        form = UploadFileForm()
    return render(request, "upload.html", {"form": form})
```

Má tá réad á thógáil agat de láimh lasmuigh d'iarratas, is féidir leat a:class: ~django.core.files.file cosúil le réad a shannadh chuig an:class: ~django.db.models.filefield:

```
from django.core.management.base import BaseCommand
from django.core.files.base import ContentFile

class MyCommand(BaseCommand):
    def handle(self, *args, **options):
        content_file = ContentFile(b"Hello world!", name="hello-world.txt")
        instance = ModelWithFileField(file_field=content_file)
        instance.save()
```

### Comhad iolracha a uaslódáil

Más mian leat comhad iolracha a uaslódáil ag baint úsáide as réimse foirme amháin, cruthaigh fo-aicme de ghuirléid an réimse agus socraigh a tréith aicme allow\_multiple\_selected go `True`.

Ionas go mbeidh comhaid den sórt sin go léir a bhailíochtú ag d'fhoirm (agus go mbeidh luach an réimse iad go léir san áireamh), beidh ort fo-aicme “FileField” a dhéanamh freisin. Féach thíos le haghaidh sampla.

> **Réimse comhad iolrach**
>
> Is dócha go mbeidh tacaíocht cheart réimse comhad iolrach ag Django ag pointe éigin sa todhchaí.

*`foirme.py`*

```python
from django import forms

class MultipleFileInput(forms.ClearableFileInput):
    allow_multiple_selected = True

class MultipleFileField(forms.FileField):
    def __init__(self, *args, **kwargs):
        kwargs.setdefault("widget", MultipleFileInput())
        super().__init__(*args, **kwargs)

    def clean(self, data, initial=None):
        single_file_clean = super().clean
        if isinstance(data, (list, tuple)):
            result = [single_file_clean(d, initial) for d in data]
        else:
            result = [single_file_clean(data, initial)]
        return result

class FileFieldForm(forms.Form):
    file_field = MultipleFileField()
```

Ansin athraigh an modh form\_valid () de d':class: ~django.views.generic.edit.formView chun uaslódálacha comhad iolracha a láimhseáil:

*`views.py`*

```python
from django.views.generic.edit import FormView
from .forms import FileFieldForm

class FileFieldFormView(FormView):
    form_class = FileFieldForm
    template_name = "upload.html"  # Replace with your template.
    success_url = "..."  # Replace with your URL or reverse().

    def form_valid(self, form):
        files = form.cleaned_data["file_field"]
        for f in files:
            ...  # Do something with each file.
        return super().form_valid(form)
```

> **Warning**
>
> Ligfidh sé seo duit comhad iolracha a láimhseáil ag leibhéal na foirme amháin. Bí ar an eolas nach féidir leat é a úsáid chun comhad iolracha a chur ar shampla samhail amháin (i réimse amháin), mar shampla, fiú má úsáidtear an giuirléid saincheaptha le réimse foirme a bhaineann le samhail FileField\`.

## Uaslódáil Handlers

Nuair a uaslódálann úsáideoir comhad, cuireann Django sonraí na gcomhad chuig\*láimhseálaí uaslódálaí\* - rang beag a láimhseálann sonraí comhaid de réir mar a uaslódáltar iad. Sainmhínítear láimhseálaithe uaslódála ar dtús sa socrú:setting: FILE\_UPLOAD\_HANDLERS, a réamhshocraíonn:

```
[
    "django.core.files.uploadhandler.MemoryFileUploadHandler",
    "django.core.files.uploadhandler.TemporaryFileUploadHandler",
]
```

Le chéile: Class: MemoryFileUploadHandler agus: class: TemporaryFileUploadHandler soláthraíonn 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.

Is féidir leat láimhseálaithe saincheaptha a scríobh a shaincheapann an chaoi a láimhseálann D'fhéadfá, mar shampla, láimhseálaithe saincheaptha a úsáid chun cuótaí ar leibhéal an úsáideora a fhorfheidhmiú, sonraí a chomhbhrú ar an eitilt, barraí dul chun cinn a léiriú, agus fiú sonraí a sheoladh chuig áit stórála eile go díreach gan Féach: ref: custom\_upload\_handlers le haghaidh sonraí maidir le conas is féidir leat iompar uaslódála a shaincheapadh nó a athsholáthar go hiomlán.

### Nuair a stóráiltear sonraí uaslódá

Sula sábhálann tú comhaid uaslódáilte, ní mór na sonraí a stóráil áit éigin.

De réir réamhshocraithe, má tá comhad uaslódáilte níos lú ná 2.5 meigabyte, coinneoidh Django ábhar iomlán an uaslódála i gcuimhne. Ciallaíonn sé seo nach mbíonn ach léamh ón gcuimhne agus scríobh chuig diosca i gceist leis an gcomhad a shábháil agus dá bhrí sin tá sé an-tapa.

Mar sin féin, má tá comhad uaslódáilte ró-mhór, scríobhfaidh Django an comhad uaslódáilte chuig comhad sealadach atá stóráilte in eolaire sealadach do chórais. Ar ardán cosúil le Unix ciallaíonn sé seo gur féidir leat a bheith ag súil go nginfidh Django comhad ar a dtugtar rud éigin cosúil le `/tmpzfp6i6.upload`. Má tá uaslódáil mór go leor, is féidir leat féachaint ar an gcomhad seo ag fás i méid de réir mar a shruthlaíonn Django na sonraí ar an diosca.

Is “réamhshocruithe réasúnacha” iad na sonraíochtaí seo - 2.5 meigabyte; `/tmp`; srl. - is féidir iad a shaincheapadh mar a thuairiscítear sa chéad chuid eile.

### Iompar láimhseála uaslódála

Tá cúpla socrú ann a rialaíonn iompar uaslódála comhad Django. Féach: Ref: Socruithe Uaslódála Comhad \<file-upload-settings\>\`le haghaidh sonraí.

### Láimhseálóirí uaslódála a mhodhnú

Uaireanta teastaíonn iompar uaslódála éagsúla Sna cásanna seo, is féidir leat láimhseálaithe uaslódála a shárú ar bhonn in aghaidh iarratais trí request.upload\_handlers\` a mhodhnú. De réir réamhshocraithe, beidh na láimhseálaithe uaslódála a thugtar ar:setting: FILE\_UPLOAD\_HANDLERS sa liosta seo, ach is féidir leat an liosta a mhodhnú mar a dhéanfá aon liosta eile.

Mar shampla, cuir i gcás go bhfuil “ProgressbarUploadHandler” scríofa agat a sholáthraíonn aiseolas ar dhul chun cinn a uaslódáil chuig cineál éigin giuirléid AJAX. Chuirfeá an láimhseálaí seo le do láimhseálaithe uaslódála mar seo:

```
request.upload_handlers.insert(0, ProgressBarUploadHandler(request))
```

Using `list.insert()`, as shown above, ensures that the progress bar handler
is placed at the beginning of the list. Since upload handlers are executed in
order, this placement guarantees that the progress bar handler runs before the
default handlers, allowing it to track progress across the entire upload.

Más mian leat na láimhseálaithe uaslódála a chur in ionad go hiomlán, is féidir leat liosta nua a shannadh:

```
request.upload_handlers = [ProgressBarUploadHandler(request)]
```

> **Note**
>
> Ní féidir leat láimhseálaithe uaslódála a mhodhnú ach roimh\* roimh rochtain a fháil ar `Request.Post` nó `Request.Files` \- níl ciall láimhseálaithe uaslódála a athrú tar éis do láimhseáil uaslódála tosú cheana féin. Má dhéanann tú iarracht `request.upload_handlers` a mhodhnú tar éis léamh ó `Request.post` nó `Request.Files` caithfidh Django earráid.
>
> Dá bhrí sin, ba cheart duit láimhseálaithe uaslódála a mhodhnú chomh luath i do thuairim agus is féidir.
>
> Also, `request.POST` is accessed by
> [`CsrfViewMiddleware`](/ga/6.1/ref/middleware/#django.middleware.csrf.CsrfViewMiddleware) which is enabled by
> default. This means you will need to use
> [`csrf_exempt()`](/ga/6.1/ref/csrf/#django.views.decorators.csrf.csrf_exempt) on your view to allow you
> to change the upload handlers. You will then need to use
> [`csrf_protect()`](/ga/6.1/ref/csrf/#django.views.decorators.csrf.csrf_protect) on the function that
> actually processes the request. Note that this means that the handlers may
> start receiving the file upload before the CSRF checks have been done.
> Example code:
>
> ```
> from django.views.decorators.csrf import csrf_exempt, csrf_protect
>
>
> @csrf_exempt
> def upload_file_view(request):
>     request.upload_handlers.insert(0, ProgressBarUploadHandler(request))
>     return _upload_file_view(request)
>
>
> @csrf_protect
> def _upload_file_view(request):
>     # Process request
>     ...
> ```
>
> Má tá radharc bunaithe ar rang á úsáid agat, beidh ort: func: ~django.views.decorators.csrf.csrf\_exempt a úsáid ara:meth: ~django.views.generic.base.view.dispch modh agus:func: ~django.views.decorators.csrf.csrf\_protect ar an modh próiseálann an iarratas i ndáiríre. Cód sampla:
>
> ```
> from django.utils.decorators import method_decorator
> from django.views import View
> from django.views.decorators.csrf import csrf_exempt, csrf_protect
>
>
> @method_decorator(csrf_exempt, name="dispatch")
> class UploadFileView(View):
>     def setup(self, request, *args, **kwargs):
>         request.upload_handlers.insert(0, ProgressBarUploadHandler(request))
>         super().setup(request, *args, **kwargs)
>
>     @method_decorator(csrf_protect)
>     def post(self, request, *args, **kwargs):
>         # Process request
>         ...
> ```