# dokumentasi Django 2.2.9.dev20191202104323

# Aplikasi `staticfiles`

`django.contrib.staticfiles` menyimpan berkas-berkas tetap dari setiap dari aplikasi anda (dan setiap tempat lain anda tentukan) kedalam tempat tunggal yang dapat dengan mudah dilayani di produksi.

lihat juga

Untuk sebuah perkenalaln pada aplikasi berkas-berkas tetap dan beberapa penggunaan contoh, lihat Mengelola berkas statis (sebagai contoh gambar, JavaScript, CSS). Untuk panduan dalam menyebarkan berkas-berkas tetap, lihat menyebarkan berkas tetap.

## Pengaturan

Lihat staticfiles settings untuk rincian pada pengaturan berikut:

- `STATIC_ROOT`
- `STATIC_URL`
- `STATICFILES_DIRS`
- `STATICFILES_STORAGE`
- `STATICFILES_FINDERS`

## Pengelolaan perintah

`django.contrib.staticfiles` membuka tiga perintah pengelolaan.

### `collectstatic`

`django-admin collectstatic`

Kumpulkan berkas-berkas tetap kedalam `STATIC_ROOT`.

Gandakan nama-nama berkas secara awalan diselesaikan dalam cara mirip untuk bagaimana ketetapan cetakan bekerja: berkas yaitu pertama ditemukan dalam satu dari tempat yang ditentukan akan digunakan. Jika anda sedang bingung, perintah `findstatic` dapat membantu anda dimana berkas-berkas ditemukan.

Pada jalanan `collectstatic` selanjutnya (jika `STATIC_ROOT` tidak kosong), berkas disalain hanya jike mereka telah merubah timestamp lebih besar dari timestamp dari berkas dalam `STATIC_ROOT`. Oleh karena itu jika anda memindahkan sebuah aplikasi dari `INSTALLED_APPS`, itu adalah ide bagus menggunakan pilihan `collectstatic --clear` untuk memindahkan berkas tetap yang lama.

Berkas-berkas dicari dengan menggunakan `enabled finders`. Awalan adalah mencari dalam semua tempat ditentukan dalam `STATICFILES_DIRS` dan dalam direktori `'static'` dari aplikasi ditentukan oleh pengaturan `INSTALLED_APPS`.

Perintah pengelolaan `collectstatic` memanggil metode `post_process()` dari `STATICFILES_STORAGE` setelah setiap berjalan dan melewatkan sebuah daftar dari jalur yang telah ditemukan oleh perintah pengelolaan. Itu juga menerima semua pilihan baris perintah dari `collectstatic`. Ini digunakan oleh `ManifestStaticFilesStorage` secara awalan.

Secara awalan, berkas-berkas terkumpul menerima perizinan dari `FILE_UPLOAD_PERMISSIONS` dan direktori terkumpul menerima perizinan dari `FILE_UPLOAD_DIRECTORY_PERMISSIONS`. Jika anda ingin perizinan berbeda untuk berkas dan direktori ini, anda dapat mensubkelaskan salah satu dari static files storage classes dan menentukan `file_permissions_mode` dan/atau parameter `directory_permissions_mode`, masing-masing. Sebagai contoh:

    from django.contrib.staticfiles import storage

    class MyStaticFilesStorage(storage.StaticFilesStorage):
        def __init__(self, *args, **kwargs):
            kwargs['file_permissions_mode'] = 0o640
            kwargs['directory_permissions_mode'] = 0o760
            super().__init__(*args, **kwargs)

Kemudian setel pengaturan `STATICFILES_STORAGE` menjadi `'path.to.MyStaticFilesStorage'`.

Beberapa pilihan umum digunakan adalah:

`--noinput````,` `--no-input```

  JANGAN mengarahkan pengguna untuk masukan apapun.

`--ignore` `PATTERN``,` `-i` `PATTERN`

  Mengabaikan berkas-berkas, direktori, atau jalur cocok pola gaya-global ini. Gunakan beberapa kali untuk mengabaikan lebih. Ketika menentukan sebuah jalur, selalu gunakan garis miring ke depan, bahkan pada Windows.

  Changed in Django 2.2:

  Pencocokan jalur telah ditambahkan.

`--dry-run````,` `-n```

  Lakukan apapun kecuali merubah sistem berkas.

`--clear````,` `-c```

  Bersihkan berkas-berkas yang ada sebelum mencoba menyalin atau menaut berkas asli.

`--link````,` `-l```

  Buat sebuah tautan simbolus pada setiap berkas daripada menyalin.

`--no-post-process```

  Jangan memanggil metode `post_process()` dari backend penyimpanan `STATICFILES_STORAGE` yang sudah dikonfigurasi.

`--no-default-ignore```

  Jangan abaikan pola-gaya-blobal pribadi umum `'CVS'`, `'.*'` dan `'*~'`.

Untuk daftar penuh dari pilihan, mengacu pada bantuan perintah sendiri dengan menjalankan:

/ 

    $ python manage.py collectstatic --help

    ...\> py manage.py collectstatic --help

#### Menyesuaikan daftar pola diabaikan

Daftar pola diabaikan awalan, `['CVS', '.*', '*~']`, dapat disesuaikan dalam satu cara tetap daripada menyediakan pilihan perintah `--ignore` pada setiap permohonan `collectstatic`. Sediakan kelas `AppConfig` penyesuaian, timpa atribut `ignore_patterns` dari kelas ini dan ganti `'django.contrib.staticfiles'` dengan jalur kelas itu dalam pengaturan `INSTALLED_APPS` anda:

    from django.contrib.staticfiles.apps import StaticFilesConfig

    class MyStaticFilesConfig(StaticFilesConfig):
        ignore_patterns = [...]  # your custom ignore list

### `findstatic`

`django-admin findstatic staticfile [staticfile ...]`

Mencari untuk satu atau lebih jalur relatif dengan diadakan penemu.

Sebagai contoh:

/ 

    $ python manage.py findstatic css/base.css admin/js/core.js
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css
      /home/polls.com/core/static/css/base.css
    Found 'admin/js/core.js' here:
      /home/polls.com/src/django/contrib/admin/media/js/core.js

    ...\> py manage.py findstatic css\base.css admin\js\core.js
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css
      /home/polls.com/core/static/css/base.css
    Found 'admin/js/core.js' here:
      /home/polls.com/src/django/contrib/admin/media/js/core.js

`findstatic``--first`

Secara awalan, semua tempat cocok ditemukan. Kembalian satu-satunya pertama yang cocok untuk setiap jalur relatif, gunakan pilihan `--first`:

/ 

    $ python manage.py findstatic css/base.css --first
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css

    ...\> py manage.py findstatic css\base.css --first
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css

Ini adalah pertolongan mencari kesalahan; itu akan menunjukkan anda tepatnya berkas tetap mana akan dikumpulkan untuk jalur yang diberikan.

Dengan mensetel bendera `--verbosity` menjadi 0, anda dapat menekan keluaran tambahan dan hanya mendapatkan jalur nama:

/ 

    $ python manage.py findstatic css/base.css --verbosity 0
    /home/special.polls.com/core/static/css/base.css
    /home/polls.com/core/static/css/base.css

    ...\> py manage.py findstatic css\base.css --verbosity 0
    /home/special.polls.com/core/static/css/base.css
    /home/polls.com/core/static/css/base.css

Disisi lain, dengan mengatur bendera `--verbosity` menjadi 2, anda dapat mendapatkan semua direktori yang dicari:

/ 

    $ python manage.py findstatic css/base.css --verbosity 2
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css
      /home/polls.com/core/static/css/base.css
    Looking in the following locations:
      /home/special.polls.com/core/static
      /home/polls.com/core/static
      /some/other/path/static

    ...\> py manage.py findstatic css\base.css --verbosity 2
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css
      /home/polls.com/core/static/css/base.css
    Looking in the following locations:
      /home/special.polls.com/core/static
      /home/polls.com/core/static
      /some/other/path/static

### `runserver`

`django-admin runserver [addrport]`

Timpa perintah inti `runserver` jika aplikasi `staticfiles` `installed` dan tambah penyajian otomatis dari berkas-berkas statis. Penyajian berkas tidak berjalan melalui `MIDDLEWARE`.

Perintah menambah pilihan-pilihan ini:

`--nostatic```

Gunakan pilihan `--nostatic` untuk meniadakan penyajian berkas-berkas statis dengan aplikasi staticfiles seluruhnya. Pilihan ini hanya tersedia jika aplikasi staticfiles dalam pengaturan `INSTALLED_APPS` proyek anda.

Contoh penggunaan:

/ 

    $ django-admin runserver --nostatic

    ...\> django-admin runserver --nostatic

`--insecure```

Gunakan pilihan `--insecure` untuk memaksa melayani berkas-berkas statis dengan aplikasi staticfiles bahkan jika pengaturan `DEBUG` adalah `False`. Dengan menggunakan ini anda mengetahui kenyataan bahwa itu adalah terlalu tidak efesien dan mungkin tidak nyaman. Ini hanya bertujuan untuk pengembangan lokal, harus jangan pernah digunakan dalam produksi dan hanya tersedia jika aplikasi staticfiles berada dalam pengaturan `INSTALLED_APPS` proyek anda.

`--insecure` tidak dapat bekerja dengan `ManifestStaticFilesStorage`.

Contoh penggunaan:

/ 

    $ django-admin runserver --insecure

    ...\> django-admin runserver --insecure

## Penyimpanan

### `StaticFilesStorage`

class `storage.``StaticFilesStorage`

Sebuah subkelas dari backend penyimpanan `FileSystemStorage` yang menggunakan pengaturan `STATIC_ROOT` sebagai berkas dasar tempat sistem dan pengaturan `STATIC_URL` masing-masing sebagai dasar URL.

`storage.StaticFilesStorage.``post_process`(paths, **options)

Jika metode ini ditentukan pada penyimpanan, itu dipanggil oleh perintah pengelolaan `collectstatic` setelah tiap larian dan meloloskan penyimpanan lokal dan jalur dari berkas-berkas ditemukan sebagai sebuah dictionary, sama halnya pilihan baris perintah. Itu menghasilkan tuple-tuple dari tiga nilai: `original_path, processed_path, processed`. Nilai jalur adalah string dan `processed` adalah boolean mengunjukkan apakah atau tidak nilai setelah-diolah, atau sebuah pengecualian jika setelah-diolah gagal.

`ManifestStaticFilesStorage` menggunakan dibelakang layar ini untuk mengganti jalur dengan pasangan campuran mereka dan memperbaharui cache secara tepat.

### `ManifestStaticFilesStorage`

class `storage.``ManifestStaticFilesStorage`

Sebuah subkelas dari backend penyimpanan `StaticFilesStorage` yang menyimpan nama berkas itu tangani dengan menambahkan campuran MD5 dari isi berkas ke nama berkas. Sebagai contoh, berkas `css/styles.css` akan juga disimpan sebagai `css/styles.55e7cbb9ba48.css`.

Tujuan dari penyimpanan ini adalah tetap melayani berkas-berkas bilamana beberapa halaman masih mengacu ke berkas-berkas tersebut, misalnya karena mereka di cache oleh anda atau peladen proxy pihak ke 3. Sebagai tambahan, itu sangat membantu jika anda ingin memberlakukan far future Expires headers pada berkas pengembangan untuk mempercepat waktu muat untuk kunjungan halaman selanjutnya.

Backend penyimpanan otomatis mengganti jalur ditemukan dalam berkas tersimpan cocok dengan berkas tersimpan lain dengan jalur dari salinan ter cache (menggunakan metode `post_process()`). Regular expression digunakan untuk menemukan jalur-jalur tersebut (`django.contrib.staticfiles.storage.HashedFilesMixin.patterns`) secara awalan mencakupi pernyataan @import rule dan url() dari Cascading Style Sheets. Sebagai contoh, berkas `'css/styles.css'` dengan isi.

    @import url("../admin/css/base.css");

akan diganti dengan memanggil metode `url()` dari abckend penyimpanan `ManifestStaticFilesStorage`, akhirnya menyimpan sebuah berkas `'css/styles.55e7cbb9ba48.css'` dengan isi berikut:

    @import url("../admin/css/base.27e20196a850.css");

`storage.ManifestStaticFilesStorage.``max_post_process_passes`

Sejak berkas-berkas tetap mungkin mengacu berkas-berkas tetap lainnya yang butuh jalur mereka diganti, banyak pelewatan dari mengganti jalur mungkin dibutuhkan sampai campuran berkas bertemu di satu tempat. Untuk mencegah dari putaran tak terbatas pada campuran tidak bertemu di satu tempat (sebagai contoh, jika `'foo.css'` mengacu `'bar.css'` yang mengacu `'foo.css'`) ada angka maksimal dari pelewatan sebelum setelah-pengolahan diabaikan. Dalam kasus dengan sejumlah besar acuan, ankga tertinggi dari pelewatan mungkin dibutuhkan. Meningkatkan angka maksimal dari pelewatan dengan mensubkelaskan `ManifestStaticFilesStorage` dan mengatur atribut``max_post_process_passes``. Itu awalan pada 5.

Untuk mengadakan `ManifestStaticFilesStorage` anda harus memastikan persyaratan berikut terpenuhi:

- Pengaturan `STATICFILES_STORAGE` disetel menjadi `'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'`
- Pengaturan `DEBUG` disetel ke `False`
- Anda telah mengumpulkan semua berkas tetap dengan menggunakan perintah pengelolaan `collectstatic`

Sejak membuat campuran MD5 hash bisa menjadi beban kinerja ke situs jaringan anda selama waktu berjalan, `staticfiles` akan otomatis menyimpan pemetaan dengan nama dicampur untuk semua berkas-berkas terolah dalam sebuah panggilan berkas `staticfiles.json`. Ini terjadi sekali ketika anda menjalankan perintah pengelolaan `collectstatic`.

`storage.ManifestStaticFilesStorage.``manifest_strict`

Jika sebuah berkas tidak ditemukan dalam wujud `staticfiles.json` pada waktu berjalan, sebuah `ValueError` dimunculkan. Perilaku ini dapat ditiadakan dengan mensubkelaskan `ManifestStaticFilesStorage` dan mengatur atribut `manifest_strict` menjadi `False` -- jalur tidak ada akan tetap tidak berubah.

Dikarenakan persyaratan dari menjalankan `collectstatic`, penyimpanan ini khususnya jangan digunakan ketika menjalankan percobaan sebagai `collectstatic` bukan berjalan sebagai bagian dari pengaturan percobaan biasa. Selama percobaan, pastikan bahwa pengaturan `STATICFILES_STORAGE` disetel ke sesuatu lain seperti `'django.contrib.staticfiles.storage.StaticFilesStorage'` (awalan).

`storage.ManifestStaticFilesStorage.``file_hash`(name, content=None)

Metode yang digunakan ketika membuat nama dicampur dari berkas. Butuh mengembalikan sebuah campuran untuk nama berkas dan isi yang diberikan. Secara awalan itu menghitung campuran MD5 dari potongan isi seperti disebutkan diatas. Merasa bebas untuk menimpa metode ini untuk digunakan algotirma campuran anda sendiri.

### `CachedStaticFilesStorage`

class `storage.``CachedStaticFilesStorage`

Ditinggalkan sejak versi 2.2: `CachedStaticFilesStorage` diusangkan karena memiliki beberapa masalah yang sulit dipecahkan,beberapa diantaranya diuraikan dibawah. Gunakan `ManifestStaticFilesStorage` atau penyimpanan awan pihak ketiga sebagai gantinya.

`CachedStaticFilesStorage` adalah kelas mirip seperti kelas `ManifestStaticFilesStorage` tetapi menggunakan caching framework Django untuk menyimpan nama-nama campuran dari berkas-berkas terolah daripada berkas nyata satis disebut `staticfiles.json`. Ini adalah kebanyakan berguna untuk keadaan dimana anda tidak mempunyai akses ke sistem berkas.

Jika anda ingin menimpa pilihan tertentu dari backend cache penggunaan penyimpanan, cukup menentukan masuakn penyesuaian dalam pengaturan `CACHES` bernama `'staticfiles'`. Itu kembali untuk menggunakan backend cache `'default'`.

Peringatan

`CachedStaticFilesStorage``tidak dianjurkan -- dalam kebanyakan semua kasus ``ManifestStaticFilesStorage` adalah pilihan terbaik. Ada beberapa hukuman penampilan ketika menggunakan `CachedStaticFilesStorage` sejak sebuah cache hilang berkas-berkas campuran dibutuhkan pada waktu berjalan. Penyimpanan berkas terpencil membutuhkan beberapa perjalanan-pulang-pergi round-trips untuk mencampur sebuah berkas pada sebuah cache hilang, ketika beberapa berkas diakses dibutuhkan untuk memastikan bahwa berkas campuran adalah benar dalam kasus jalur berkas bersarang.

### `ManifestFilesMixin`

class `storage.``ManifestFilesMixin`

Gunakan mixin ini dengan penyimpanan penyesuaian untuk menambahkan campuran MD5 dari isi berkas ke nama berkas seperti `ManifestStaticFilesStorage` lakukan.

## penemu Modul

Penemu `staticfiles` mempunyai sebuah atribut `searched_locations` dimana daftar dari jalur direktori dimana penemu mencari. Contoh penggunaan:

    from django.contrib.staticfiles import finders

    result = finders.find('css/base.css')
    searched_locations = finders.searched_locations

## Pembantu Lain

Ada sedikit pembantu lain diluar dari aplikasi `staticfiles` untuk bekerja dengan berkas-berkas tetap:

- Pengolah konteks yang menambahkan `django.template.context_processors.static()` `STATIC_URL` pada setiap cetakan konteks dibangun dengan konteks `RequestContext`.
- Etiket cetakansiap pakai `static` yang mengambil jalur dan gabungan url itu dengan awalan statis `STATIC_URL`. Jika `django.contrib.staticfiles` dipasang, etiket menggunakan metode `url()` dari `STATICFILES_STORAGE` sebagai gantinya.
- Etiket cetakan siap pakai `get_static_prefix` yang mengumpulkan variabel cetakan dengan awalan tetap `STATIC_URL` untuk digunakan sebagai sebuah variabel atau langsung.
- Etiket cetakan mirip `get_media_prefix` yang bekerja seperti `get_static_prefix` tetapi menggunakan `MEDIA_URL`.

### Tampilan pengembahan berkas tetap

Alat-alat berkas statis kebanyakan dirancang untuk membantu dengan mendapatkan berkas-berkas statis berhasil disebarkan kedalam produksi. Ini biasanya berarti memisahkan, peladen berkas statis berdedikasi, yaitu banyak overhead dikacaukan ketika mengembangkan secara lokal. Dengan demikian, aplikasi `staticfiles` dikirim dengan sebuah tampilan pembantu cepat dan jorok yang anda dapat gunakan untuk melayani berkas-berkas secara lokal dalam pengembangan.

`views.``serve`(request, path)

Ini menampilkan fungsi melayani berkas-berkas tetap dalam pengembangan.

Peringatan

Tampilan ini hanya bekerja jika `DEBUG` adalah `True`.

Itu karena tampilan ini terlalu tidak efesien dan mungkin tidak aman. Ini hanya bertujuan untuk pengembangan lokal, dan harus jangan pernah digunakan dalam produksi.

Catatan

Untuk menebak jenis isi berkas dilayani, tampilan ini bergantung pada modul `mimetypes` dari pustaka standar Python, yang itu sendiri bergantung pada pokok berkas peta serambi. Jika anda menemukan bahwa tampilan ini tidak mengembalikanjenis isi yang sesuai untuk berkas-berkas tertent, itu kebanyakan sepertinya bahwa berkas-berkas peta serambi butuh diperbaharui. Ini dapat dicapai, sebagai contoh, dengan memasang atau memperbaharui paket `mailcap` pada penyaluran Red Hat, atau `mime-support` pada penyaluran Debian.

Tampilan ini otomatis diadakan oleh `runserver` (dengan pengaturan `DEBUG` disetel menjadi `True`). Untuk menggunakan tampilan dengan peladen pengembangan lokal bereda, tambah potongan berikut ke akhir dari konfigurasi URL utama anda:

    from django.conf import settings
    from django.contrib.staticfiles import views
    from django.urls import re_path

    if settings.DEBUG:
        urlpatterns += [
            re_path(r'^static/(?P<path>.*)$', views.serve),
        ]

catat, awal dari pola (`r'^static/'`) seharusnya pengaturan `STATIC_URL` anda.

Sejak ini adalah sedikit rewel, ada juga fungsi pembantu yang akan melakukan ini untuk anda:

`urls.``staticfiles_urlpatterns`()

Ini akan mengembalikan pola URL sebenarnya untuk melayani berkas-berkas tetap ke daftar pola anda sudah tetapkan. Gunakan itu seperti ini:

    from django.contrib.staticfiles.urls import staticfiles_urlpatterns

    # ... the rest of your URLconf here ...

    urlpatterns += staticfiles_urlpatterns()

Ini akan memeriksa pengaturan `STATIC_URL` anda dan mengikat tampilan untuk melayani berkas-berkas tetap sesuai. jangan lupa mensetel pengaturan `STATICFILES_DIRS` dengan tepat untuk membuat `django.contrib.staticfiles` tahu dimana mencari untuk berkas-berkas tambahan ke berkas-berkas dalam direktori aplikasi.

Peringatan

Fungsi pembantu ini hanya akan bekerja jika `DEBUG` adalah `True` dan pengaturan `STATIC_URL` anda tidak juga kosong maupun URL penuh seperti `http://static.example.com/`.

Itu karena tampilan ini terlalu tidak efesien dan mungkin tidak aman. Ini hanya bertujuan untuk pengembangan lokal, dan harus jangan pernah digunakan dalam produksi.

### Kasus percobaan khusus untuk mendukung 'live testing'

class `testing.``StaticLiveServerTestCase`

Subkelas TestCase unittest ini memperpanjang `django.test.LiveServerTestCase`.

Sama seperti orang tuanya, anda dapat menggunakan itu menulis percobaan yang melibatkan kode dibawah percobaan dan menkonsumsi itu dengan alat-alat percobaan melalui HTTP (misalnya Selenium, PhantomJS, dll.), karena dimana itu dibutuhkan bahwa aset-aset statis juga diterbitkan.

Tetapi diberikan kenyataan bahwa itu menggunakan dari tampilan `django.contrib.staticfiles.views.serve()` digambarkan diatas, itu dapat secara transparan melapisi pada waktu-penjalanan aset-aset disediakan oleh penemu `staticfiles`. Ini berarti anda tidak perlu menjalankan `collectstatic` sebelum atau sebagai bagian dari pengaturan percobaan anda.