---
title: "Berkas Terunggah dan Penangan Unggah"
version: 4.0
locale: id
source: https://docs.djangoproject.com/id/4.0/ref/files/uploads/
canonical: https://djangodocs.dev/id/4.0/ref/files/uploads/
---
# Berkas Terunggah dan Penangan Unggah

## Berkas-berkas terunggah

#### `class UploadedFile`

During file uploads, the actual file data is stored in [`request.FILES`](/id/4.0/ref/request-response/#django.http.HttpRequest.FILES). Each entry in this dictionary is an
`UploadedFile` object (or a subclass) -- a wrapper around an uploaded file.
You'll usually use one of these methods to access the uploaded content:

#### `UploadedFile.read()`

Read the entire uploaded data from the file. Be careful with this method:
if the uploaded file is huge it can overwhelm your system if you try to
read it into memory. You'll probably want to use `chunks()` instead; see
below.

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

Returns `True` if the uploaded file is big enough to require reading in
multiple chunks. By default this will be any file larger than 2.5 megabytes,
but that's configurable; see below.

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

A generator returning chunks of the file. If `multiple_chunks()` is
`True`, you should use this method in a loop instead of `read()`.

In practice, it's often easiest to use `chunks()` all the time. Looping
over `chunks()` instead of using `read()` ensures that large files
don't overwhelm your system's memory.

Ini adalah atribut-atribut berguna dari `UploadedFile`:

#### `UploadedFile.name`

Nama dari berkas terunggah (misalnya `my_file.txt`).

#### `UploadedFile.size`

Ukuran, dalam byte, dari berkas terunggah.

#### `UploadedFile.content_type`

Kepala jenis-isi dinunggah dengan berkas (misalnya `text/plain` atau `application/pdf`). Seperti data apapun disokong oleh pengguna, anda tidak harus percaya bahwa berkas terunggah sebenarnya jenis ini. Anda akan masih butuh mensahkan bahwa berkas mengandung isi yang kepala jenis-isi tagihkan -- "trust but verify."

#### `UploadedFile.content_type_extra`

A dictionary containing extra parameters passed to the `content-type`
header. This is typically provided by services, such as Google App Engine,
that intercept and handle file uploads on your behalf. As a result your
handler may not receive the uploaded file content, but instead a URL or
other pointer to the file (see [**RFC 2388**](https://datatracker.ietf.org/doc/html/rfc2388.html#section-5.3)).

#### `UploadedFile.charset`

For `text/*` content-types, the character set (i.e. `utf8`)
supplied by the browser. Again, "trust but verify" is the best policy here.

> **Note**
>
> Like regular Python files, you can read the file line-by-line by iterating
> over the uploaded file:
>
> ```
> for line in uploadedfile:
>     do_something_with(line)
> ```
>
> Lines are split using [**universal newlines**](https://peps.python.org/pep-0278/). 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'`.

Subkelas-subkelas dari `UploadedFile` termasuk:

#### `class TemporaryUploadedFile`

A file uploaded to a temporary location (i.e. stream-to-disk). This class
is used by the
[`TemporaryFileUploadHandler`](#django.core.files.uploadhandler.TemporaryFileUploadHandler). In
addition to the methods from [`UploadedFile`](#django.core.files.uploadedfile.UploadedFile), it has one additional
method:

#### `TemporaryUploadedFile.temporary_file_path()`

Mengembalikan jalur penuh pada berkas terunggah sementara.

#### `class InMemoryUploadedFile`

A file uploaded into memory (i.e. stream-to-memory). This class is used
by the [`MemoryFileUploadHandler`](#django.core.files.uploadhandler.MemoryFileUploadHandler).

## Penangan unggah siap-pakai

Together the [`MemoryFileUploadHandler`](#django.core.files.uploadhandler.MemoryFileUploadHandler) and
[`TemporaryFileUploadHandler`](#django.core.files.uploadhandler.TemporaryFileUploadHandler) provide Django's default file upload
behavior of reading small files into memory and large ones onto disk. They
are located in `django.core.files.uploadhandler`.

#### `class MemoryFileUploadHandler`

File upload handler to stream uploads into memory (used for small files).

#### `class TemporaryFileUploadHandler`

Upload handler that streams data into a temporary file using
[`TemporaryUploadedFile`](#django.core.files.uploadedfile.TemporaryUploadedFile).

## Menulis penangan unggah penyesuaian

#### `class FileUploadHandler`

All file upload handlers should be subclasses of
`django.core.files.uploadhandler.FileUploadHandler`. You can define upload
handlers wherever you wish.

### Metode-metode diwajibkan

Penyesuaian penangan unggah berkas **harus** ditentukan metode-metode berikut:

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

Menerima "chunk" data dari unggah berkas.

`raw_data` is a bytestring containing the uploaded data.

`start` adalah posisi dimana berkas potongan `raw_data` ini dimulai.

The data you return will get fed into the subsequent upload handlers'
`receive_data_chunk` methods. In this way, one handler can be a
"filter" for other handlers.

Return `None` from `receive_data_chunk` to short-circuit remaining
upload handlers from getting this chunk. This is useful if you're
storing the uploaded data yourself and don't want future handlers to
store a copy of the data.

If you raise a `StopUpload` or a `SkipFile` exception, the upload
will abort or the file will be completely skipped.

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

Dipanggil setelah sebuah berkas selesai diunggah.

The handler should return an `UploadedFile` object that will be stored
in `request.FILES`. Handlers may also return `None` to indicate that
the `UploadedFile` object should come from subsequent upload handlers.

### Metode-metode pilihan

Custom upload handlers may also define any of the following optional methods or
attributes:

#### `FileUploadHandler.chunk_size`

Size, in bytes, of the "chunks" Django should store into memory and feed
into the handler. That is, this attribute controls the size of chunks
fed into `FileUploadHandler.receive_data_chunk`.

For maximum performance the chunk sizes should be divisible by `4` and
should not exceed 2 GB (2<sup>31</sup> bytes) in size. When there are
multiple chunk sizes provided by multiple handlers, Django will use the
smallest chunk size defined by any handler.

Awalan 64\*2<sup>10</sup> byte, atau 64 KB.

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

Callback signaling that a new file upload is starting. This is called
before any data has been fed to any upload handlers.

`field_name` adalah nama string dari bidang `<input>` berkas.

`file_name` adalah nama berkas disediakan oleh peramban.

`content_type` adalah jenis MIME disediakan oleh peramban --Sebagai contoh `'image/jpeg'`.

`content_length` is the length of the image given by the browser.
Sometimes this won't be provided and will be `None`.

`charset` is the character set (i.e. `utf8`) given by the browser.
Like `content_length`, this sometimes won't be provided.

`content_type_extra` is extra information about the file from the
`content-type` header. See [`UploadedFile.content_type_extra`](#django.core.files.uploadedfile.UploadedFile.content_type_extra).

This method may raise a `StopFutureHandlers` exception to prevent
future handlers from handling this file.

#### `FileUploadHandler.upload_complete()`

Callback signaling that the entire upload (all files) has completed.

#### `FileUploadHandler.upload_interrupted()`

> **New in Django 3.2**

Callback signaling that the upload was interrupted, e.g. when the user
closed their browser during file upload.

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

Allows the handler to completely override the parsing of the raw
HTTP input.

`input_data` is a file-like object that supports `read()`-ing.

`META` adalah obyek sama seperti `request.META`.

`content_length` adalah panjang dari data dalam `input_data`. Jangan membaca lebih dari `content_length` byte dari `input_data`.

`boundary` adalah batasan MIME untuk permintaan ini.

`encoding` adalah penyandian dari permintaan.

Return `None` if you want upload handling to continue, or a tuple of
`(POST, FILES)` if you want to return the new data structures suitable
for the request directly.