+
+
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
diff --git a/CONTRIBUTION.md b/CONTRIBUTION.md
new file mode 100644
index 0000000000..e83a57ab24
--- /dev/null
+++ b/CONTRIBUTION.md
@@ -0,0 +1,39 @@
+# Halaman Panduan Berkontribusi
+
+Beberapa panduan yang harus diikuti bila ingin ikut berkontribusi pada proses penerjemahan dokumentasi Vue.js ke dalam Bahasa Indonesia
+
+## Pengurus Utama
+
++ [@mul14](https://github.com/mul14), Telegram: [@mul14](https://t.me/@mul14)
++ [@mazipan](https://github.com/mazipan), Telegram: [@mazipan](https://t.me/@mazipan)
++ [@nusendra](https://github.com/nusendra), Telegram: [@nusendra](https://t.me/@nusendra)
++ [@isatrio](https://github.com/isatrio), Telegram: [@isatrio](https://t.me/@isatrio)
+
+## Kontribusi Menerjemahkan
+
++ Silakan fork dari repositori ini, bila belum mengerti cara `fork` silakan baca artikel https://help.github.com/articles/fork-a-repo/
++ Sebelum memulai proses, pastikan anda melihat halaman **[issues](https://github.com/vuejs-id/docs/issues)** untuk mengecek apakah sudah ada yang mengerjakan halaman tersebut atau belum.
++ Setiap halaman akan memiliki *issue* tersendiri, jika *issue* tersebut belum di *assign* ke seseorang berarti belum ada yang mengerjakan halaman tersebut.
++ Silakan tambahkan komentar pada *issue* dari halaman yang ingin Anda kerjakan. Pastikan mention salah satu pengurus. Mas [@mul14](https://github.com/mul14), [@nusendra](https://github.com/nusendra) atau [@mazipan](https://github.com/mazipan) untuk *assign* *issue* tersebut.
++ Branch yang menjadi panduan adalah branch `master`.
++ Buat branch dari base branch dengan nama halaman yang kalian terjemahkan, misalkan `introduction`. Bila belum mengerti bagaimana membuat branch silakan baca artikel [https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/](https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/)
++ Pastikan kalian sudah membaca [kamus berbagai istilah asing](GLOSARIUM.md) yang kami kumpulkan. Kemungkinan besar kalian akan bertemu dengan berbagai kata tersebut, ada baiknya kalau kalian mengenalnya terlebih dahulu.
++ Setelah selesai menerjemahkan, silakan buat Pull Request ke branch `master` pada repositori ini.
++ Jangan lupa untuk menyertakan komentar nomor Pull Request yang dibuat lewat komentar di dalam issue agar saling terkait antara Issue dan Pull Request.
++ Para pengurus dan teman-teman lain akan membantu melakukan review pada Pull Request kalian, bila semuanya sudah bagus maka dengan segera bisa di `merge` ke branch `master`.
++ Kami tidak memperkenankan kalian mengerjakan lebih dari satu halaman pada satu waktu untuk tetap menjaga fokus, pastikan selesaikan terlebih dahulu halaman yang sudah kalian ambil sebelumnya. Pastikan halaman tersebut selesai dan telah di merge, setelahnya baru kalian boleh mengambil issue lain.
+
+> Note : Usahakan ketika menerjemahkan menggunakan kalimat Indonesia yang natural (Mudah dibaca, tidak seperti terjemahan mentah yang kaku ala Google translate)
+
+## Kontribusi Lain
+
+Bila kalian tidak terbiasa dengan proses menerjemahkan dengan Git, mungkin akan mengalami kesulitan dalam mengikuti `git flow` yang kita tentukan. Jangan khawatir, kalian masih bisa berkontribusi tanpa harus ikut menerjemahkan sebuah halaman. Berikut beberepa kontribusi yang bisa kalian berikan pada kami:
+
++ Berikan ⭐️ pada repositori ini.
++ Sebarkan berita mengenai proses menerjemahkan dokumentasi ini agar ada teman lain yang sanggup dan ingin membantu proses menerjemahkan.
++ Bantu para pengurus melakukan review pada halaman [Pull Request](https://github.com/vuejs-id/docs/pulls) agar kualitas terjemahan bisa dijaga dengan baik.
++ Bergabung dengan komunitas Vue.js Indonesia di [Facebook](https://www.facebook.com/groups/1675298779418239/), [Telegram](https://t.me/vuejsid) dan [Medium](https://medium.com/vuejs-id).
+
+## Beberapa pertanyaan umum
+
+Silakan baca di halaman [Pertanyaan Umum](FAQ.md)
diff --git a/FAQ.md b/FAQ.md
new file mode 100644
index 0000000000..4125f41127
--- /dev/null
+++ b/FAQ.md
@@ -0,0 +1,4 @@
+# Beberapa pertanyaan umum mengenai proses penerjemahan
+
+## Q
+A:
diff --git a/GLOSARIUM.md b/GLOSARIUM.md
new file mode 100644
index 0000000000..3c94783081
--- /dev/null
+++ b/GLOSARIUM.md
@@ -0,0 +1,228 @@
+# Kamus Perbendaharaan Istilah Asing
+
+📚 Kamus perbendaharaan kata asing yang akan sering ditemukan ketikan menerjemahkan dokumentasi resmi Vue.js.
+
+## Sumber yang akan membantu Anda menerjemahkan
+
+- [PUEBI](https://puebi.readthedocs.io/en/latest/)
+- [KBBI Kemdigbud](https://kbbi.kemdikbud.go.id/)
+- [Kateglo.com](http://kateglo.com/)
+- [Hukum Diterangkan Menerangkan](https://rubrikbahasa.wordpress.com/2003/09/01/hukum-dm-dalam-bahasa-indonesia/)
+
+## Navigasi Berdasarkan Abjad
+
++ [A](#a), [B](#b), [C](#c), [D](#d), [E](#e), [F](#f),
++ [G](#g), [H](#h), [I](#i), [J](#j), [K](#k), [L](#l),
++ [M](#m), [N](#n), [O](#o), [P](#p), [Q](#q), [R](#r),
++ [S](#s), [T](#t), [U](#u), [V](#v), [W](#w), [X](#x),
++ [Y](#y), [Z](#z)
+
+## A
+
+- Analyze: Analisis
+- Argument: Argumen
+- Attribute: Atribut
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## B
+
+- Bind: *Bind*
+- Browser: Peramban
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## C
+
+- Case: Aturan Huruf
+- Chain: Rantai (atau bisa dengan tetap *Chain*)
+- Child: Anak
+- Component: Komponen
+- Compile: Menyusun/Menghimpun
+- Console: Konsol
+- Constructor: Konstruktor
+- Custom: Khusus
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## D
+
+- Default: Bawaan
+- Default Value: Nilai Anggapan
+- Define: Mendefinisikan
+- Development: Developmen, Pengembangan, Pembuatan (Pilih senatural mungkin)
+- Deploy: Menggelar (Tetap diikuti dengan bahasa inggris asli italic dan dalam kurung)
+- Deployment: Penggelaran (Tetap diikuti dengan bahasa inggris asli italic dan dalam kurung)
+- Directive: Direktif
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## E
+
+- E.g. (exempli gratia / for example): Sebagai Contoh
+- Element: Elemen
+- Error: Galat
+- Event: *Event*
+- Extracted: Diekstraksi
+- Export: Ekspor
+- Expression: Ekspresi
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## F
+
+- File: Berkas
+- Framework: Kerangka kerja
+- Function: *Function*
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## G
+
+- Gotcha: Rintangan / Halangan
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## H
+
+- Hook: Kait (untuk beberapa konteks Anda perlu tetap menggunakan Hook dengan font miring)
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## I
+
+- I.e. (id est / in other words): Dengan kata lain
+- Import: Impor
+- Inception: Permulaan
+- Index: Indeks
+- Inheritance: Pewarisan
+- Instance: *Instance*
+- Instantiate: *Instantiate*
+- Interpolation: Interpolasi
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## J
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## K
+
+- Key: *Key*
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## L
+
+- Library: Pustaka
+- Lifecycle: Siklus Hidup
+- Listener: Pemantau (pada beberapa konteks mungkin tidak cocok, bisa dipertimbangkan menggunakan *listener*)
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## M
+
+- Modifier: Pengubah
+- Mount: Pasang
+- Mutate: Memutasi
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## N
+
+- Nested: Bersarang
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## O
+
+- Object: Objek
+- Option: Opsi (beberapa konteks harus diartikan "Pilihan")
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## P
+
+- Parent: Induk
+- Passing: Mengoper
+- Path: Jalur
+- Piece-by-piece: Sepotong-sepotong
+- Project: Proyek
+- Property: Properti
+- Props: Props
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## Q
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## R
+
+- Refactor: *Refactor*
+- Render: *Render*
+- Return: Mengembalikan
+- Router: *Router*
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## S
+
+- Section: Bagian/Seksi
+- Set: Menetapkan
+- Shorthand: Tulisan cepat (tambahkan imbuhan sesuai dengan konteks jika diperlukan)
+- String: Untai
+- Style: Gaya
+- Style Guide: Panduan Gaya
+- Single Page Application: Aplikasi *Single-Page*
+- Single File Component: Komponen Berkas Tunggal (untuk penggunaan pertama kali dalam halaman tersebut, sertakan kata aslinya di dalam kurung)
+- Statement: Statemen
+- Syntax: Sintaksis
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## T
+
+- Template: Templat
+- Trigger: Picu (memicu/dipicu)
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## U
+
+- Update: Pembaruan - Updated: Diperbarui
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## V
+
+- Value: Nilai
+- Virtual DOM: DOM Virtual
+-
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## W
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## X
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## Y
+
+- You: Anda
+
+[⬆️](#navigasi-berdasarkan-abjad)
+
+## Z
+
+
+[⬆️](#navigasi-berdasarkan-abjad)
diff --git a/README.md b/README.md
index db4b5ba602..6869da49ad 100644
--- a/README.md
+++ b/README.md
@@ -1,92 +1,56 @@
-# vuejs.org
+# 🇮🇩 Dokumentasi resmi Vue.js dalam Bahasa Indonesia
+[](#contributors)
-This site is built with [hexo](http://hexo.io/). Site content is written in Markdown format located in `src`. Pull requests welcome!
+Halaman ini dibuat menggunakan [hexo](http://hexo.io/). Konten ditulis menggunakan _Markdown_ dan diletakkan pada direktori `src`. _*Pull requests*_ Anda sangat kami tunggu!
-## Developing
+## Website
+Dokumentasi bisa diakses di halaman web situs [http://docs.vuejs.id](http://docs.vuejs.id)
+
+## Proses Development
+
+Jika anda menggunakan NPM
``` bash
+# npm
$ npm install
-$ npm start # dev server at http://localhost:4000
+$ npm start # dev server di http://localhost:4000
```
-## Deploying
-
-The site is automatically deployed when commits land in `master`, via [Netlify](https://www.netlify.com/).
-
-If you are the maintainer of a community translation fork and would like to deploy via Netlify instead of GitHub pages, please ping @yyx990803 in an issue to request a Netlify team membership and DNS update.
-
-## On Translations
-
-Translation for this documentation project are currently maintained in separate repositories forked from this original one.
-
-### French
-
-French translation is maintained by Vuejs-FR.
-
-* Translation Repo - [/vuejs-fr/vuejs.org](https://github.com/vuejs-fr/vuejs.org)
-
-### Italian
-
-* Translation Repo - [/vuejs/it.vuejs.org](https://github.com/vuejs/it.vuejs.org)
-
-### Japanese
-
-Japanese translation is maintained by [Vue.js japan user group](https://github.com/vuejs-jp)
-
-* Translation Repo - [/vuejs/jp.vuejs.org](https://github.com/vuejs/jp.vuejs.org)
-* Primary maintainer - [kazupon](https://github.com/kazupon)
-* Secondary Maintainers:
- * [re-fort](https://github.com/re-fort)
- * [potato4d](https://github.com/potato4d)
-
-### Korean
-
-Korean translation is maintained by [Vue.js Korean User group](https://github.com/vuejs-kr).
-
-* Translation Repo - [/vuejs-kr/kr.vuejs.org](https://github.com/vuejs-kr/kr.vuejs.org)
-* Primary maintainer - [ChangJoo Park](https://github.com/ChangJoo-Park)
-
-### Mandarin
-
-* Translation Repo - [/vuejs/cn.vuejs.org](https://github.com/vuejs/cn.vuejs.org)
-
-### Persian (Farsi)
-
-Persian translation is maintained by VueJS-fa.
-
-* Translation Repo - [/vuejs-fa/fa.vuejs.org](https://github.com/vuejs-fa/fa.vuejs.org)
-* Primary maintainer - [Pooya Parsa](https://github.com/pi0)
+Jika anda menggunakan Yarn
+``` bash
+$ yarn
+$ yarn start # dev server at http://localhost:4000
+```
-### Português-Br
+## Kontribusi
-Português-Br translation is maintained by [Vuejs-Br](https://github.com/vuejs-br).
+Silakan lihat di halaman [Panduan Berkontribusi](CONTRIBUTION.md)
-* Translation Repo - [/vuejs-br/br.vuejs.org](https://github.com/vuejs-br/br.vuejs.org)
+## Kamus Perbendaharaan Istilah
-### Russian
+Silakan lihat di halaman [Kamus Perbendaharaan Istilah](GLOSARIUM.md)
-Russian translation is maintained by Translation Gang.
+## Progres
-* Translation Repo - [/translation-gang/ru.vuejs.org](https://github.com/translation-gang/ru.vuejs.org)
-* Primary maintainer - [Grigoriy Beziuk](https://gbezyuk.github.io)
+Silakan lihat di halaman [Milestone](https://github.com/vuejs-id/docs/milestones) dan [Issues](https://github.com/vuejs-id/docs/issues).
-### Spanish
-Spanish translation is maintained by [1950Labs](https://1950labs.com) and Vue.js Montevideo ([Leonel More](https://twitter.com/leonelmore), [Sebastian Camacho](https://twitter.com/sxcamacho), and [Diana Rodriguez](https://vue.beingadev.rocks).
+## Beberapa pertanyaan umum
-* Translation Repo - [/1950Labs/vuejs.org](https://github.com/1950Labs/vuejs.org)
+Silakan baca di halaman [Pertanyaan Umum](FAQ.md)
-### Vietnamese
+----
-Vietnamese translation is maintained by [Vue.js Vietnam User group](https://github.com/vuejs-vn/).
+Diterjemahkan oleh komunitas [Vue.js Indonesia](https://github.com/vuejs-id/) dengan dukungan banyak [kontributor](https://github.com/vuejs-id/docs/graphs/contributors) hebat.
-* Translation Repo: [/vuejs-vn/vuejs.org](https://github.com/vuejs-vn/vuejs.org)
-* Primary maintainer - [phanan](https://github.com/phanan)
+## Contributors
-### Want to help with the translation?
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
-If you feel okay with translating sorta alone, you can fork the repo, create a "work-in-progress" issue to inform others that you're doing the translation, and go for it.
+
+
+
-If you are more of a team player, Translation Gang might be for you. Let us know somehow that you're ready to join this international open-source translators community. Feel free to contact [Grigoriy Beziuk](https://gbezyuk.github.io) or anybody else from [the team](https://github.com/orgs/translation-gang/people).
+
-And thank you in advance ;)
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
\ No newline at end of file
diff --git a/package.json b/package.json
index 030bfdfb41..e3640cc3fa 100644
--- a/package.json
+++ b/package.json
@@ -29,4 +29,4 @@
"hoek": "^6.1.2",
"request": "^2.85.0"
}
-}
+}
\ No newline at end of file
diff --git a/src/_posts/011-component.md b/src/_posts/011-component.md
index c95230e530..e3dc6ca049 100644
--- a/src/_posts/011-component.md
+++ b/src/_posts/011-component.md
@@ -1,61 +1,61 @@
----
-title: 0.11 Component Tips
-date: 2014-12-08 15:02:14
-tags:
----
-
-
Note: this post contains information for the outdated 0.11 version. Please refer to the [0.12 release notes](https://github.com/yyx990803/vue/releases) for the changes in the API.
-
-The release of 0.11 introduced [many changes](https://github.com/yyx990803/vue/blob/master/changes.md), but the most important one is how the new component scope works. Previously in 0.10.x, components have inherited scope by default. That means in a child component template you can reference parent scope properties. This often leads to tightly-coupled components, where a child component assumes knowledge of what properties are present in the parent scope. It is also possible to accidentally refer to a parent scope property in a child component.
-
-
-
-### Isolated Scope and Data Passing
-
-Starting in 0.11, all child components have isolated scope by default, and the recommended way to control component data access is via [Explicit Data Passing](/guide/components.html#Explicit_Data_Passing) using [`v-with`](/api/directives.html#v-with) or [`paramAttributes`](/api/options.html#paramAttributes).
-
-`paramAttributes` enables us to write Web Component style templates:
-
-``` js
-Vue.component('my-component', {
- paramAttributes: ['params'],
- compiled: function () {
- console.log(this.params) // passed from parent
- }
-})
-```
-
-``` html
-
-```
-
-### Where Does It Belong?
-
-Previously in 0.10, all directives on a component's container element are compiled in the child component's scope. Because it inherited parent scope, this worked in most situations. Starting in 0.11.1, we want to provide a cleaner separation between component scopes. The rule of thumbs is: if something appears in the parent template, it will be compiled in parent scope; if it appears in child template, it will be compiled in child scope. For example:
-
-``` html
-
-
-
{{parentMessage}}
-
-```
-
-``` html
-
-
-
{{childMessage}}
-
-
-```
-
-Everything in the parent template will be compiled in the parent's scope, including the content that's going to be inserted into the child component.
-
-The only exception to the rule is `v-with` (and `paramAttributes` which compiles down to `v-with`), which works in both places - so you don't need to worry about it too much.
-
-### Cleaner Event Communication
-
-Previously the standard way for a child component to communicate to its parent is via dispatching events. However, with this approach, the event listeners on the parent component are not guaranteed to be listening on the desired child component only. It's also possible to trigger undesired listeners further up the chain if we do not cancel the event.
-
-The most common use case is for a parent to react to the events from a specific, direct child component. So in 0.11.4, [a new directive `v-events`](/api/directives.html#v-events) has been introduced to enable exactly this behavior.
-
-0.11.4 has already been released, go try it out!
+---
+title: 0.11 Component Tips
+date: 2014-12-08 15:02:14
+tags:
+---
+
+
Note: post ini berisi informasi untuk versi lama 0.11. Silahkan lihat [0.12 release notes](https://github.com/yyx990803/vue/releases) untuk melihat perubahan pada API.
+
+Perilisan dari 0.11 memperkenalkan [banyak perubahan](https://github.com/yyx990803/vue/blob/master/changes.md), tapi yang paling penting adalah bagaimana cara ruang lingkup komponen baru bekerja. Sebelumnya di 0.10.x, komponen mempunyai ruang linkup yang diwariskan sebagai settingan awal. Itu berarti di sebuah template child komponen kalian bisa menghubungkan properti ruang lingkup parent. Ini biasanya berakhir pada komponen dengan hubungan erat, dimana child komponen mengira-ngira pengetahuan dari properti apa yang ada di ruang lingkup parent. Ada juga kemungkinan untuk properti ruang lingkup parent tidak sengaja merujuk di komponen child.
+
+
+
+### Isolasi Ruang Lingkup dan Pengiriman Data
+
+Dimulai di 0.11, semua komponen child punya ruang lingkup terisolasi sebagai settingan awal, dan cara yang disarankan untuk mengendalikan kompenen akses data adalah lewat [Pengiriman Data Jelas](/guide/components.html#Explicit_Data_Passing) menggunakan [`v-with`](/api/directives.html#v-with) atau [`paramAttributes`](/api/options.html#paramAttributes).
+
+`paramAttributes` memperbolehkan kita untuk menulis template komponen tampilan web:
+
+``` js
+Vue.component('my-component', {
+ paramAttributes: ['params'],
+ compiled: function () {
+ console.log(this.params) // diwariskan dari parent
+ }
+})
+```
+
+``` html
+
+```
+
+### Darimana Asalnya?
+
+Sebelumnya di 0.10, semua arahan pada elemen wadah komponen dikompilasi di komponen ruang lingkup child. Karena mewariskan ruang lingkup parent, hal ini sering bekerja di beberapa situasi. Dimulai di 0.11.1, kita ingin menyediakan pemisahan yang lebih rapi antara komponen ruang lingkup. Peraturan thumbs adalah: jika sesuatu muncul di template parent, itu akan dikompilasi di ruang lingkup parent; jika itu muncul di template child, itu akan dikompilasi di ruang lingkup child. Sebagai contoh:
+
+``` html
+
+
+
{{Pesanparent}}
+
+```
+
+``` html
+
+
+
{{Pesanchild}}
+
+
+```
+
+Segala hal yang ada di template parent akan dikompilasi di ruang lingkup parent, termasuk konten yang akan dimasukkan ke dalam komponen child.
+
+Satu-satunya pengecualian pada peraturannya adalah `v-with` (dan `paramAttributes` yang dikompilasi menjadi `v-with`), dimana bekerja di kedua tempat - jadi kalian tidak perlu terlalu mencemaskannya.
+
+### Komunikasi Event yang Lebih Rapi
+
+Sebelumnya cara standar untuk sebuah komponen child untuk berkomunikasi dengan parent adalah lewat event pelepasan. Namun, dengan cara ini, pendengar event di komponen parent tidak terjamin untuk hanya mendengarkan komponen child yang diinginkan. Dan juga berkemungkinan untuk memicu pendengar yang tidak diinginkan masuk lebih dalam jika kita tidak membatalkan the event.
+
+Kasus penggunaan yang paling umum adalah untuk parent bereaksi ke events dari sebuah spesifik, komponen child langsung. Jadi di 0.11.4, [arahan baru `v-events`](/api/directives.html#v-events) telah diperkenalkan untuk mengaktifkan perilaku ini.
+
+0.11.4 sudah rilis, cobalah!
diff --git a/src/_posts/012-release.md b/src/_posts/012-release.md
index ea002a9688..da623f5a82 100644
--- a/src/_posts/012-release.md
+++ b/src/_posts/012-release.md
@@ -3,88 +3,88 @@ title: Vue.js 0.12 released!
date: 2015-06-11 17:37:30
---
-I'm really excited to announce that [Vue.js 0.12: Dragon Ball](https://github.com/yyx990803/vue/releases/tag/0.12.0) is finally here! Thanks to everyone who tried out the beta/rc versions and provided feedback / bug reports along the way.
+Saya sangat bersemangat untuk mengumumkan bahwa [Vue.js 0.12: Dragon Ball](https://github.com/yyx990803/vue/releases/tag/0.12.0) akhirnya selesai. Terima kasih kepada seluruh pihak yang telah mencoba versi beta/rc dan memberikan feedback / laporan bug selama penggunaan.
-There's a lot to cover in this release, and we will talk about a few highlights below. However, it is still recommended to carefully go through the [Full Release Note](https://github.com/yyx990803/vue/releases/tag/0.12.0) and updated docs if you are upgrading from 0.11. You can report bugs on GitHub, send questions to [vuejs/Discussion](https://github.com/vuejs/Discussion/issues), or join us in the [Gitter chat channel](https://gitter.im/yyx990803/vue).
+Ada banyak hal yang harus dibahas pada perilisan ini, dan kami akan berbicara tentang bebrapa hal-hal yang penting dibawah ini. Namun, alangkah baiknya untuk tetap mengikuti [Catatan Rilis Lengkap](https://github.com/yyx990803/vue/releases/tag/0.12.0) dan perbarui dokumen jika kamu meningkatkan dari 0.11. Kamu dapat melaporkan bug di Github, mengirim pertanyaan ke [vuejs/Discussion](https://github.com/vuejs/Discussion/issues), atau bergabung dengan kami di [Gitter chat channel](https://gitter.im/yyx990803/vue).
-### More Consistent Component Syntax
+### Komponen Sintaks Lebih Konsisten
-Previously in 0.11 you have two ways to use a Vue.js component: using the `v-component` directive, or using custom elements. There are also two ways to pass data down to child components: using the `v-with` directive, or using the `paramAttributes` option. Although both custom elements and param attributes get compiled down to directives eventually, it is confusing and redundant to have two sets of syntax for the same functionality.
+Sebelumnya di 0.11 Anda memiliki dua cara untuk menggunakan komponen Vue.js: menggunakan `v-component` secara langsung, atau menggunakan elemen khusus. Terdapat juga dua cara untuk meneruskan data ke komponen child: menggunakan `v-with` secara langsung, atau menggunakan opsi `paramAttributes`. Meskipun kedua elemen khusus dan atribut parameter dapat dikomplikasi, itu membingungkan dan berlebihan untuk memiliki dua set sintaks untuk fungsi yang sama.
-In addition, it should be noted that the component system is a first-class concept in Vue.js, even more important than directives. It defines how we encapsulate our higher-level view logic and compose our application. In the meanwhile, having a clear and declarative way to pass data into child components is also very important. Components and param attributes really deserve their own dedicated syntax to differentiate from other directives.
+Selain itu, perlu dicatat bahwa sistem komponen adalah konsep kelas pertama dalam Vue.js, bahkan lebih penting. Ini mendefinisikan bagaimana kita merangkum logika tampilan tingkat yang lebih tinggi dan menyusun aplikasi kita. Sementara itu, memiliki cara yang jelas dan deklaratif untuk meneruskan data ke dalam komponen tururnan itu juga sangat penting. Komponen dan atribut parameter memilik sintaksis khusus mereka sendiri untuk membedakannya dari yang lainnya.
-As a result, `v-component` and `v-with` have been deprecated in 0.12. `paramAttributes` has also been renamed to `props`, which is shorter and cleaner. From now on, most Vue.js components will look like this:
+Hasil dari, `v-component` dan `v-with` sudah tidak digunakan lagi di 0.12. `paramAttributes` juga diubah namanya menjadi `props`, yang lebih pendek dan lebih bersih. Mulai sekarang, kebanyakan komponen Vue.js akan terlihat seperti ini:
``` html
```
-There are also additional props-related improvements such as explicit one-time or one-way props, expression as props, methods as prop callbacks and more. You can find out more details in the 0.12 release notes linked above and the updated [Component System](/guide/components.html) section of the guide.
+Ada juga alat peraga tambahan terkait seperti alat peraga satu kali atau satu arah yang jelas, ekspresi sebagai alat peraga, metode sebagai callback prop dan lebih banyak lagi. Anda dapat mengetahui lebih detail di catatan rilis 0.12 terkait di atas dan perbaruan [Sistem Komponen](/guide/components.html) pada panduan ini.
-### Filter Arguments Improvements
+### Filter Perbaikan Argumen
-In 0.11, filters always receive their arguments as plain strings. An argument can be enclosed in quotes to include whitespace, but the quotes are not automatically stripped when passed into the filter function. Some users were also confused about how to retrieve a dynamic value on the vm instead of a plain string.
+Di 0,11, filter selalu menerima argumen mereka sebagai string biasa. Argumen dapat diapit dalam tAnda kutip untuk menyertakan spasi putih, tetapi tAnda kutip tidak secara otomatis dihapus ketika diteruskan ke fungsi filter. Beberapa pengguna juga bingung tentang cara mengambil nilai dinamis pada vm bukan string biasa.
-In 0.12, the filter argument syntax now follows a simple rule: if an argument is enclosed in quotes, it will be passed in as a plain string; otherwise, it will be evaluated against the current vm as a dynamic value.
+Dalam 0,12, sintaks argumen filter mengikuti aturan sederhana: jika argumen diapit oleh tAnda kutip, maka akan dilewatkan sebagai string biasa; jika tidak, ini akan dievaluasi terhadap vm saat ini sebagai nilai dinamis.
-This means the usage of some existing filters will have to change:
+Ini berarti penggunaan beberapa filter yang ada harus berubah:
``` html
{{ items.length | pluralize 'item' }}
```
-But it would make custom filters that rely on dynamic values much easier to write:
+Tapi itu akan membuat filter khusus yang bergantung pada nilai dinamis jauh lebih mudah untuk ditulis:
``` html
{{ msg | concat otherMsg }}
```
-Here the first argument to the `concat` filter will be the value of `this.otherMsg`.
+Disini argumen pertama ke filter `concat` akan menjadi nilai dari `this.otherMsg`.
-### Asynchronous Components
+### Komponen Asinkron
-It is common practice to bundle all the JavaScript into one file when building large single page applications. But when the file becomes too large, we may want to defer loading parts of our application for a faster initial load. However, this does pose some constraints on how the application architecture should be designed. It could be very tricky to figure out how to properly split up your JavaScript bundles.
+Ini adalah praktik khusus untuk menggabungkan seluruh JavaScript kedalam satu file ketika membangun aplikasi satu halaman besar. Tetapi ketika file terlalu besar, kami mungkin ingin menunda memuat bagian dari aplikasi kami untuk beban awal yang lebih cepat. Namun, ini memang menimbulkan beberapa kendala tentang bagaimana arsitektur aplikasi harus dirancang. Itu bisa sangat rumit untuk mencari tahu bagaimana cara yang benar untuk memecah kumpulan JavaScript Anda.
-Well, with Vue.js we can already build our applications as decoupled components. If we can lazily load a dynamic component only when it is needed, wouldn't it be awesome? As a matter of fact, in 0.12 this would be trivially easy with the new Asynchronous Component feature.
+Baik, dengan Vue.js kita sudah dapat membangun aplikasi kita sebagai komponen yang dipisahkan. Jika kita dapat dengan malas memuat komponen dinamis hanya ketika itu dibutuhkan, bukankah itu sangat mengesankan? Faktanya, di 0.12 ini akan sangat mudah dengan adanya fitur komponen asinkron yang baru.
-In 0.12, you can define a component as a factory function that asynchronously resolves a component definition (can be just a plain options object). Vue.js will only trigger the factory function when the component actually needs to be rendered, and will cache the result for future re-renders:
+Di 0.12, Anda dapat mendefinisikan sebuah komponen sebagai you can define a component as a fungsi pabrik yang secara asinkron menyelesaikan definisi komponen (hanya bisa menjadi objek pilihan biasa). Vue.js hanya akan memicu fungsi pabrik ketika komponen tersebut sebenarnya perlu diberikan, dan akan menyimpan hasilnya untuk render selanjutnya:
``` js
-Vue.component('async-example', function (resolve, reject) {
+Vue.component('contoh-asinkron', function (resolve, reject) {
setTimeout(function () {
resolve({
- template: '
I am async!
'
+ template: '
Aku asinkron!
'
})
}, 1000)
})
```
-It is up to you to decide how to load the component from the server, e.g. `$.getScript()` or require.js; but the recommended usage is to pair it up with Webpack's [Code Splitting feature](http://webpack.github.io/docs/code-splitting.html):
+Terserah Anda untuk memutuskan bagaimana memuat komponen dari server, misalnya menggunakan `$.getScript()` atau require.js; tetapi penggunaan yang disarankan adalah mengunakan Webpack [Fitur Pembatas Kode](http://webpack.github.io/docs/code-splitting.html):
``` js
-Vue.component('async-webpack-example', function (resolve, reject) {
- // In Webpack AMD like syntax indicates a code split point
- require(['./my-async-component'], resolve)
+Vue.component('contoh-asinkron-webpack', function (resolve, reject) {
+ // Di Webpack AMD (Asynchronous Module Definition) seperti sintaks menunjukkan titik perpecahan kode
+ require(['./komponen-asinkron'], resolve)
})
```
-That's all you need to do. You can use the component just like before, without even thinking about it being async. Webpack will automatically split your final JavaScript into separate bundles with correct dependencies, and automatically load a bundle via Ajax when it is required. You can check out a fully functional example [here](https://github.com/vuejs/vue-webpack-example).
+Itu semua hal yang Anda harus lakukan. Anda dapat menggunakan komonen tersebut seperti sebelumnya, tanpa perlu memikirkan tentang asinkron komponen tersebut. Webpack akan secara otomatis memecah kode akhir JavaScript Anda kedalam berkas terpisah dengan keadaan yang benar, dan otomatis memuat berkas melalui Ajax ketika itu dibutuhkan.Anda dapat melihat contoh yang berfungsi penuh [di sini](https://github.com/vuejs/vue-webpack-example).
-### Improved Transition System
+### Sistem Transisi Yang Lebih Baik
-Vue.js' transition system is really easy to use, but in the past it has the limitation that you cannot mix CSS and JavaScript-based transitions together. In 0.12 that is no longer the case! The improved transition system now allows you to add JavaScript hooks to a CSS-based transition for additional control. The amount of hooks exposed have also been expanded to give you finer-grained control at every stage of the transition.
+ Sistem transisi Vue.js' sangat mudah untuk digunakan, tetapi diakhir itu memiliki batasan bahwa Anda tidak bisa menggabungkan transisi CSS dan berbasis JavaScript bersamaan. Di 0.12 itu bukan lagi masalah! Sistem transisi yang ditingkatkan sekarang memungkinkan Anda menambahkan pengait (hook) JavaScript ke transisi berbasis CSS untuk kontrol tambahan. Jumlah kait (hook) yang terpapar juga telah diperluas untuk memberi Anda kontrol yang lebih halus pada setiap tahap transisi.
-`v-repeat` now also ships with built-in support for staggering transitions. It is as simple as adding `stagger="100"` to your repeated element. It is also possible to define separate staggering for enter and leaving, or even dynamically calculate the staggering delay in a JavaScript hook.
+`v-repeat` sekarang juga didukung dengan dukungan built-in untuk transisi yang membingungkan. Ini semudah menambahkan `stagger="100"` ke elemen berulang Anda. Hal ini juga memungkinkan untuk menentukan keterpisahan untuk masuk dan keluar, atau bahkan secara dinamis menghitung penundaan yang membingungkan dalam pengait (hook) JavaScript.
-For full details on the new transition system, check out the [updated guide](/guide/transitions.html).
+Untuk perincian lengkap tentang sistem transisi baru, lihat [panduan terbaru](/guide/transitions.html).
-### Performance Tuning
+### Penyetelan Kinerja
-Vue.js' precise dependency tracking makes it the one of the most efficient view layer for small hot updates, but there's always room for improvement. In 0.12, internal instance creation and compilation refactors have improved first-render performance for large lists by up to 40%. With proper `track-by` usage, [re-rendering with large, brand new dataset](http://vuejs.github.io/js-repaint-perfs/vue/) is also comparable to, or even faster than other Virtual-DOM based frameworks.
+Pelacakan ketergantungan tepat Vue.js membuatnya menjadi salah satu lapisan tampilan paling efisien untuk pembaruan kecil, tetapi selalu ada ruang untuk perbaikan. Di 0.12, kreasi instance internal dan refactor kompilasi telah meningkatkan performa render pertama untuk daftar besar hingga 40%. Dengan penggunaan `track-by` yang tepat, [render ulang dengan kumpulan data baru yang besar](http://vuejs.github.io/js-repaint-perfs/vue/) juga sebanding dengan, atau bahkan lebih cepat daripada kerangka kerja berbasis-Virtual-DOM lainnya.
-### One More Thing...
+### Satu Hal Lagi...
-With 0.12 out of the door, more efforts will now be spent on the official vue-router, a dedicated routing library for Vue.js with nested view matching, full transition support, and asynchronous data hooks. I have expressed that Vue.js core intends to stay as a no-frills, drop-in view layer library, and that will not change. The vue-router will be shipped separately and is totally optional, however you can expect it to work seamlessly with Vue.js core when you need it.
+Dengan dirilisnya 0.12, lebih banyak upaya sekarang akan dihabiskan pada vue-router resmi, pustaka routing khusus untuk Vue.js dengan menyesuaikan tampilan berlapis, dukungan transisi penuh, dan kait (hook) data asinkron. Saya telah menyatakan bahwa inti Vue.js bermaksud untuk tetap sesuai dengan kebutuhan, pustaka lapisan tampilan drop-in, dan itu tidak akan berubah. Vue-router akan dikirim secara terpisah dan benar-benar opsional, namun Anda dapat mengharapkannya bekerja secara lancar dengan inti Vue.js saat Anda membutuhkannya.
diff --git a/src/_posts/1.0.0-release.md b/src/_posts/1.0.0-release.md
index 106f2d3f02..482d68d50d 100644
--- a/src/_posts/1.0.0-release.md
+++ b/src/_posts/1.0.0-release.md
@@ -1,64 +1,64 @@
----
-title: Vue.js 1.0.0 Released
-date: 2015-10-26 10:00:00
----
-
-> Hi HN! If you are not familiar with Vue.js, you might want to read this [blog post](http://blog.evanyou.me/2015/10/25/vuejs-re-introduction/) for a higher level overview.
-
-After 300+ commits, 8 alphas, 4 betas and 2 release candidates, today I am very proud to announce the release of [Vue.js 1.0.0 Evangelion](https://github.com/vuejs/vue/releases/tag/1.0.0)! Many thanks to all those who participated in the API re-design process - it would not have been possible without all the input from the community.
-
-
-
-### Improved Template Syntax
-
-The 1.0 template syntax resolves a lot of subtle consistency issues and makes Vue templates more concise and more readable in general. The most notable new feature is the shorthand syntax for `v-on` and `v-bind`:
-
-``` html
-
-
-
-
-
-```
-
-When used on a child component, `v-on` listens for custom events and `v-bind` can be used to bind props. The shorthands using child components very succinct:
-
-``` html
-
-
-```
-
-### API Cleanup
-
-The overall goal for Vue.js 1.0 is to make it suitable for larger projects. This is why there are many API deprecations. Except for ones that are barely used, the most common reason for a deprecation is that the feature leads to patterns that damages maintainability. Specifically, we are deprecating features that make it hard to maintain and refactor a component in isolation without affecting the rest of the project.
-
-For example, the default asset resolution in 0.12 has implicit fallbacks to parents in the component tree. This makes the assets available to a component non-deterministic and subject how it is used at runtime. In 1.0, all assets are now resolved in strict mode and there are no longer implicit fallbacks to parent. The `inherit` option is also removed, because it too often leads to tightly coupled components that are hard to refactor.
-
-### Faster Initial Rendering
-
-1.0 replaces the old `v-repeat` directive with `v-for`. In addition to providing the same functionality and more intuitive scoping, `v-for` provides up to **100%** initial render performance boost when rendering large lists and tables!
-
-### More Powerful Tooling
-
-There are also exciting things going on outside of Vue.js core - [vue-loader](https://github.com/vuejs/vue-loader) and [vueify](https://github.com/vuejs/vueify) have received major upgrades including:
-
-- Hot component reloading. When a `*.vue` component is edited, all of its active instances are hot swapped without reloading the page. This means when making small changes, e.g. tweaking the styles or the template, your app doesn't need to fully reload; the state of the app the swapped component can be preserved, drastically improving the development experience.
-
-- Scoped CSS. By simply adding a `scoped` attribute to your `*.vue` component style tags, the component's template and final generated CSS are magically re-written to ensure a component's styles are only applied to its own elements. Most importantly, the styles specified in a parent component **does not** leak down to child components nested within it.
-
-- ES2015 by default. JavaScript is evolving. You can write much cleaner and expressive code using the latest syntax. `vue-loader` and `vueify` now transpiles the JavaScript in your `*.vue` components out of the box, without the need for extra setup. Write future JavaScript today!
-
-Combined with [vue-router](https://github.com/vuejs/vue-router), Vue.js is now more than a library - it provides a solid foundation for building complex SPAs.
-
-### What's Next?
-
-As what 1.0.0 usually suggests, the core API will stay stable for the foreseeable future and the library is ready for production use. Future development will focus on:
-
-1. Improving `vue-router` and make it production ready.
-
-2. Streamlining the developer experience, e.g. a better devtool and a CLI for scaffolding Vue.js projects and components.
-
-3. Providing more learning resources such as tutorials and examples.
+---
+title: Vue.js 1.0.0 Released
+date: 2015-10-26 10:00:00
+---
+
+> Hi HN! Jika kau tidak terbiasa dengan Vue.js, kau mungkin ingin untuk membaca [post blog](http://blog.evanyou.me/2015/10/25/vuejs-re-introduction/) untuk tingkatreview yang lebih tinggi.
+
+Setelah 300+ commits, 8 alphas, 4 betas dan 2 kandidat perilisan, hari ini saya sangat bangga untuk mengumumkan perilisan dari [Vue.js 1.0.0 Evangelion](https://github.com/vuejs/vue/releases/tag/1.0.0)! Banyak terima kasih untuk semua yang berpatisipasi pada proses design ulang API - hal ini tidak akan mungkin terjadi tanpa semua input dari komunitas.
+
+
+
+### Template Syntax yang Lebih Baik
+
+Template syntax 1.0 memperbaiki banyak isu konsistensi dan membuat template Vue lebih concise dan lebih dapat dibaca pada umumnya. Fitur baru yang paling terlihat adalah syntax singkatan untuk `v-on` dan `v-bind`:
+
+``` html
+
+
+
+
+
+```
+
+Saat digunakan pada komponen child, `v-on` mendengar untuk event buatan sendiri dan `v-bind` dapat digunakan untuk mengikat properti. Penggunaan singkatan pada komponen child sangatlah ketat:
+
+``` html
+
+
+```
+
+### Pembersihan API
+
+Tujuan keseluruhan dari Vue.js 1.0 adalah untuk membuatnya cocok dengan projek yang lebih besar. Karena itulah banyak pembatalan API. Kecuali untuk API yang jarang digunakan, Alasan paling umum untuk pembatalan API adalah fitur-fiturnya yang menuntun ke pola kerusakan pada proses pemeliharaan. Khususnya, kita membatalkan fitur yang membuat API susah untuk di pelihara dan refactor sebuah komponen isolasi tanpa mempengaruhi isi lain dari proyeknya.
+
+Sebagai contohnya, Resolusi kegunaan awal pada 0.12 mempunyai reaksi negatif ke parent pada pohon komponen. Hal ini membuat aset-aset dapat digunakan pada komponen yang bersifat tidak deterministik dan bagaimana subjek digunakan saat runtime. Di 1.0, semua aset sekarang diselesaikan pada mode ketat dan sudah tidak ada lagi reaksi negatif ke parent. Opsi `inherit` juga dihapus, karena sering menuntun ke komponen yang berhubungan erat yang susah untuk di refactor.
+
+### Render Awal Lebih Cepat
+
+1.0 mengganti `v-repeat` lama searah dengan `v-for`. Sebagai bonus untuk menyediakan fungsi yang sama dan ruang lingkup yang lebih intuitif, `v-for` menyediakan sampai dengan **100%** peningkatan performa render awal saat merender daftar yang besar dan tabel!
+
+### Alat yang Lebih Kuat
+
+Ada juga hal-hal menarik yang terjadi di luar Vue.js core - [vue-loader](https://github.com/vuejs/vue-loader) dan [vueify](https://github.com/vuejs/vueify) telah menerima peningkatan utama yang termasuk:
+
+- Memuat ulang komponen panas. Disaat komponen `*.vue` diedit, semua instansi aktif yang panas bertukar tanpa memuat ulang halaman. Hal ini berarti saat membuat perubahan kecil, atau mengutak-atik style atau template, aplikasimu tidak perlu sepenuhnya dimuat ulang; keadaan komponen aplikasi yang ditukar dapat dipertahankan, meningkatkan pengalaman pengembangan secara drastis.
+
+- Ruang lingkup CSS. Cukup dengan menambahkan sifat `scoped` ke tag komponen style`*.vue`mu, komponen template dan hasil akhir CSS secara ajaib ditulis ulang untuk memastikan komponen style hanya di terapkan di elemennya sendiri. Yang paling penting, style khusus di komponen parent **tidak** turun ke komponen child yang nested di dalamnya.
+
+- ES2015 secara settingan awal. JavaScript sedang berevolusi. Kau bisa menulis kode yang lebih rapi dan ekspresif menggunakan syntax terbaru. `vue-loader` dan `vueify` sekarang mentranspile JavaScript di `*.vue` mu, komponen di luar kotak, tanpa dibutuhkannya pengaturan ekstra. Tulislah masa depan JavaScript hari ini!
+
+Digabung dengan [vue-router](https://github.com/vuejs/vue-router), Vue.js sekarang lebih dari sekadar library - ia menyediakan pondasi kuat untuk membangun SPAs rumit.
+
+### Apa Selanjutnya?
+
+Seperti 1.0.0 biasanya menyarankan, inti API akan tetap stabil untuk masa-masa mendatang dan librarynya telah siap untuk penggunaan produksi. Perkembangan kedepan akan fokus pada:
+
+1. Mengembangkan `vue-router` dan membuatnya siap produksi.
+
+2. Memperlancar pengalaman developer, misalnya alat pengembangan yang lebih baik dan CLI untuk Perancangan projek dan komponen Vue.js.
+
+3. Menyediakan lebih banyak sumber pembelajaran seperti tutorial dan contoh-contoh.
diff --git a/src/_posts/announcing-2.0.md b/src/_posts/announcing-2.0.md
index dbb956155c..d5ee42101c 100644
--- a/src/_posts/announcing-2.0.md
+++ b/src/_posts/announcing-2.0.md
@@ -3,52 +3,52 @@ title: Announcing Vue.js 2.0
date: 2016-04-27 13:33:00
---
-Today I am thrilled to announce the first public preview of Vue.js 2.0, which brings along many exciting improvements and new features. Let's take a peek at what's in store!
+Hari ini saya senang mengumumkan preview publik pertama dari Vue.js 2.0, yang membawa banyak perbaikan menarik dan fitur baru. Mari kita intip apa yang ada di toko!
## Even Leaner, Even Faster
-Vue.js has always focused on staying light and fast, but 2.0 pushes it even further. The rendering layer is now based on a lightweight virtual-DOM implementation (based on [Snabbdom](https://github.com/paldepind/snabbdom)) that improves initial rendering speed and memory consumption by up to 2~4x in most scenarios (check out [these benchmarks](https://github.com/vuejs/vue/tree/next/benchmarks)). The template-to-virtual-DOM compiler and the runtime can be separated, so you can pre-compile templates and ship your app with only the runtime, which is less than 12KB min+gzip (as a reference, React 15 is 44KB min+gzip). The compiler also works in the browser, which means you can still drop in one script tag and start hacking, just like before. Even with the compiler included, the build is sitting at 17KB min+gzip, still lighter than the current 1.0 build.
+Vue.js selalu fokus untuk tetap ringan dan cepat, tetapi 2.0 mendorongnya lebih jauh. Lapisan rendering sekarang didasarkan pada implementasi DOM virtual-ringan (berdasarkan [Snabbdom] (https://github.com/paldepind/snabbdom)) yang meningkatkan kecepatan rendering awal dan konsumsi memori hingga 2 ~ 4x dalam sebagian besar skenario (lihat [tolak ukur ini] (https://github.com/vuejs/vue/tree/next/benchmark)). Kompiler template-to-virtual-DOM dan runtime dapat dipisahkan, sehingga Anda dapat melakukan pra-kompilasi template dan mengirimkan aplikasi Anda hanya dengan runtime, yang kurang dari 12KB min + gzip (sebagai referensi, Bereaksi 15 adalah 44KB min + gzip). Kompiler juga berfungsi di browser, yang berarti Anda masih dapat memasukkan satu tag skrip dan mulai meretas, seperti sebelumnya. Bahkan dengan kompiler yang disertakan, build berada di 17KB min + gzip, masih lebih ringan dari versi 1.0 saat ini.
## Not Your Average Virtual-DOM
-Now, just virtual-DOM sounds boring because there are so many implementations out there - but this one is different. Combined with Vue's reactivity system, it provides optimized re-rendering out of the box without you having to do anything. Each component keeps track of its reactive dependencies during its render, so the system knows precisely when to re-render, and which components to re-render. No need for `shouldComponentUpdate` or immutable data structures - **it just works**.
+Sekarang, hanya virtual-DOM yang terdengar membosankan karena ada begitu banyak implementasi di luar sana - tetapi yang ini berbeda. Dikombinasikan dengan sistem reaktivitas Vue, Vue memberikan proses rendering ulang yang dioptimalkan tanpa Anda harus melakukan apa pun. Setiap komponen melacak dependensi reaktif selama render, sehingga sistem tahu persis kapan harus merender ulang, dan komponen mana yang akan dirender ulang. Tidak perlu untuk `shouldComponentUpdate` atau struktur data yang tidak dapat diubah - ** itu hanya berfungsi **.
-In addition, Vue 2.0 applies some advanced optimizations during the template-to-virtual-DOM compilation phase:
+Selain itu, Vue 2.0 menerapkan beberapa optimasi lanjutan selama fase kompilasi template-to-virtual-DOM:
-1. It detects static class names and attributes so that they are never diffed after the initial render.
+1. Mendeteksi nama dan atribut kelas statis sehingga tidak pernah berbeda setelah render di awal.
-2. It detects the maximum static sub trees (sub trees with no dynamic bindings) and hoist them out of the render function. So on each re-render, it directly reuses the exact same virtual nodes and skips the diffing.
+2. Mendeteksi sub trees statis maksimum (sub trees tanpa ikatan dinamis) dan mengeluarkannya dari fungsi render. Jadi pada setiap re-render, secara langsung menggunakan kembali node virtual yang sama persis dan melewatkan diffing.
-These advanced optimizations can usually only be achieved via Babel plugins when using JSX, but with Vue 2.0 you can get them even using the in-browser compiler.
+Optimalisasi lanjutan ini biasanya hanya dapat dicapai melalui plugin Babel saat menggunakan JSX, tetapi dengan Vue 2.0 Anda bisa mendapatkannya bahkan menggunakan kompiler dalam browser.
-The new rendering system also allows you to disable reactive conversions by simply freezing your data and manually force updates, essentially giving you full control over the re-rendering process.
+Sistem rendering baru juga memungkinkan Anda untuk menonaktifkan konversi reaktif hanya dengan membekukan data Anda dan secara manual memaksa pembaruan, pada dasarnya memberi Anda kontrol penuh atas proses rendering ulang.
-With these techniques combined, Vue 2.0 ensures blazing fast performance in every possible scenario while requiring minimal optimization efforts from the developer.
+Dengan teknik-teknik ini digabungkan, Vue 2.0 memastikan kinerja yang sangat cepat dalam setiap skenario yang mungkin sambil memerlukan upaya optimasi minimal dari pengembang.
## Templates, JSX, or Hyperscript?
-Developers tend to have strong opinions on templates vs. JSX. On the one hand, templates are closer to HTML - they map better to the semantic structure of your app and make it much easier to think visually about the design, layout and styling. On the other hand, templates are limited to the DSL while the programmatic nature of JSX/hyperscript provides the full expressive power of a turing-complete language.
+Pengembang cenderung memiliki pendapat yang kuat tentang template vs JSX. Di satu sisi, templat lebih dekat ke HTML - templat lebih baik pada struktur semantik aplikasi Anda dan membuatnya lebih mudah untuk berpikir secara visual tentang desain, tata letak, dan gaya. Di sisi lain, template terbatas pada DSL sementara sifat program JSX / hyperscript memberikan kekuatan ekspresif penuh dari bahasa turing-complete.
-Being a designer/developer hybrid, I prefer writing most of my interfaces in templates, but in certain cases I do miss the flexibility of JSX/hyperscript. An example would be writing a component that programmatically handles its children, something not feasible with just the template-based slot mechanism.
+Menjadi hibrida desainer / pengembang, saya lebih suka menulis sebagian besar antarmuka saya di templat, tetapi dalam kasus tertentu saya kehilangan fleksibilitas JSX / hyperscript. Contohnya adalah menulis komponen yang secara terprogram menangani anak-anaknya, sesuatu yang tidak layak hanya dengan mekanisme slot berbasis template.
-Well, why not have both? In Vue 2.0, you can keep using the familiar template syntax, or drop down to the virtual-DOM layer whenever you feel constrained by the template DSL. Instead of the `template` option, just replace it with a `render` function. You can even embed render functions in your templates using the special `` tag! The best of both worlds, in the same framework.
+Nah, mengapa tidak memiliki keduanya? Dalam Vue 2.0, Anda dapat terus menggunakan sintaks template yang sudah dikenal, atau drop-down ke lapisan virtual-DOM setiap kali Anda merasa terkendala oleh template DSL. Alih-alih opsi `template`, ganti saja dengan fungsi` render`. Anda bahkan dapat menanamkan fungsi render dalam templat Anda menggunakan tag `` khusus! Yang terbaik dari kedua dunia, dalam kerangka yang sama.
## Streaming Server-side Rendering
-With the migration to virtual-DOM, Vue 2.0 naturally supports server-side rendering with client-side hydration. One pain point of current mainstream server rendering implementations, such as React's, is that the rendering is synchronous so it can block the server's event loop if the app is complex. Synchronous server-side rendering may even adversely affect time-to-content on the client. Vue 2.0 provides built-in streaming server-side rendering, so that you can render your component, get a readable stream back and directly pipe it to the HTTP response. This ensures your server is responsive, and gets the rendered content to your users faster.
+Dengan migrasi ke virtual-DOM, Vue 2.0 secara alami mendukung rendering sisi server dengan hidrasi sisi klien. Salah satu titik sakit dari implementasi render server utama saat ini, seperti React's, adalah renderingnya sinkron sehingga dapat memblokir loop acara server jika aplikasinya kompleks. Render sisi server yang sinkron bahkan dapat mempengaruhi waktu-ke-konten pada klien. Vue 2.0 menyediakan rendering sisi server streaming internal, sehingga Anda dapat merender komponen Anda, mendapatkan aliran yang dapat dibaca kembali dan langsung menyalurkannya ke respons HTTP. Ini memastikan server Anda responsif, dan membuat konten yang diberikan kepada pengguna Anda lebih cepat.
## Unlocking More Possibilities
-With the new architecture, there are even more possibilities to explore - for example, rendering to native interfaces on mobile. Currently, we are exploring a port of Vue.js 2.0 that uses [weex](http://alibaba.github.io/weex/) as a native rendering backend, a project maintained by engineers at Alibaba Group, the biggest tech enterprise of China. It is also technically feasible to adapt Vue 2.0's virtual-DOM to run inside ReactNative. We are excited to see how it goes!
+Dengan arsitektur baru, bahkan ada lebih banyak kemungkinan untuk dijelajahi - misalnya, rendering ke antarmuka asli di seluler. Saat ini, kami sedang mengeksplorasi port Vue.js 2.0 yang menggunakan [weex] (http://alibaba.github.io/weex/) sebagai backend rendering asli, sebuah proyek yang dikelola oleh para insinyur di Alibaba Group, perusahaan teknologi terbesar dari Cina. Secara teknis juga memungkinkan untuk mengadaptasi virtual-DOM Vue 2.0 untuk dijalankan di dalam ReactNative. Kami sangat senang melihat hasilnya!
## Compatibility and What to Expect Next
-Vue.js 2.0 is still in pre-alpha, but you can checkout the source code [here](https://github.com/vuejs/vue/tree/next/). Despite being a full rewrite, the API is largely compatible with 1.0 with the exception of some intentional deprecations. Check out [the same official examples written in 2.0](https://github.com/vuejs/vue/tree/next/examples) - you will see that not much has changed!
+Vue.js 2.0 masih dalam pra-alfa, tetapi Anda dapat checkout kode sumber [di sini] (https://github.com/vuejs/vue/tree/next/). Meskipun menjadi penulisan ulang penuh, API sebagian besar kompatibel dengan 1.0 dengan pengecualian beberapa penghentian yang disengaja. Lihat [contoh resmi yang sama yang ditulis dalam 2.0] (https://github.com/vuejs/vue/tree/next/examples) - Anda akan melihat bahwa tidak banyak yang berubah!
-The feature deprecations are part of our continued effort to provide the simplest API possible for maximum developer productivity. You can check out a 1.0 vs. 2.0 feature comparison [here](https://github.com/vuejs/vue/wiki/2.0-features). This does mean that it will take some effort to migrate an existing app if you happen to use some of these deprecated features heavily, but we will provide detailed upgrade guides in the future.
+Penghentian fitur adalah bagian dari upaya berkelanjutan kami untuk menyediakan API sesederhana mungkin untuk produktivitas pengembang maksimum. Anda dapat memeriksa perbandingan fitur 1.0 vs. 2.0 [di sini] (https://github.com/vuejs/vue/wiki/2.0-features). Ini berarti perlu upaya untuk memigrasikan aplikasi yang ada jika Anda sering menggunakan beberapa fitur yang sudah usang ini, tetapi kami akan memberikan panduan pemutakhiran terperinci di masa mendatang.
-There is still much work left to be done. We will be releasing the first alpha once we reach satisfactory test coverage, and we are aiming for beta by end of May / early June. In addition to more tests, we also need to update the supporting libraries (vue-router, Vuex, vue-loader, vueify...). Currently only Vuex works with 2.0 out of the box, but we will make sure that everything works smoothly together when 2.0 ships.
+Masih banyak pekerjaan yang harus dilakukan. Kami akan merilis alpha pertama setelah kami mencapai cakupan tes yang memuaskan, dan kami menargetkan beta pada akhir Mei / awal Juni. Selain lebih banyak tes, kami juga perlu memperbarui perpustakaan pendukung (vue-router, Vuex, vue-loader, vueify ...). Saat ini hanya Vuex bekerja dengan 2.0 di luar kotak, tetapi kami akan memastikan bahwa semuanya bekerja dengan lancar saat 2.0 dikirimkan.
-We are also not forgetting about 1.x! 1.1 will be released alongside 2.0 beta, with an LTS period of 6-month critical bug fixes and 9-month security updates. It will also ship with optional deprecation warnings to get you prepared for upgrading to 2.0. Stay tuned!
+Kami juga tidak melupakan tentang 1.x! 1.1 akan dirilis bersamaan dengan 2.0 beta, dengan periode LTS perbaikan bug kritis 6 bulan dan pembaruan keamanan 9 bulan. Ini juga akan dikirimkan dengan peringatan penghentian opsional untuk membuat Anda siap untuk meningkatkan ke 2.0. Tetap disini!
\ No newline at end of file
diff --git a/src/_posts/common-gotchas.md b/src/_posts/common-gotchas.md
index a8abf2314e..b31bacb225 100644
--- a/src/_posts/common-gotchas.md
+++ b/src/_posts/common-gotchas.md
@@ -1,38 +1,37 @@
---
-title: Common Beginner Gotchas
-date: 2016-02-06 10:00:00
+judul: Rintangan Umum Bagi Pemula
+tanggal: 2016-02-06 10:00:00
---
-There are few types of questions that we frequently see from users who are new to Vue.js. Although they are all mentioned somewhere in the guide, they are easy to miss and can be hard to find when you do get bitten by the gotchas. Therefore we are aggregating them in this post and hopefully it can save you some time!
-
+Ada beragam pertanyaan yang sering dijumpai oleh pengguna yang baru mengenal Vue.js. Sekalipun semua itu telah dijelaskan pada panduan, itu mudah terlewati dan menjadi sulit untuk dicari ketika anda sudah berhadapan dengan rintangan. Oleh karena itu kami mengumpulkan semuanya dalam pembahasan ini dan semoga dapat mempersingkat waktu anda.
-### Why isn't the DOM updating?
+### Kenapa DOM tidak berubah?
-Most of the time, when you change a Vue instance's data, the view updates. But there are two edge cases:
+Sebagian besar, ketika anda merubah data pada sebuah Vue instance, tampilan akan diperbaharui. Tetapi ada dua kasus berbeda:
-1. When you are **adding a new property** that wasn't present when the data was observed. Due to the limitation of ES5 and to ensure consistent behavior across browsers, Vue.js cannot detect property addition/deletions. The best practice is to always declare properties that need to be reactive upfront. In cases where you absolutely need to add or delete properties at runtime, use the global [`Vue.set`](/api/#Vue-set) or [`Vue.delete`](/api/#Vue-delete) methods.
+1. Saat anda **menambahkan properti baru** lalu tidak tersedia ketika data diamati. Disebabkan keterbatasan pada ES5 dan untuk memastikan agar perilaku konsisten disemua browser, Vue.js tidak dapat mendeteksi penambahan/penghapusan properti. Cara terbaik adalah selalu mendeklarasikan properti yang dibutuhkan agar reaktif diawal. Pada beberapa kejadian ketika benar-benar perlu menambah atau menghapus properti saat runtime, gunakan global method [`Vue.set`](/api/#Vue-set) atau [`Vue.delete`](/api/#Vue-delete).
-2. When you modify an Array by directly setting an index (e.g. `arr[0] = val`) or modifying its `length` property. Similarly, Vue.js cannot pickup these changes. Always modify arrays by using an Array instance method, or replacing it entirely. Vue provides a convenience method `arr.$set(index, value)` which is syntax sugar for `arr.splice(index, 1, value)`.
+2. Saat anda mengubah sebuah Array secara langsung menggunakan sebuah index (contoh `arr[0] = val`) atau mengubah dengan properti `length`. Demikian pula, Vue.js tidak akan melakukan perubahan. Selalu lakukan perubahan array menggunakan Array instance method, atau ganti seluruhnya. Vue menyediakan convenience method `arr.$set(index, value)` yang merupakan syntax sugar dari `arr.splice(index, 1, value)`.
-Further reading: [Reactivity in Depth](/guide/reactivity.html) and [Array Change Detection](http://vuejs.org/guide/list.html#Array-Change-Detection).
+Baca lebih lanjut: [Reactivity in Depth](/guide/reactivity.html) dan [Array Change Detection](http://vuejs.org/guide/list.html#Array-Change-Detection).
-### When is the DOM updated?
+### Kapan DOM diperbaharui?
-Vue.js uses an asynchronous queue to batch DOM updates. This means when you modify some data, the DOM updates do not happen instantly: they are applied asynchronously when the queue is flushed. So how do you know when the DOM has been updated? Use `Vue.nextTick` right after you modify the data. The callback function you pass to it will be called once the queue has been flushed.
+Vue.js menggunakan antrian asinkron untuk mengumpulkan perubahan DOM. Ini berarti saat anda memperbaharui beberapa data, Dom tidak diperbaharui secara langsung: mereka diterapkan secara tidak sinkron ketika antriannya diproses. Jadi, bagaimana anda tahu kapan DOM telah diperbaharui? Gunakan `Vue.nextTick` tepat setelah anda memperbaharui data. Callback function yang diberikan akan dipanggil sekali setelah antrian diproses.
-Further reading: [Async Update Queue](/guide/reactivity.html#Async-Update-Queue).
+Baca lebih lanjut: [Async Update Queue](/guide/reactivity.html#Async-Update-Queue).
-### Why does `data` need to be a function?
+### Kenapa `data` harus sebuah function?
-In the basic examples, we declare the `data` directly as a plain object. This is because we are creating only a single instance with `new Vue()`. However, when defining a **component**, `data` must be declared as a function that returns the initial data object. Why? Because there will be many instances created using the same definition. If we still use a plain object for `data`, that same object will be **shared by reference** across all instance created! By providing a `data` function, every time a new instance is created we can call it to return a fresh copy of the initial data.
+Dalam contoh dasar, kita mendeklarasikan `data` secara langsung sebagai sebuah plain objek. Ini dikarenakan kita hanya membuat sebuah instance tungal dengan `new Vue()`. Namun, ketika mendefinisikan sebuah **komponen**, `data` harus dideklarasikan sebagai sebuah function yang mengembalikan data objek awal. Kenapa? Karena akan banyak instance yang dibuat menggunakan definisi yang sama. Jika kita tetap menggunakan sebuah plain objek untuk `data`, itu objek sama yang akan menjadi **shared by reference** disemua instance yang dibuat! Dengan menyediakan sebuah `data` function, setiap kali sebuah instance baru dibuat kita dapat memanggilnya untuk mengembalikan salinan baru dari data awal.
-Further reading: [Component Option Caveats](/guide/components.html#Component-Option-Caveats).
+Baca lebih lanjut: [Component Option Caveats](/guide/components.html#Component-Option-Caveats).
### HTML case insensitivity
-All Vue.js templates are valid, parsable HTML markup, and Vue.js relies on spec-compliant parsers to process its templates. However, as specified in the standard, HTML is case-insensitive when matching tag and attribute names. This means camelCase attributes like `:myProp="123"` will be matched as `:myprop="123"`. As a rule of thumb, you should use camelCase in JavaScript and kebab-case in templates. For example a prop defined in JavaScript as `myProp` should be bound in templates as `:my-prop`.
+Semua templat Vue.js valid, HTML markup dapat diparse, dan Vue.js bergantung pada parser yang memenuhi spesifikasi untuk memproses templatnya. Namun, seperti yang telah ditentukan dalam standar, HTML case-insensitive ketika mencocokan tag dan nama attribut. Ini berarti attribut camelCase seperti `:myProp="123"` akan cocok dengan `:myprop="123"`. Sebagai aturan praktis, anda harus menggunakan camelCase di JavaScript dan kebab-case di templat. Sebagai contoh sebuah prop didefinisikan di JavaScript sebagai `myProp` dan dihubungkan di templat sebagai `:my-prop`.
-Further reading: [camelCase vs. kebab-case](http://vuejs.org/guide/components.html#camelCase-vs-kebab-case).
+Baca lebih lanjut: [camelCase vs. kebab-case](http://vuejs.org/guide/components.html#camelCase-vs-kebab-case).
-We are also discussing the possibility of eliminating this inconsistency by resolving props and components in a case-insensitive manner. Join the conversation [here](https://github.com/vuejs/vue/issues/2308).
+Kita juga mendiskusikan kemungkinan menghilangkan ketidakkonsistenan ini dengan memperbaiki props dan komponen dengan cara case-insensitive. Gabung dengan percakapannya [disini](https://github.com/vuejs/vue/issues/2308).
diff --git a/src/_posts/march-update.md b/src/_posts/march-update.md
index 1a8d0e7bb8..58f1371358 100644
--- a/src/_posts/march-update.md
+++ b/src/_posts/march-update.md
@@ -1,42 +1,42 @@
---
-title: March 2016 Update
-date: 2016-03-14 18:45:00
+judul: Pembaruan Maret 2016
+tanggal: 2016-03-14 18:45:00
---
-## Growing Community
+## Komunitas yang Terus Berkembang
-Vue's growth in the past year has been nothing short of amazing. As of today we are at over 15,000 stars on GitHub, over 500k downloads from npm, and over 2,000 users in the Gitter channel. What's more exciting though, is that the community successfully organized the first [London Vue.js Meetup](http://www.meetup.com/London-Vue-js-Meetup/) and the first [Paris Vue.js Meetup](http://www.meetup.com/Vuejs-Paris/?scroll=true)! A big shoutout to the awesome organizers: [Jack](https://twitter.com/JackBarham), [James](https://twitter.com/onejamesbrowne/) and [Eduardo](https://twitter.com/posva/).
+Pertumbuhan Vue dalam setahun terakhir sangat luar biasa. Sampai hari ini kami memiliki lebih dari 15.000 bintang di GitHub, lebih dari 500 ribu unduhan dari npm, dan lebih dari 2.000 pengguna di saluran Gitter. Yang lebih menarik adalah komunitas berhasil menyelenggarakan [Pertemuan Vue.js London Pertama](http://www.meetup.com/London-Vue-js-Meetup/) dan [Pertemuan Vue.js Paris Pertama](http://www.meetup.com/Vuejs-Paris/?scroll=true)! Sorakan yang menggema untuk penyelenggara yang luar biasa: [Jack](https://twitter.com/JackBarham), [James](https://twitter.com/onejamesbrowne/) dan [Eduardo](https://twitter.com/posva/).
-
+
-If you are interested in connecting with Vue.js users near you and share your experiences in using Vue.js, joining a local Meetup is a great idea - even better, maybe you can organize one :)
+Jika kamu tertarik untuk berinteraksi dengan pengguna Vue.js di dekat kamu dan berbagi pengalaman kamu dalam menggunakan Vue.js, bergabung dengan Pertemuan(_Meetup_) lokal adalah ide yang bagus - bahkan lebih baik lagi, mungkin kamu dapat mengadakan/ ikut mengaturnya :)
-## Cool Things Being Built
+## Karya Keren Yang Dikembangkan Dengan Vue
-More and more amazing things are being built with Vue. There are products like [PageKit](https://pagekit.com/), Laravel Spark (coming soon) and [Statamic](https://v2.statamic.com/), sleek apps like [Koel](http://koel.phanan.net/) and [Gokotta](https://github.com/Zhangdroid/Gokotta), UI components like [VueStrap](http://yuche.github.io/vue-strap/) and [Vue-MDL](http://posva.net/vue-mdl/), and smooth, interactive experiences like [YouTube Adblitz](https://adblitz.withyoutube.com) and even the [Facebook NewsFeed Marketing Site](https://newsfeed.fb.com/)!
+Semakin banyak karya keren yang dibangun dengan Vue. Ada produk seperti [PageKit](https://pagekit.com/), Laravel Spark (segera hadir) dan [Statamic](https://v2.statamic.com/), aplikasi yang ramping seperti [Koel](http://koel.phanan.net/) dan [Gokotta](https://github.com/Zhangdroid/Gokotta), komponen UI seperti [VueStrap](http://yuche.github.io/vue-strap/) dan [Vue-MDL](http://posva.net/vue-mdl/), dan pengalaman interaktif yang lancar seperti [YouTube Adblitz](https://adblitz.withyoutube.com) dan bahkan [Situs Pemasaran Facebook NewsFeed](https://newsfeed.fb.com/)!
-There are many other great projects - too many to be listed here - but you can check them all out in [awesome-vue](https://github.com/vuejs/awesome-vue). If you've built great things with Vue, you should also add them to the list!
+Ada banyak proyek keren lainnya - terlalu banyak untuk dicantumkan di sini - tetapi kamu dapat memeriksanya di [awesome-vue](https://github.com/vuejs/awesome-vue). Jika kamu telah membangun hal-hal keren dengan Vue, kamu juga harus menambahkannya ke daftar!
-## A New Vision For the Project
+## Visi Baru Untuk Proyek Vue
-Some of you may have noticed that the development on the Vue.js core repo has slowed down lately - in the meanwhile, a lot of efforts went into other sub projects, namely [Vuex](https://github.com/vuejs/vuex), [vue-devtools](https://github.com/vuejs/vue-devtools) and the official [Webpack project boilerplate](https://github.com/vuejs-templates/webpack). The next step is a new release for [vue-router](https://github.com/vuejs/vue-router), and better documentation/examples demonstrating how Vue.js core, Vuex and vue-router work together in a large single page application.
+Beberapa dari kamu mungkin telah memperhatikan bahwa pengembangan repo inti Vue.js telah melambat akhir-akhir ini - sementara itu, banyak upaya dilakukan ke sub proyek lainnya, yaitu [Vuex](https://github.com/vuejs/vuex), [vue-devtools](https://github.com/vuejs/vue-devtools) dan [_boilerplate_(kode yg sering ditulis di berbagai kebutuhan) resmi proyek Webpack](https://github.com/vuejs-templates/webpack). Langkah selanjutnya adalah rilisan baru untuk [vue-router](https://github.com/vuejs/vue-router), dan dokumentasi / contoh yang lebih baik menggambarkan bagaimana inti Vue.js, Vuex dan vue-router bekerja bersama dalam sebuah aplikasi satu-halaman (_single-page app_) besar.
-All this adds together towards a new vision for the Vue.js project: a progressive framework that can adapt to different complexity levels. Vue.js core will remain "just the view layer" - you can still drop it on whatever existing page to replace jQuery, but the Vue.js project also includes other pieces like vue-router, Vuex, vue-loader/vueify and vue-cli that works together as a more complete, opinionated framework for single page applications. More on this in a later post.
+Semua ini digabungkan untuk mewujudkan visi baru proyek Vue.js: kerangka kerja progresif yang dapat beradaptasi dengan berbagai tingkat kompleksitas. Inti Vue.js akan tetap "hanya lapisan tampilan" - kamu masih dapat meletakannya pada halaman apa pun yang ada untuk menggantikan jQuery, tetapi proyek Vue.js juga mencakup bagian lain seperti vue-router, Vuex, vue-loader / vueify dan vue -cli yang dapat bekerja bersama sebagai kerangka kerja beropini(_opinionated_) yang lebih lengkap untuk aplikasi satu-halaman. Lebih lanjut tentang ini di postingan selanjutnya.
-## Vue.js needs your help!
+## Vue.js membutuhkan bantuanmu!
-Open source is awesome, and I'm proud that Vue.js is helping people build real products all over the world. However, as the scope of the project grows, pushing new features while maintaining everything becomes a very demanding job. The good news is you can help!
+Open source itu luar biasa, dan saya bangga bahwa Vue.js ini membantu banyak orang membangun produk nyata di seluruh dunia. Namun, seiring dengan berkembangnya ruang lingkup proyek, menambah fitur baru sambil mempertahankan dan merawat semuanya menjadi pekerjaan yang sangat menuntut. Berita baiknya adalah kamu dapat membantu!
-### Looking for collaborators
+### Mencari kolaborator
-There are already users who frequently helps out in various ways, but this is an invitation to make things official. I'm looking for contributors to join the "team", which is currently mostly just me. If that sounds interesting to you, take a look at the application [here](https://docs.google.com/forms/d/1SgDgKZqyivEf5xl0EOWNfs68Xy3f4oBzLXIlwlS0BIs/viewform).
+Sudah ada pengguna yang sering membantu dengan berbagai cara, tetapi ini adalah undangan agar resmi. Saya mencari kontributor untuk bergabung dengan "tim", yang saat ini kebanyakan hanya saya. Jika itu terdengar menarik bagi kamu, lihat formulir lamaran [disini](https://docs.google.com/forms/d/1SgDgKZqyivEf5xl0EOWNfs68Xy3f4oBzLXIlwlS0BIs/viewform).
-### Looking for sponsors
+### Mencari sponsor
-Another way to help making Vue development sustainable is providing direct financial support. The more financial support I receive, the more time I get to spend on making Vue even better.
+Cara lain untuk membantu pengembangan Vue terus berlanjut adalah memberikan dukungan langsung berupa pendanaan. Semakin banyak dukungan finansial yang saya terima, semakin banyak waktu yang dapat saya fokuskan untuk membuat Vue menjadi lebih baik.
-If you run a business and is using Vue in a revenue-generating product, it would make business sense to sponsor Vue development: it ensures the project that your product relies on stays healthy and actively maintained. It can also help your exposure in the Vue community and makes it easier to attract Vue developers.
+Jika kamu menjalankan bisnis dan menggunakan Vue dalam produk yang menghasilkan pendapatan, tentu bijak untuk mensponsori pengembangan Vue: itu memastikan produkmu dapat bergantung pada proyek yang sehat dan dipelihara/dikembangkan secara aktif. Ini juga dapat membangun kehadiran produk kamu di komunitas Vue dan membuatnya lebih mudah untuk menarik pengembang Vue.
-If you are an individual user and have enjoyed the productivity of using Vue, consider donating as a sign of appreciation - like buying me coffee once in a while :)
+Jika kamu adalah pengguna perorangan dan telah menikmati produktivitas menggunakan Vue, pertimbangkan untuk menyumbang sebagai bentuk penghargaan - seperti membelikan saya kopi sesekali :)
-In either case, you can provide recurring funding through Vue's [Patreon campaign](https://www.patreon.com/evanyou), or provide one-time donations via [PayPal](https://www.paypal.me/evanyou). There are many ideas for Vue that I have lined up but haven't had the time to embark on, and I would love to be able to work on them full time - I hope you can help me make that happen!
+Dalam kedua kasus tersebut, kamu dapat memberikan pendanaan rutin melalui [kampanye Patreon Vue](https://www.patreon.com/evanyou), atau memberikan sumbangan se-sekali melalui [PayPal](https://www.paypal.me/evanyou). Ada banyak ide untuk Vue yang telah saya wacanakan tetapi belum memiliki waktu untuk memulai, dan saya ingin sekali dapat mengerjakannya penuh waktu - Saya harap kamu dapat membantu saya mewujudkannya!
diff --git a/src/coc/index.md b/src/coc/index.md
index fd53230a08..cf491f3f1e 100644
--- a/src/coc/index.md
+++ b/src/coc/index.md
@@ -1,45 +1,44 @@
-# Code Of Conduct
+# Kode Etik
-## Our Pledge
+## Janji Kami
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, political party, or sexual identity and orientation. Note, however, that religion, political party, or other ideological affiliation provide no exemptions for the behavior we outline as unacceptable in this Code of Conduct.
+Demi menumbuhkan sebuah lingkungan yang terbuka dan ramah, Kami selaku kontributor dan pengelola berjanji menjadikan partisipasi dalam proyek dan komunitas kami bebas dari pelecehan bagi semua orang, tanpa memandang usia, ukuran tubuh, disabilitas, etnis, karakteristik seks, identitas dan ekspresi gender, tingkat pengalaman, pendidikan, status ekonomi-sosial, kebangsaan, penampilan pribadi, ras, agama, partai politik, atau identitas dan orientasi seksual. Catatan, akan tetapi bahwa agama, partai politik, atau afiliasi ideologi lainya tidak memberikan pengecualian untuk perilaku yang kami sebutkan sebagai tidak dapat diterima dalam kode etik ini.
-## Our Standards
+## Patokan Kami
-Examples of behavior that contributes to creating a positive environment include:
+Beberapa contoh perilaku yang berkontribusi dalam menciptakan lingkungan yang positif meliputi:
-- Using welcoming and inclusive language
-- Being respectful of differing viewpoints and experiences
-- Gracefully accepting constructive criticism
-- Focusing on what is best for the community
-- Showing empathy towards other community members
+- Menggunakan bahasa yang ramah dan inklusif
+- Menghormati berbagai perbedaan sudut pandang dan pengalaman
+- Menerima kritik yang membangun dengan baik
+- Memusatkan hal terbaik untuk komunitas
+- Menunjukan empati terhadap anggota komunitas lainnya
-Examples of unacceptable behavior by participants include:
+Beberapa contoh perilaku yang tidak dapat diterima oleh para anggota meliputi:
-- The use of sexualized language or imagery and unwelcome sexual attention or advances
-- Trolling, insulting/derogatory comments, and personal or political attacks
-- Public or private harassment
-- Publishing others' private information, such as a physical or electronic address, without explicit permission
-- Other conduct which could reasonably be considered inappropriate in a professional setting
+- Penggunaan bahasa atau citra seksual dan tindakan seksual atau lebih yang tidak diinginkan
+- Trolling, komentar melecehkan / menghina, dan serangan pribadi atau politik
+- Pelecehan secara umum atau pribadi
+- Menyebarkan informasi pribadi orang lain, seperti alamat fisik atau elektronik, tanpa izin langsung
+- Perilaku lain yang secara wajar dapat dianggap tidak pantas dalam lingkungan profesional
-## Our Responsibilities
+## Tangung Jawab Kami
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+Pengelola proyek bertanggung jawab untuk menjelaskan dasar tindakan yang dapat diterima dan diharapkan untuk mengambil tindakan korektif yang tepat dan adil dalam menanggapi setiap tindakan yang tidak dapat diterima.
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+Pengelola proyek memiliki hak dan kewajiban untuk menghapus, menyunting, atau menolak komentar, komit, kode, suntingan wiki, masalah dan kontribusi lain yang tidak selaras dengan kode etik, atau untuk melarang secara sementara atau permanen kontribusi apapun untuk tindakan-tindakan lain yang dianggap tidak pantas, mengancam, menyinggung atau berbahaya.
-## Scope
+## Cakupan
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+Kode etik ini berlaku baik di dalam lingkup proyek atau lingkup publik ketika seorang mewaliki proyek atau komunitasnya. Contoh mewakili sebuah proyek atau komunitas termasuk dalam menggunakan alamat email proyek resmi, menerbitkan melalui akun sosial media resmi, atau bertindak sebagai perwakilan yang ditunjuk di acara baik online ataupun offline. Perwakilan proyek dapat didefinisikan lebih lanjut dan diklarifikasi oleh pengelola proyek.
-## Enforcement
+## Pelaksanaan
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at community@vuejs.org. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Perilaku kasar, melecehkan, atau tindakan lain yang tidak dapat diterima dapat dilaporkan dengan menghubungi tim proyek di community@vue.js.org. Semua keluhan akan ditinjau dan diselidiki dan akan menghasilkan tanggapan yang dianggap perlu dan sesuai dengan keadaan. Tim proyek berkewajiban untuk menjaga rahasia berkenaan dengan pelapor insiden. Rincian lebih lanjut terkait kebijakan pelaksanaan dapat diterbitkan secara terpisah
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+Pengelola proyek yang tidak mengikuti atau menegakkan kode etik dengan itikad baik dapat menghadapi dampak sementara atau permanen sebagaimana telah ditentukan oleh anggota lain dari kepemimpinan proyek.
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+## Atribusi
+Kode etik ini diadaptasi dari the [Contributor Covenant][homepage], versi 1.4, tersedia di https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
diff --git a/src/perf/index.md b/src/perf/index.md
index 7a2fdc3d37..0f2e5f5dea 100644
--- a/src/perf/index.md
+++ b/src/perf/index.md
@@ -1,15 +1,15 @@
---
-title: Performance Comparisons
+judul: Perbandingan Kinerja/Performa
---
-## TodoMVC Benchmark
+## Tolok Ukur(_Benchmark_) TodoMVC
-> *Last Updated: 2014-10-12*
+> * Terakhir Diperbarui: 2014-10-12 *
-Looking for the TodoMVC Benchmark? It's been removed because after discussion with some other framework authors we have agreed that:
+Mencari tolok ukur TodoMVC? tolok ukur itu telah dihapus karena setelah diskusi dengan beberapa penulis kerangka kerja lain kami telah sepakat bahwa:
-1. The original intention of these benchmarks were for comparing Browser performance rather than that of frameworks. The "synchronously trigger an action xxx times" test routine doesn't reflect meaningful real world user actions.
+1. Tujuan sebenarnya dari tolok ukur ini adalah untuk membandingkan kinerja Browser dan bukan kinerja kerangka kerja. Pengujian dengan bentuk "memicu tindakan/aksi tertentu xxx kali" tidak mencerminkan tindakan yang bermakna dari pengguna di dunia nyata.
-2. Due to internal implementation differences, frameworks that uses async rendering (e.g. Vue, Om, Mercury) gains the advantage by skipping part of the calculations that happened in the same event loop. The real world user experience doesn't demonstrate such dramatic difference.
+2. Karena perbedaan implementasi internal, kerangka kerja yang menggunakan rendering async (contoh. Vue, Om, Mercury) mendapatkan keuntungan dengan melewati sebagian dari perhitungan yang terjadi dalam perulangan peristiwa(_event_) yang sama. Pengalaman pengguna di dunia nyata tidak menunjukkan perbedaan dramatis seperti itu.
-3. Overall this benchmark suite gave rise to more controversy than constructive insights, so it's been removed and I'd be happy to replace it with a more meaningful way to measure front-end performance.
+3. Secara keseluruhan rangkaian tolok ukur ini memunculkan lebih banyak kontroversi daripada wawasan yang membangun, sehingga lebih baik dihapus dan saya akan senang untuk menggantinya dengan cara yang lebih bermakna untuk mengukur kinerja program bagian depan(_front-end_)/tampilan.
diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index bf5b600a1b..51353a0140 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -3,31 +3,31 @@ title: API
type: api
---
-## Global Config
+## Konfigurasi Global
-`Vue.config` is an object containing Vue's global configurations. You can modify its properties listed below before bootstrapping your application:
+`Vue.config` adalah objek yang berisi konfigurasi global Vue. Anda dapat memodifikasi propertinya yang terdaftar di bawah ini sebelum mem-*bootstrap* aplikasi Anda:
### silent
-- **Type:** `boolean`
+- **Tipe:** `boolean`
-- **Default:** `false`
+- **Nilai Anggapan:** `false`
-- **Usage:**
+- **Penggunaan:**
``` js
Vue.config.silent = true
```
- Suppress all Vue logs and warnings.
+ Memunculkan semua log dan peringatan Vue.
### optionMergeStrategies
-- **Type:** `{ [key: string]: Function }`
+- **Tipe:** `{ [key: string]: Function }`
-- **Default:** `{}`
+- **Nilai Anggapan:** `{}`
-- **Usage:**
+- **Penggunaan:**
``` js
Vue.config.optionMergeStrategies._my_option = function (parent, child, vm) {
@@ -41,106 +41,106 @@ type: api
// Profile.options._my_option = 2
```
- Define custom merging strategies for options.
+ Menetapkan strategi penggabungan kustom untuk opsi.
- The merge strategy receives the value of that option defined on the parent and child instances as the first and second arguments, respectively. The context Vue instance is passed as the third argument.
+ Strategi penggabungan menerima nilai dari opsi yang didefinisikan pada *instance* induk dan anak sebagai argumen pertama dan kedua. Konteks dari Vue *instance* dioper sebagai argumen ketiga.
-- **See also:** [Custom Option Merging Strategies](../guide/mixins.html#Custom-Option-Merge-Strategies)
+- **Lihat juga:** [Strategi Penggabungan pada Opsi Khusus](../guide/mixins.html#Strategi-Penggabungan-pada-Opsi-Khusus)
### devtools
-- **Type:** `boolean`
+- **Tipe:** `boolean`
-- **Default:** `true` (`false` in production builds)
+- **Nilai Anggapan:** `true` (`false` pada _build_ produksi)
-- **Usage:**
+- **Penggunaan:**
``` js
- // make sure to set this synchronously immediately after loading Vue
+ // pastikan untuk mengatur ini secara synchronous segera setelah memuat Vue
Vue.config.devtools = true
```
- Configure whether to allow [vue-devtools](https://github.com/vuejs/vue-devtools) inspection. This option's default value is `true` in development builds and `false` in production builds. You can set it to `true` to enable inspection for production builds.
+ Konfigurasi untuk mengizinkan [vue-devtools](https://github.com/vuejs/vue-devtools) untuk melakukan inspeksi pada aplikasi kita. Nilai anggapan dari opsi ini adalah `true` dalam _build_ pengembangan dan `false` di _build_ produksi. Anda dapat mengaturnya ke `true` untuk mengaktifkan inspeksi pada produksi.
### errorHandler
-- **Type:** `Function`
+- **Tipe:** `Function`
-- **Default:** `undefined`
+- **Nilai Anggapan:** `undefined`
-- **Usage:**
+- **Penggunaan:**
``` js
Vue.config.errorHandler = function (err, vm, info) {
- // handle error
- // `info` is a Vue-specific error info, e.g. which lifecycle hook
- // the error was found in. Only available in 2.2.0+
+ // penanganan galat
+ // `info` adalah informasi galat yang spesifik pada Vue, seperti pada kait siklus hidup
+ // galat ditemukan di. Hanya tersedia di 2.2.0+
}
```
- Assign a handler for uncaught errors during component render function and watchers. The handler gets called with the error and the Vue instance.
+ Tetapkan _handler_ untuk kesalahan yang tidak tertangkap selama fungsi render komponen dan pengamat _(watcher)_. Fungsi _handler_ akan dipanggil dengan galat dan _instance_ Vue sebagai parameter.
- > In 2.2.0+, this hook also captures errors in component lifecycle hooks. Also, when this hook is `undefined`, captured errors will be logged with `console.error` instead of crashing the app.
+ > Di 2.2.0+, kait ini juga menangkap galat pada kait siklus hidup komponen. Begitu juga ketika kait ini `undefined`, galat tetap akan dicatat dengan `console.error`, alih-alih membuat aplikasi menjadi tidak bisa digunakan.
- > In 2.4.0+, this hook also captures errors thrown inside Vue custom event handlers.
+ > Di 2.4.0+, kait ini juga menangkap galat yang dilempar dari dalam _event handler_ khusus.
- > In 2.6.0+, this hook also captures errors thrown inside `v-on` DOM listeners. In addition, if any of the covered hooks or handlers returns a Promise chain (e.g. async functions), the error from that Promise chain will also be handled.
+ > Di 2.6.0+, kait ini juga menangkap galat yang dilempar dari pemantau _(listener)_ DOM `v-on`. Sebagai tambahan, jika ada kait atau _handler_ yang mengembalikan rantai Promise (misalnya fungsi _async_), maka galat dari rantai Promise tersebut juga akan ditangani.
- > Error tracking services [Sentry](https://sentry.io/for/vue/) and [Bugsnag](https://docs.bugsnag.com/platforms/browsers/vue/) provide official integrations using this option.
+ > Servis pelacak galat [Sentry](https://sentry.io/for/vue/) dan [Bugsnag](https://docs.bugsnag.com/platforms/browsers/vue/) menyediakan integrasi resmi dengan opsi ini.
### warnHandler
-> New in 2.4.0+
+> Baru di 2.4.0+
-- **Type:** `Function`
+- **Tipe:** `Function`
-- **Default:** `undefined`
+- **Nilai Anggapan:** `undefined`
-- **Usage:**
+- **Penggunaan:**
``` js
Vue.config.warnHandler = function (msg, vm, trace) {
- // `trace` is the component hierarchy trace
+ // `trace` adalah jejak hierarki komponen
}
```
- Assign a custom handler for runtime Vue warnings. Note this only works during development and is ignored in production.
+ Menetapkan handler khusus untuk peringatan pada *runtime Vue*. Untuk catatan, ini hanya berfungsi selama mode pengembangan dan diabaikan dalam produksi.
### ignoredElements
-- **Type:** `Array`
+- **Tipe:** `Array`
-- **Default:** `[]`
+- **Nilai Anggapan:** `[]`
-- **Usage:**
+- **Penggunaan:**
``` js
Vue.config.ignoredElements = [
'my-custom-web-component',
'another-web-component',
- // Use a `RegExp` to ignore all elements that start with "ion-"
- // 2.5+ only
+ // Gunakan `RegExp` untuk mengabaikan semua elemen yang dimulai dengan "ion-"
+ // hanya 2.5+
/^ion-/
]
```
- Make Vue ignore custom elements defined outside of Vue (e.g., using the Web Components APIs). Otherwise, it will throw a warning about an `Unknown custom element`, assuming that you forgot to register a global component or misspelled a component name.
+ Membuat Vue mengabaikan elemen khusus yang didefinisikan di luar Vue (mis., Menggunakan Web Components APIs). Jika tidak, itu akan memunculkan peringatan tentang `Unknown custom element`, dengan asumsi Anda lupa mendaftarkan komponen global atau salah mengeja nama komponen.
### keyCodes
-- **Type:** `{ [key: string]: number | Array }`
+- **Tipe:** `{ [key: string]: number | Array }`
-- **Default:** `{}`
+- **Nilai Anggapan:** `{}`
-- **Usage:**
+- **Penggunaan:**
``` js
Vue.config.keyCodes = {
v: 86,
f1: 112,
- // camelCase won`t work
+ // camelCase tidak akan bekerja
mediaPlayPause: 179,
- // instead you can use kebab-case with double quotation marks
+ // tapi gunakan kebab-case dengan tanda kutip ganda
"media-play-pause": 179,
up: [38, 87]
}
@@ -150,51 +150,51 @@ type: api
```
- Define custom key alias(es) for `v-on`.
+ Menetapkan alias key kustom untuk `v-on`.
### performance
-> New in 2.2.0+
+> Baru di 2.2.0+
-- **Type:** `boolean`
+- **Tipe:** `boolean`
-- **Default:** `false (from 2.2.3+)`
+- **Nilai Anggapan:** `false (from 2.2.3+)`
-- **Usage**:
+- **Penggunaan**:
- Set this to `true` to enable component init, compile, render and patch performance tracing in the browser devtool performance/timeline panel. Only works in development mode and in browsers that support the [performance.mark](https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark) API.
+ Setel ini menjadi `true` untuk mengaktifkan pelacakan inisialisasi komponen, kompilasi, render, dan palacakan performa patch pada alat pengembang peramban di bagian performance/timeline. Hanya berfungsi dalam mode pengembangan dan peramban yang mendukung API [performance.mark](https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark).
### productionTip
-> New in 2.2.0+
+> Baru di 2.2.0+
-- **Type:** `boolean`
+- **Tipe:** `boolean`
-- **Default:** `true`
+- **Nilai Anggapan:** `true`
-- **Usage**:
+- **Penggunaan**:
- Set this to `false` to prevent the production tip on Vue startup.
+ Setel ini menjadi `false` untuk mencegah tip produksi pada memulai Vue.
-## Global API
+## API Global
### Vue.extend( options )
-- **Arguments:**
+- **Argumen:**
- `{Object} options`
-- **Usage:**
+- **Penggunaan:**
- Create a "subclass" of the base Vue constructor. The argument should be an object containing component options.
+ Membuat sebuah "subclass" dari konstruktor. Argumen harus berisi objek yang berisi opsi komponen.
- The special case to note here is the `data` option - it must be a function when used with `Vue.extend()`.
+ Kasus spesial untuk dicatat disini adalah opsi `data` - ini harus berupa fungsi ketika digunakan dengan `Vue.extend()`.
``` html
```
``` js
- // create constructor
+ // buat konstruktor
var Profile = Vue.extend({
template: '
{{firstName}} {{lastName}} aka {{alias}}
',
data: function () {
@@ -205,89 +205,89 @@ type: api
}
}
})
- // create an instance of Profile and mount it on an element
+ // buat sebuah instance dari profil dan pasang ke dalam elemen
new Profile().$mount('#mount-point')
```
- Will result in:
+ Akan menghasilkan:
``` html
Walter White aka Heisenberg
```
-- **See also:** [Components](../guide/components.html)
+- **Lihat juga:** [Components](../guide/components.html)
### Vue.nextTick( [callback, context] )
-- **Arguments:**
+- **Argumen:**
- `{Function} [callback]`
- `{Object} [context]`
-- **Usage:**
+- **Penggunaan:**
- Defer the callback to be executed after the next DOM update cycle. Use it immediately after you've changed some data to wait for the DOM update.
+ Menangguhkan panggilan balik untuk dieksekusi setelah siklus pembaruan DOM selanjutnya. Gunakan ini segera setelah Anda mengubah beberapa data untuk menunggu untuk pembaruan DOM.
``` js
- // modify data
+ // modifikasi data
vm.msg = 'Hello'
- // DOM not updated yet
+ // DOM belum diperbarui
Vue.nextTick(function () {
- // DOM updated
+ // DOM telah diperbarui
})
- // usage as a promise (2.1.0+, see note below)
+ // gunakan sebagai promise (2.1.0+, lihat catatan di bawah)
Vue.nextTick()
.then(function () {
- // DOM updated
+ // DOM telah diperbarui
})
```
- > New in 2.1.0+: returns a Promise if no callback is provided and Promise is supported in the execution environment. Please note that Vue does not come with a Promise polyfill, so if you target browsers that don't support Promises natively (looking at you, IE), you will have to provide a polyfill yourself.
+ > Baru di 2.1.0+: mengembalikan sebuah _Promise_ jika tidak tersedia panggilan balikdan _Promise_ didukung di lingkungan eksekusi. Tolong catat bahwa Vue tidak datang dengan _Promise_ _polyfill_, jadi jika Anda menargetkan peramban yang tidak mendukung _Promise_ secara bawaan (melihat Anda, IE). Anda harus menyediakan _polyfill_ Anda sendiri.
-- **See also:** [Async Update Queue](../guide/reactivity.html#Async-Update-Queue)
+- **Lihat juga:** [Async Update Queue](../guide/reactivity.html#Async-Update-Queue)
### Vue.set( target, key, value )
-- **Arguments:**
+- **Argumen:**
- `{Object | Array} target`
- `{string | number} key`
- `{any} value`
-- **Returns:** the set value.
+- **Mengembalikan:** nilai yang diset.
-- **Usage:**
+- **Penggunaan:**
- Adds a property to a reactive object, ensuring the new property is also reactive, so triggers view updates. This must be used to add new properties to reactive objects, as Vue cannot detect normal property additions (e.g. `this.myObject.newProperty = 'hi'`).
+ Menambahkan properti ke dalam objek reaktif, menjamin properti baru untuk reaktif juga, jadi memicu pembaruan _view_. Ini harus digunakan untuk menambah properti baru untuk objek reaktif, karena Vue tidak dapat mendeteksi penambahan properti normal (sebagai contoh `this.myObject.newProperty = 'hi'`).
-
The target object cannot be a Vue instance, or the root data object of a Vue instance.
+
Objek target tidak dapat menjadi _instance_ Vue, atau objek data root dari _instance_ Vue.
-- **See also:** [Reactivity in Depth](../guide/reactivity.html)
+- **Lihat juga:** [Reactivity in Depth](../guide/reactivity.html)
### Vue.delete( target, key )
-- **Arguments:**
+- **Argumen:**
- `{Object | Array} target`
- `{string | number} key/index`
- > Only in 2.2.0+: Also works with Array + index.
+ > Hanya di 2.2.0+: Juga bekerja dengan Array + index.
-- **Usage:**
+- **Penggunaan:**
- Delete a property on an object. If the object is reactive, ensure the deletion triggers view updates. This is primarily used to get around the limitation that Vue cannot detect property deletions, but you should rarely need to use it.
+ Menghapus properti dalam objek. Jika objek reaktif, menjamin pembaruan pemicu penghapusan _view_. Ini terutama digunakan untuk mengatasi batasan dimana Vue tidak dapat mendeteksi penghapusan properti, tapi Anda jarang harus menggunakannya.
-
The target object cannot be a Vue instance, or the root data object of a Vue instance.
+
Objek target tidak dapat menjadi _instance_ Vue, atau objek data root dari _instance_ Vue.
-- **See also:** [Reactivity in Depth](../guide/reactivity.html)
+- **Lihat juga:** [Reactivity in Depth](../guide/reactivity.html)
### Vue.directive( id, [definition] )
-- **Arguments:**
+- **Argumen:**
- `{string} id`
- `{Function | Object} [definition]`
-- **Usage:**
+- **Penggunaan:**
- Register or retrieve a global directive.
+ Mendaftarkan atau mengambil directif global.
``` js
// register
@@ -301,24 +301,24 @@ type: api
// register (function directive)
Vue.directive('my-directive', function () {
- // this will be called as `bind` and `update`
+ // ini akan dipanggil sebagai `bind` dan `update`
})
- // getter, return the directive definition if registered
+ // getter, mengembalikan definisi direktif jika terdaftar
var myDirective = Vue.directive('my-directive')
```
-- **See also:** [Custom Directives](../guide/custom-directive.html)
+- **Lihat juga:** [Custom Directives](../guide/custom-directive.html)
### Vue.filter( id, [definition] )
-- **Arguments:**
+- **Argumen:**
- `{string} id`
- `{Function} [definition]`
-- **Usage:**
+- **Penggunaan:**
- Register or retrieve a global filter.
+ Mendaftarkan atau mengambil filter global.
``` js
// register
@@ -326,69 +326,69 @@ type: api
// return processed value
})
- // getter, return the filter if registered
+ // getter, mengembalikan filter jika terdaftar
var myFilter = Vue.filter('my-filter')
```
-- **See also:** [Filters](../guide/filters.html)
+- **Lihat juga:** [Filters](../guide/filters.html)
### Vue.component( id, [definition] )
-- **Arguments:**
+- **Argumen:**
- `{string} id`
- `{Function | Object} [definition]`
-- **Usage:**
+- **Penggunaan:**
- Register or retrieve a global component. Registration also automatically sets the component's `name` with the given `id`.
+ Mendaftarkan atau mengambil komponen global. Pendaftaran juga secara otomatis menset komponen `name` dengan `id` yang diberikan.
``` js
- // register an extended constructor
+ // mendaftarkan sebuah perpanjangan konstruktor
Vue.component('my-component', Vue.extend({ /* ... */ }))
- // register an options object (automatically call Vue.extend)
+ // mendaftarkan opsi objek (secara otomatis memanggil Vue.extend)
Vue.component('my-component', { /* ... */ })
- // retrieve a registered component (always return constructor)
+ // mengambil komponen yang telah terdaftar (selalu mengembalikan konstruktor)
var MyComponent = Vue.component('my-component')
```
-- **See also:** [Components](../guide/components.html)
+- **Lihat juga:** [Components](../guide/components.html)
### Vue.use( plugin )
-- **Arguments:**
+- **Argumen:**
- `{Object | Function} plugin`
-- **Usage:**
+- **Penggunaan:**
- Install a Vue.js plugin. If the plugin is an Object, it must expose an `install` method. If it is a function itself, it will be treated as the install method. The install method will be called with Vue as the argument.
+ Memasang plugin Vue.js. Jika plugin adalah sebuah objek, objek tersebut harus membuka metode `install`. Jika ini adalah fungsinya sendiri, ini akan diperlukan sebagai metode pemasangan. Metode pemasangan akan dipanggil dengan Vue sebagai argumen.
- This method has to be called before calling `new Vue()`
+ Metode ini harus dipanggil sebelum memanggil `new Vue()`
- When this method is called on the same plugin multiple times, the plugin will be installed only once.
+ Ketika metode ini dipanggil dalam plugin yang sama beberapa kali, plugin hanya akan dipasang sekali.
-- **See also:** [Plugins](../guide/plugins.html)
+- **Lihat juga:** [Plugins](../guide/plugins.html)
### Vue.mixin( mixin )
-- **Arguments:**
+- **Argumen:**
- `{Object} mixin`
-- **Usage:**
+- **Penggunaan:**
- Apply a mixin globally, which affects every Vue instance created afterwards. This can be used by plugin authors to inject custom behavior into components. **Not recommended in application code**.
+ Menerapkan _mixin_ secara global, akan berpengaruh ke setiap _instance_ Vue yang tercipta setelah itu. Ini dapat digunakan oleh pembuat plugin untuk menginjeksi perilaku khusus ke dalam komponen. **Tidak direkomendasikan dalam kode aplikasi**.
-- **See also:** [Global Mixin](../guide/mixins.html#Global-Mixin)
+- **Lihat juga:** [Global Mixin](../guide/mixins.html#Global-Mixin)
### Vue.compile( template )
-- **Arguments:**
+- **Argumen:**
- `{string} template`
-- **Usage:**
+- **Penggunaan:**
- Compiles a template string into a render function. **Only available in the full build.**
+ Menghimpun untai templat kedalam fungsi render. **Hanya tersedia dalam build penuh.**
``` js
var res = Vue.compile('
{{ msg }}
')
@@ -402,20 +402,20 @@ type: api
})
```
-- **See also:** [Render Functions](../guide/render-function.html)
+- **Lihat juga:** [Render Functions](../guide/render-function.html)
### Vue.observable( object )
-> New in 2.6.0+
+> Baru di 2.6.0+
-- **Arguments:**
+- **Argumen:**
- `{Object} object`
-- **Usage:**
+- **Penggunaan:**
- Make an object reactive. Internally, Vue uses this on the object returned by the `data` function.
+ Membuat sebuah reaktif objek. Secara internal, Vue menggunakan ini dalam objek yang dikembalikan oleh fungsi `data`.
- The returned object can be used directly inside [render functions](../guide/render-function.html) and [computed properties](../guide/computed.html), and will trigger appropriate updates when mutated. It can also be used as a minimal, cross-component state store for simple scenarios:
+ Objek yang dikembalikan dapat digunakan secara langsung dalam [fungsi render](../guide/render-function.html) dan [properti computed](../guide/computed.html), dan akan memicu pembaruan yang sesuai ketika bermutasi. Ini juga dapat digunakan secara minimal, menyimpan _state_ lintas komponen untuk skenario sederhana:
``` js
const state = Vue.observable({ count: 0 })
@@ -429,15 +429,15 @@ type: api
}
```
-
In Vue 2.x, `Vue.observable` directly mutates the object passed to it, so that it is equivalent to the object returned, as [demonstrated here](../guide/instance.html#Data-and-Methods). In Vue 3.x, a reactive proxy will be returned instead, leaving the original object non-reactive if mutated directly. Therefore, for future compatibility, we recommend always working with the object returned by `Vue.observable`, rather than the object originally passed to it.
+
Dalam Vue 2.x, `Vue.observable` secara langsung memutasikan objek yang dioper ke dalamnya, jadi ini sama dengan pengembalian objek, [didemonstrasikan disini](../guide/instance.html#Data-and-Methods). Dalam Vue 3.x, proksi reaktif akan kembali sebagai gantinya, meninggalkan objek nonreaktif aslinya jika bermutasi secara langsung. Karena itu, untuk kompatibilitas di masa yang akan datang, kami selalu merekomendasikan bekerja dengan objek yang dikembalikan oleh `Vue.observable`, dari pada objek asli yang dioper ke dalamnya.
-- **See also:** [Reactivity in Depth](../guide/reactivity.html)
+- **Lihat juga:** [Reactivity in Depth](../guide/reactivity.html)
### Vue.version
-- **Details**: Provides the installed version of Vue as a string. This is especially useful for community plugins and components, where you might use different strategies for different versions.
+- **Detil**: Menyediakan versi yang terpasang dari Vue sebagai untai. Terutama beguna untuk plugin dan komponen dari komunitas, dimana Anda mungkin menggunakan stretegi berbeda untuk versi yang berbeda.
-- **Usage**:
+- **Penggunaan**:
```js
var version = Number(Vue.version.split('.')[0])
@@ -451,41 +451,41 @@ type: api
}
```
-## Options / Data
+## Opsi / Data
### data
-- **Type:** `Object | Function`
+- **Tipe:** `Object | Function`
-- **Restriction:** Only accepts `Function` when used in a component definition.
+- **Batasan:** Hanya menerima `Function` saat digunakan dalam pendefinisian komponen.
-- **Details:**
+- **Detil:**
- The data object for the Vue instance. Vue will recursively convert its properties into getter/setters to make it "reactive". **The object must be plain**: native objects such as browser API objects and prototype properties are ignored. A rule of thumb is that data should just be data - it is not recommended to observe objects with their own stateful behavior.
+ Objek data pada sebuah Vue *instance*. Vue secara rekursif akan mengkonversi properti-propertinya menjadi *getter/setter* untuk membuatnya *reaktif*. **Objeknya haruslah sederhana**: objek-objek *native* seperti objek *browser* API and properti-properti *prototype* akan diabaikan. Aturan sederhananya adalah data seharusnya hanyalah data - tidak direkomendasikan untuk melakukan observasi ke objek-objek yang memiliki perilaku *stateful* (yang memiliki bermacam variasi keadaan / *state*).
- Once observed, you can no longer add reactive properties to the root data object. It is therefore recommended to declare all root-level reactive properties upfront, before creating the instance.
+ Jika telah terobservasi, kamu tidak dapat lagi menambahkan properti-properti reaktif ke objek data *root*. Maka direkomendasikan untuk mendeklarasikan semua properti-properti reaktif tingkat *root* diawal, sebelum membuat *instance*.
- After the instance is created, the original data object can be accessed as `vm.$data`. The Vue instance also proxies all the properties found on the data object, so `vm.a` will be equivalent to `vm.$data.a`.
+ Setelah *instance* terbuat, objek data original dapat diakses sebagai `vm.$data`. Vue *instance* juga menjembatani semua properti-properti yang ditemui pada objek data, sehingga `vm.a` akan ekuivalen dengan `vm.$data.a`.
- Properties that start with `_` or `$` will **not** be proxied on the Vue instance because they may conflict with Vue's internal properties and API methods. You will have to access them as `vm.$data._property`.
+ Properti-properti yang berawalan `_` atau `$` **tidak** akan dijembatani pada Vue *instance* karena dapat menyebabkan konflik dengan properti-properti internal Vue dan API *methods*. Kamu akan dapat mengakses mereka sebagai `vm.$data._property`.
When defining a **component**, `data` must be declared as a function that returns the initial data object, because there will be many instances created using the same definition. If we use a plain object for `data`, that same object will be **shared by reference** across all instances created! By providing a `data` function, every time a new instance is created we can call it to return a fresh copy of the initial data.
- If required, a deep clone of the original object can be obtained by passing `vm.$data` through `JSON.parse(JSON.stringify(...))`.
+ Jika dibutuhkan, penjiplakan mendalam (*deep clone*) daripada objek original dapat dilakukan dengan meneruskan (*passing*) `vm.$data` melalui `JSON.parse(JSON.stringify(...))`.
-- **Example:**
+- **Contoh:**
``` js
var data = { a: 1 }
- // direct instance creation
+ // pembuatan instance secara langsung
var vm = new Vue({
data: data
})
vm.a // => 1
vm.$data === data // => true
- // must use function when in Vue.extend()
+ // harus menggunakan function saat berada didalam Vue.extend()
var Component = Vue.extend({
data: function () {
return { a: 1 }
@@ -493,45 +493,45 @@ type: api
})
```
- Note that if you use an arrow function with the `data` property, `this` won't be the component's instance, but you can still access the instance as the function's first argument:
+ Perlu dicatat bahwa jika kamu menggunkan fungsi panah (*arrow function*) pada properti `data`, `this` tidaklah menjadi *instance* dari komponen, namun kamu tetap dapat mengakses *instance* tersebut sebagai argumen pertama dari *function*:
```js
data: vm => ({ a: vm.myProp })
```
-- **See also:** [Reactivity in Depth](../guide/reactivity.html)
+- **Lihat juga:** [Reaktivitas Secara Mendalam](../guide/reactivity.html)
### props
-- **Type:** `Array | Object`
+- **Tipe:** `Array | Object`
-- **Details:**
+- **Detil:**
- A list/hash of attributes that are exposed to accept data from the parent component. It has an Array-based simple syntax and an alternative Object-based syntax that allows advanced configurations such as type checking, custom validation and default values.
+ Sebuah daftar (*list*) / *hash* dari attribut-attribut yang diekspos untuk menerima data dari komponen induk (*parent*). Props memiliki sebuah sintaks sederhana berbasis *Array* dan sintaks alternatif berbasis Objek yang memungkinkan konfigurasi lebih jauh (*advanced*) seperti pengecekan tipe (*type checking*), validasi khusus (*custom*) dan melakukan pemberian nilai-nilai standar (*default values*).
- With Object-based syntax, you can use following options:
- - **type:** can be one of the following native constructors: `String`, `Number`, `Boolean`, `Array`, `Object`, `Date`, `Function`, `Symbol`, any custom constructor function or an array of those. Will check if a prop has a given type, and will throw a warning if it doesn't. [More information](../guide/components-props.html#Prop-Types) on prop types.
+ Dengan sintaks berbasis Objek, kamu dapat menggunakan opsi-opsi berikut:
+ - **type:** dapat berupa salah satu dari *native contructors* berikut: `String`, `Number`, `Boolean`, `Array`, `Object`, `Date`, `Function`, `Symbol`, *constructor* khusus (*custom*) apapun atau suatu *array* dari itu semua. Akan dilakukan pengecekan apakah sebuah *prop* telah diberikan tipe, dan akan memunculkan peringatan jika belum. [Informasi lebih lanjut](../guide/components-props.html#Prop-Types) untuk tipe-tipe *prop*.
- **default:** `any`
- Specifies a default value for the prop. If the prop is not passed, this value will be used instead. Object or array defaults must be returned from a factory function.
+ Menspesifikasikan nilai dasar (*default*) untuk *prop*. Jika prop tidak diberikan nilai, maka nilai ini yang akan digunakan. Objek atau *array* standar harus dikembalikan (*returned*) dari *function* yang membuatnya.
- **required:** `Boolean`
- Defines if the prop is required. In a non-production environment, a console warning will be thrown if this value is truthy and the prop is not passed.
+ Mendefinisikan jika *prop* ini dibutuhkan (harus ada dan memiliki nilai). Dalam lingkungan yang bukan untuk keperluan produksi (*non-production*), peringatan pada *console* akan dimunculkan jika nilainya *truthy* (`true` atau yang ekuivalen) dan *prop*-nya tidak diteruskan (*passed*).
- **validator:** `Function`
- Custom validator function that takes the prop value as the sole argument. In a non-production environment, a console warning will be thrown if this function returns a falsy value (i.e. the validation fails). You can read more about prop validation [here](../guide/components-props.html#Prop-Validation).
+ Sebuah fungsi validator *custom* (bebas dan khusus) yang menerima nilai *prop* sebagai satu-satunya argumen. Dalam lingkungan yang bukan untuk keperluan produksi (*non-production*), peringatan pada *console* akan dimunculkan jika fungsi ini mengembalikan nilai yang *falsy* (`false` atau yang ekuivalen) (misal: validasi gagal). Kamu dapat membaca lebih lanjut tentang validasi *prop* [disini](../guide/components-props.html#Prop-Validation).
-- **Example:**
+- **Contoh:**
``` js
- // simple syntax
+ // sintaks sederhana
Vue.component('props-demo-simple', {
props: ['size', 'myMessage']
})
- // object syntax with validation
+ // sintaks objek dengan validasi
Vue.component('props-demo-advanced', {
props: {
- // type check
+ // pengecekan tipe
height: Number,
- // type check plus other validations
+ // pengecekan tipe plus validasi lain
age: {
type: Number,
default: 0,
@@ -544,19 +544,19 @@ type: api
})
```
-- **See also:** [Props](../guide/components-props.html)
+- **Lihat juga:** [Props](../guide/components-props.html)
### propsData
-- **Type:** `{ [key: string]: any }`
+- **Tipe:** `{ [key: string]: any }`
-- **Restriction:** only respected in instance creation via `new`.
+- **Batasan:** hanya dapat ditemui / digunakan (*respected*) pada pembuatan *instance* via `new`.
-- **Details:**
+- **Detil:**
- Pass props to an instance during its creation. This is primarily intended to make unit testing easier.
+ Meneruskan *props* ke *instance* saat pembuatan *instance* tersebut. Utamanya ditujukan agar pengerjaan *unit testing* lebih mudah.
-- **Example:**
+- **Contoh:**
``` js
var Comp = Vue.extend({
@@ -573,13 +573,13 @@ type: api
### computed
-- **Type:** `{ [key: string]: Function | { get: Function, set: Function } }`
+- **Tipe:** `{ [key: string]: Function | { get: Function, set: Function } }`
-- **Details:**
+- **Detil:**
- Computed properties to be mixed into the Vue instance. All getters and setters have their `this` context automatically bound to the Vue instance.
+ Properti-properti terolah (*computed*) yang kemudian digabung kedalam Vue *instance*. Seluruh *getters* (fungsi untuk mengambil data) dan *setters* (fungsi untuk mengubah data) memiliki konteks `this` yang secara otomatis terikat dengan Vue *instance*-nya.
- Note that if you use an arrow function with a computed property, `this` won't be the component's instance, but you can still access the instance as the function's first argument:
+ Perlu dicatat bahwa jika kamu menggunkan fungsi panah (*arrow function*) pada properti terolah (*computed*), `this` bukanlah *instance* dari komponen, namun kamu tetap dapat mengakses *instance* tersebut sebagai argumen pertama dari *function*:
```js
computed: {
@@ -587,19 +587,19 @@ type: api
}
```
- Computed properties are cached, and only re-computed on reactive dependency changes. Note that if a certain dependency is out of the instance's scope (i.e. not reactive), the computed property will __not__ be updated.
+ Properti-properti terolah (*computed*) ini akan tersimpan sementara (*cached*), dan hanya akan diolah kembali (*re-computed*) saat ada perubahan pada dependensi reaktif. Perlu dicatat bahwa jika sebuah dependensi tertentu berada diluar cakupan (*scope*) *instance* (misal: tidak reaktif), properti terolah (*computed*) **tidak** akan diperbarui.
-- **Example:**
+- **Contoh:**
```js
var vm = new Vue({
data: { a: 1 },
computed: {
- // get only
+ // hanya get
aDouble: function () {
return this.a * 2
},
- // both get and set
+ // get dan set
aPlus: {
get: function () {
return this.a + 1
@@ -616,19 +616,19 @@ type: api
vm.aDouble // => 4
```
-- **See also:** [Computed Properties](../guide/computed.html)
+- **Lihat juga:** [Computed Properties](../guide/computed.html)
### methods
-- **Type:** `{ [key: string]: Function }`
+- **Tipe:** `{ [key: string]: Function }`
-- **Details:**
+- **Detil:**
- Methods to be mixed into the Vue instance. You can access these methods directly on the VM instance, or use them in directive expressions. All methods will have their `this` context automatically bound to the Vue instance.
+ Metode-metode yang kemudian digabung ke dalam Vue *instance*. Kamu dapat mengakses metode-metode ini secara langsung pada VM *instance*, atau menggunakannya di ekspresi-ekspresi *directive*. Semua metode ini, konteks `this`-nya akan secara otomatis terikat ke Vue *instance*.
-
Note that __you should not use an arrow function to define a method__ (e.g. `plus: () => this.a++`). The reason is arrow functions bind the parent context, so `this` will not be the Vue instance as you expect and `this.a` will be undefined.
+
Perlu dicatat bahwa __kamu sebaiknya tidak menggunakan fungsi panah (*arrow*) untuk mendefinisikan sebuah metode__ (contoh: `plus: () => this.a++`). Hal tersebut dikarenakan fungsi panah (*arrow*) mengikat (*bind*) konteks ke konteks induk, menyebabkan `this` bukan lagi Vue *instance* seperti yang kamu ekspektasikan dan `this.a` akan menjadi *undefined*.
-- **Example:**
+- **Contoh:**
```js
var vm = new Vue({
@@ -643,17 +643,17 @@ type: api
vm.a // 2
```
-- **See also:** [Event Handling](../guide/events.html)
+- **Lihat juga:** [Penanganan Event](../guide/events.html)
### watch
-- **Type:** `{ [key: string]: string | Function | Object | Array}`
+- **Tipe:** `{ [key: string]: string | Function | Object | Array}`
-- **Details:**
+- **Detil:**
- An object where keys are expressions to watch and values are the corresponding callbacks. The value can also be a string of a method name, or an Object that contains additional options. The Vue instance will call `$watch()` for each entry in the object at instantiation.
+ Sebuah objek dimana *keys* adalah expresi-expresi untuk memantau dan *values* adalah *callback*-nya (fungsi yang dipanggil setelah suatu fungsi lain selesai dieksekusi). *Value* dapat berupa *string* dari nama sebuah metode, atau sebuah Objek yang memiliki opsi-opsi tambahan. Vue *instance* akan memanggil `$watch()` setiap key pada objek saat instansiasi (pembuatan Vue *instance*).
-- **Example:**
+- **Contoh:**
``` js
var vm = new Vue({
@@ -672,14 +672,14 @@ type: api
a: function (val, oldVal) {
console.log('new: %s, old: %s', val, oldVal)
},
- // string method name
+ // *string* dari nama metode
b: 'someMethod',
- // deep watcher
+ // pemantauan mendalam (deep watcher)
c: {
handler: function (val, oldVal) { /* ... */ },
deep: true
},
- // the callback will be called immediately after the start of the observation
+ // callback akan dipanggil seketika setelah observasi dimulai
d: {
handler: function (val, oldVal) { /* ... */ },
immediate: true
@@ -692,86 +692,86 @@ type: api
/* ... */
}
],
- // watch vm.e.f's value: {g: 5}
+ // memantau vm.e.f's value: {g: 5}
'e.f': function (val, oldVal) { /* ... */ }
}
})
vm.a = 2 // => new: 2, old: 1
```
-
Note that __you should not use an arrow function to define a watcher__ (e.g. `searchQuery: newValue => this.updateAutocomplete(newValue)`). The reason is arrow functions bind the parent context, so `this` will not be the Vue instance as you expect and `this.updateAutocomplete` will be undefined.
+
Perlu dicatat bahwa __kamu sebaiknya tidak menggunakan fungsi panah (*arrow*) untuk mendefinisikan sebuah watcher__ (contoh: `searchQuery: newValue => this.updateAutocomplete(newValue)`). Hal tersebut dikarenakan fungsi panah (*arrow*) mengikat (*bind*) konteks ke konteks induk, menyebabkan `this` bukan lagi Vue *instance* seperti yang kamu ekspektasikan dan `this.updateAutocomplete` akan menjadi *undefined*.
-- **See also:** [Instance Methods / Data - vm.$watch](#vm-watch)
+- **Lihat juga:** [Metode Instance / Data - vm.$watch](#vm-watch)
-## Options / DOM
+## Opsi / DOM
### el
-- **Type:** `string | Element`
+- **Tipe:** `string | Element`
-- **Restriction:** only respected in instance creation via `new`.
+- **Batasan:** hanya berlaku pada pembuatan _instance_ melalui `new`.
-- **Details:**
+- **Detil:**
- Provide the Vue instance an existing DOM element to mount on. It can be a CSS selector string or an actual HTMLElement.
+ Berikan _instance_ Vue sebuah elemen DOM yang sudah ada untuk dipasangkan. Ini bisa berupa kata pemilih CSS atau sebuah HTMLElement sesungguhnya.
- After the instance is mounted, the resolved element will be accessible as `vm.$el`.
+ Setelah _instance_ sudah dipasangkan, elemen akan dapat diakses sebagai `vm.$el`.
- If this option is available at instantiation, the instance will immediately enter compilation; otherwise, the user will have to explicitly call `vm.$mount()` to manually start the compilation.
+ Jika opsi ini ada saat pembuatan _instance_, _instance_ akan langsung menjalankan kompilasi; jika tidak, pengguna harus memanggil `vm.$mount()` secara eksplisit untuk menjalankan kompilasi secara manual.
-
The provided element merely serves as a mounting point. Unlike in Vue 1.x, the mounted element will be replaced with Vue-generated DOM in all cases. It is therefore not recommended to mount the root instance to `` or `
`.
+
Elemen yang diberikan hanya menjadi titik pemasangan. Tidak seperti Vue 1.x, elemen yang dipasangkan akan digantikan dengan DOM yang dihasilkan oleh Vue dalam semua kasus. Karena itu tidak disarankan untuk memasangkan instance akar ke `` atau `
`.
-
If neither `render` function nor `template` option is present, the in-DOM HTML of the mounting DOM element will be extracted as the template. In this case, Runtime + Compiler build of Vue should be used.
+
Jika fungsi `render` maupun opsi `template` tidak diberikan, DOM HTML yang di dalam dari elemen DOM yang dipasangkan akan diekstrak sebagai template. Dalam kasus ini, Runtime + Compiler build Vue harus digunakan.
-- **See also:**
+- **Lihat juga:**
- [Lifecycle Diagram](../guide/instance.html#Lifecycle-Diagram)
- [Runtime + Compiler vs. Runtime-only](../guide/installation.html#Runtime-Compiler-vs-Runtime-only)
### template
-- **Type:** `string`
+- **Tipe:** `string`
-- **Details:**
+- **Detil:**
- A string template to be used as the markup for the Vue instance. The template will **replace** the mounted element. Any existing markup inside the mounted element will be ignored, unless content distribution slots are present in the template.
+ Templat string yang akan digunakan sebagai markup untuk _instance_ Vue. Template akan **menggantikan** elemen yang dipasang. Markup apa pun yang ada di dalam elemen yang dipasang akan diabaikan, kecuali jika slot distribusi konten ada dalam template.
- If the string starts with `#` it will be used as a querySelector and use the selected element's innerHTML as the template string. This allows the use of the common `
{% endraw %}
- Using `$emit` with additional arguments:
+ Menggunakan `$emit` dengan argumen tambahan:
```js
- Vue.component('magic-eight-ball', {
+ Vue.component('pemberi-saran', {
data: function () {
return {
- possibleAdvice: ['Yes', 'No', 'Maybe']
+ opsiSaran: ['Ya', 'Tidak', 'Mungkin']
}
},
methods: {
- giveAdvice: function () {
- var randomAdviceIndex = Math.floor(Math.random() * this.possibleAdvice.length)
- this.$emit('give-advice', this.possibleAdvice[randomAdviceIndex])
+ beriSaran: function () {
+ var indeksSaranAcak = Math.floor(Math.random() * this.opsiSaran.length)
+ this.$emit('beri-saran', this.opsiSaran[indeksSaranAcak])
}
},
template: `
-
