From 7c286e9e3ba1ac847274109bb86bf0a57a66c72f Mon Sep 17 00:00:00 2001
From: aisy <aisymuhammad@gmail.com>
Date: Sat, 9 Feb 2019 16:59:01 +0700
Subject: [PATCH 1/8] menerjemahkan konten list & key

---
 content/docs/lists-and-keys.md | 86 +++++++++++++++++++---------------
 1 file changed, 48 insertions(+), 38 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index c82739a6a..e6f23627c 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -1,14 +1,15 @@
 ---
 id: lists-and-keys
-title: Lists and Keys
+title: Lists dan Key
 permalink: docs/lists-and-keys.html
 prev: conditional-rendering.html
 next: forms.html
 ---
 
-First, let's review how you transform lists in JavaScript.
+Pertama-tama, mari kita tinjau kembali bagaimana anda dapat mentransformasi list di JavaScript.
 
-Given the code below, we use the [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) function to take an array of `numbers` and double their values. We assign the new array returned by `map()` to the variable `doubled` and log it:
+Jika melihat kode di bawah, kita menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) untuk mengambil array `numbers` dan menggandakan nilainya.
+Kita akan menaruh array baru yang dikembalikan oleh `map()` ke dalam sebuah variabel `doubled` dan me-log-nya:
 
 ```javascript{2}
 const numbers = [1, 2, 3, 4, 5];
@@ -16,15 +17,17 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-This code logs `[2, 4, 6, 8, 10]` to the console.
+Kode ini akan me-log `[2,4,6,8,10]` ke dalam console.
 
 In React, transforming arrays into lists of [elements](/docs/rendering-elements.html) is nearly identical.
 
-### Rendering Multiple Components {#rendering-multiple-components}
+### Me-render Banyak Komponen {#rendering-multiple-components}
 
-You can build collections of elements and [include them in JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) using curly braces `{}`.
+Anda dapat membangun koleksi beberapa elemen dan [menyertakannya dalam JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) menggunakan tanda kurung kurawal `{}`.
 
-Below, we loop through the `numbers` array using the JavaScript [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) function. We return a `<li>` element for each item. Finally, we assign the resulting array of elements to `listItems`:
+Di bawah ini, kita loop melalui array `numbers` menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) JavaScript.
+Kita akan mengembalikan elemen `<li>` untuk setiap item.
+Akhirnya, kita akan menetapkan array elemen dari hasil proses tersebut ke dalam `listItems`:
 
 ```javascript{2-4}
 const numbers = [1, 2, 3, 4, 5];
@@ -33,7 +36,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-We include the entire `listItems` array inside a `<ul>` element, and [render it to the DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
+Kita akan menyertakan seluruh array `listItems` ke dalam elemen `<ul>`, dan [me-render-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
 
 ```javascript{2}
 ReactDOM.render(
@@ -42,15 +45,15 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
+[**Coba di CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
-This code displays a bullet list of numbers between 1 and 5.
+Kode ini akan menampilkan sebuah list bullet dari angka 1 sampai 5
 
-### Basic List Component {#basic-list-component}
+### List Komponen Dasar {#basic-list-component}
 
-Usually you would render lists inside a [component](/docs/components-and-props.html).
+Biasanya anda akan me-render list di dalam sebuah [component](/docs/components-and-props.html).
 
-We can refactor the previous example into a component that accepts an array of `numbers` and outputs an unordered list of elements.
+Kita bisa merefaktor contoh sebelumnya kedalam sebuah komponen yang menerima array `numbers` dan mengeluarkan sebuah list elemen yang tidak berurutan 
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -70,9 +73,9 @@ ReactDOM.render(
 );
 ```
 
-When you run this code, you'll be given a warning that a key should be provided for list items. A "key" is a special string attribute you need to include when creating lists of elements. We'll discuss why it's important in the next section.
+Ketika anda menjalankan code ini, anda akan mendapatkan peringatan bahwa key harus disediakan untuk item di dalam list. Sebuah "key" adalah atribut string spesial yang perlu anda sertakan dalam pembuatan list elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya
 
-Let's assign a `key` to our list items inside `numbers.map()` and fix the missing key issue.
+Mari kita sertakan `key` ke dalam list item kita pada `numbers.map()` dan memperbaiki masalah key yang hilang.
 
 ```javascript{4}
 function NumberList(props) {
@@ -94,11 +97,11 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
+[**Coba di CodePen**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
 ## Keys {#keys}
 
-Keys help React identify which items have changed, are added, or are removed. Keys should be given to the elements inside the array to give the elements a stable identity:
+Key membantu React untuk mengidentifikasi item mana yang telah diubah, ditambahkan, atau dihilangkan. Key harus diberikan di dalam elemen yang terdapat di dalam sebuah array untuk memberikan elemen tersebut identitas yang stabil:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -109,7 +112,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-The best way to pick a key is to use a string that uniquely identifies a list item among its siblings. Most often you would use IDs from your data as keys:
+Cara terbaik untuk menentukan key yang akan digunakan adalah menggunakan string unik untuk mengidentifikasikan item dalam sebuah list dari item-item lain yang menjadi saudaranya. Seringkali anda akan menggunakan ID dari data anda sebagai key:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -119,34 +122,36 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-When you don't have stable IDs for rendered items, you may use the item index as a key as a last resort:
+Ketika anda tidak memiliki ID yang stabil untuk me-render item, anda bisa menggunakan index dari item sebagai key sebagai key untuk pilihan terakhir:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
   // Only do this if items have no stable IDs
+  // Hanya lakukan ini jika item tidak memiliki ID yang stabil
   <li key={index}>
     {todo.text}
   </li>
 );
 ```
 
-We don't recommend using indexes for keys if the order of items may change. This can negatively impact performance and may cause issues with component state. Check out Robin Pokorny's article for an [in-depth explanation on the negative impacts of using an index as a key](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). If you choose not to assign an explicit key to list items then React will default to using indexes as keys.
+Kami tidak merekomendasikan menggunakan indeks untuk key jika urutan item nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan state komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan index sebagai key](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan key pada list item maka React secara bawaan akan menggunakan indeks sebagai key.
 
-Here is an [in-depth explanation about why keys are necessary](/docs/reconciliation.html#recursing-on-children) if you're interested in learning more.
+Berikut adalah [penjelasan lebih dalam tentang kenapa key sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
 
-### Extracting Components with Keys {#extracting-components-with-keys}
+### Mengextrak Komponen dengan Key {#extracting-components-with-keys}
 
-Keys only make sense in the context of the surrounding array.
+Key hanya akan di gunakan di konteks array yang mengurung item dengan key tersebut
 
-For example, if you [extract](/docs/components-and-props.html#extracting-components) a `ListItem` component, you should keep the key on the `<ListItem />` elements in the array rather than on the `<li>` element in the `ListItem` itself.
+Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan key pada elemen `<ListItem />` di dalam array daripada di elemen `<li>` yang ada pada `ListItem`. 
 
-**Example: Incorrect Key Usage**
+**Contoh: Penggunaan Key yang Salah**
 
 ```javascript{4,5,14,15}
 function ListItem(props) {
   const value = props.value;
   return (
     // Wrong! There is no need to specify the key here:
+    // Salah! Tidak diperlukan untuk menentukan key disini:
     <li key={value.toString()}>
       {value}
     </li>
@@ -157,6 +162,7 @@ function NumberList(props) {
   const numbers = props.numbers;
   const listItems = numbers.map((number) =>
     // Wrong! The key should have been specified here:
+    // Salah! Key seharusnya ditentukan disini:
     <ListItem value={number} />
   );
   return (
@@ -173,11 +179,12 @@ ReactDOM.render(
 );
 ```
 
-**Example: Correct Key Usage**
+**Contoh: Penggunaan Key yang Benar**
 
 ```javascript{2,3,9,10}
 function ListItem(props) {
   // Correct! There is no need to specify the key here:
+  // Betul! Karena tidak perlu menentukan key disini:
   return <li>{props.value}</li>;
 }
 
@@ -185,6 +192,7 @@ function NumberList(props) {
   const numbers = props.numbers;
   const listItems = numbers.map((number) =>
     // Correct! Key should be specified inside the array.
+    // Betul! Key harus ditentukan di dalam array
     <ListItem key={number.toString()}
               value={number} />
   );
@@ -202,13 +210,14 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
+[**Coba di CodePen**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
 
-A good rule of thumb is that elements inside the `map()` call need keys.
+Sebuah aturan yang mudah diingat adalah elemen di dalam pemanggilan `map()` akan membutuhkan key.
 
-### Keys Must Only Be Unique Among Siblings {#keys-must-only-be-unique-among-siblings}
+### Key Harus Bersifat Unik Diantara Saudaranya {#keys-must-only-be-unique-among-siblings}
 
-Keys used within arrays should be unique among their siblings. However they don't need to be globally unique. We can use the same keys when we produce two different arrays:
+
+Key digunakan didalam array harus bersifat unik di antara saudaranya. Namun mereka tidak perlu unik secara global. Kita dapat menggunakan key yang sama ketika kita menghasilkan dua array yang berbeda:
 
 ```js{2,5,11,12,19,21}
 function Blog(props) {
@@ -246,9 +255,9 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
+[**Coba di CodePen**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-Keys serve as a hint to React but they don't get passed to your components. If you need the same value in your component, pass it explicitly as a prop with a different name:
+Key berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen anda. Jika anda membutuhkan nilai yang sama di dalam komponen anda, oper secara eksplisit sebagai sebuah prop dengan nama yang berbeda:
 
 ```js{3,4}
 const content = posts.map((post) =>
@@ -259,11 +268,11 @@ const content = posts.map((post) =>
 );
 ```
 
-With the example above, the `Post` component can read `props.id`, but not `props.key`.
+Dengan contoh diatas, komponen `Post` dapat membaca `props.id`, bukan `props.key`.
 
-### Embedding map() in JSX {#embedding-map-in-jsx}
+### Menanamkan map() pada JSX {#embedding-map-in-jsx}
 
-In the examples above we declared a separate `listItems` variable and included it in JSX:
+Pada contoh diatas kita mendeklarasikan variabel terpisah `listItems` dan memasukkannya ke dalam JSX:
 
 ```js{3-6}
 function NumberList(props) {
@@ -280,7 +289,7 @@ function NumberList(props) {
 }
 ```
 
-JSX allows [embedding any expression](/docs/introducing-jsx.html#embedding-expressions-in-jsx) in curly braces so we could inline the `map()` result:
+JSX memperbolehkan [menanamkan ekspresi](/docs/introducing-jsx.html#embedding-expressions-in-jsx) di dalam tanda kurung kurawal oleh karenanya kita dapat memasukkan hasil `map()` secaran inline:
 
 ```js{5-8}
 function NumberList(props) {
@@ -296,6 +305,7 @@ function NumberList(props) {
 }
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
+[**Coba di CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
-Sometimes this results in clearer code, but this style can also be abused. Like in JavaScript, it is up to you to decide whether it is worth extracting a variable for readability. Keep in mind that if the `map()` body is too nested, it might be a good time to [extract a component](/docs/components-and-props.html#extracting-components).
+Terkadang penulisan seperti ini akan menghasilkan kode yang lebih jelas, namun cara seperti ini juga dapat disalahgunakan.
+Seperti di JavaScript, menjadi pilihan anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah di baca penting bagi anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
\ No newline at end of file

From 38de32c2afda048476dfb25583240d132abad9ba Mon Sep 17 00:00:00 2001
From: aisy <aisymuhammad@gmail.com>
Date: Mon, 11 Feb 2019 22:26:45 +0700
Subject: [PATCH 2/8] fix glosary and some text not translated

---
 content/docs/lists-and-keys.md | 71 ++++++++++++++++------------------
 1 file changed, 34 insertions(+), 37 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index e6f23627c..6d0fbaa4d 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -1,15 +1,15 @@
 ---
 id: lists-and-keys
-title: Lists dan Key
+title: Lists dan Keys
 permalink: docs/lists-and-keys.html
 prev: conditional-rendering.html
 next: forms.html
 ---
 
-Pertama-tama, mari kita tinjau kembali bagaimana anda dapat mentransformasi list di JavaScript.
+Pertama-tama, mari kita tinjau kembali bagaimana anda dapat mentransformasi *list* di JavaScript.
 
 Jika melihat kode di bawah, kita menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) untuk mengambil array `numbers` dan menggandakan nilainya.
-Kita akan menaruh array baru yang dikembalikan oleh `map()` ke dalam sebuah variabel `doubled` dan me-log-nya:
+Kita akan menaruh array baru yang dikembalikan oleh `map()` ke dalam sebuah variabel `doubled` dan me-*log*-nya:
 
 ```javascript{2}
 const numbers = [1, 2, 3, 4, 5];
@@ -17,13 +17,14 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-Kode ini akan me-log `[2,4,6,8,10]` ke dalam console.
+Kode ini akan me-*log* `[2,4,6,8,10]` ke dalam konsol.
 
-In React, transforming arrays into lists of [elements](/docs/rendering-elements.html) is nearly identical.
+<!-- In React, transforming arrays into lists of [elements](/docs/rendering-elements.html) is nearly identical. -->
+Di React, mengubah array ke dalam *list* [elemen](/docs/rendering-elements.html) kurang lebih sama.
 
-### Me-render Banyak Komponen {#rendering-multiple-components}
+### Me-*render* Banyak Komponen {#rendering-multiple-components}
 
-Anda dapat membangun koleksi beberapa elemen dan [menyertakannya dalam JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) menggunakan tanda kurung kurawal `{}`.
+Anda dapat membangun koleksi dari beberapa elemen dan [menyertakannya dalam JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) menggunakan tanda kurung kurawal `{}`.
 
 Di bawah ini, kita loop melalui array `numbers` menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) JavaScript.
 Kita akan mengembalikan elemen `<li>` untuk setiap item.
@@ -36,7 +37,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-Kita akan menyertakan seluruh array `listItems` ke dalam elemen `<ul>`, dan [me-render-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
+Kita akan menyertakan seluruh array `listItems` ke dalam elemen `<ul>`, dan [me-*render*-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
 
 ```javascript{2}
 ReactDOM.render(
@@ -47,13 +48,13 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
-Kode ini akan menampilkan sebuah list bullet dari angka 1 sampai 5
+Kode ini akan menampilkan sebuah *list* bullet dari angka 1 sampai 5
 
-### List Komponen Dasar {#basic-list-component}
+### *List* Komponen Dasar {#basic-list-component}
 
-Biasanya anda akan me-render list di dalam sebuah [component](/docs/components-and-props.html).
+Biasanya anda akan me-*render* *list* di dalam sebuah [komponen](/docs/components-and-props.html).
 
-Kita bisa merefaktor contoh sebelumnya kedalam sebuah komponen yang menerima array `numbers` dan mengeluarkan sebuah list elemen yang tidak berurutan 
+Kita bisa merefaktor contoh sebelumnya kedalam sebuah komponen yang menerima array `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan 
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -73,9 +74,9 @@ ReactDOM.render(
 );
 ```
 
-Ketika anda menjalankan code ini, anda akan mendapatkan peringatan bahwa key harus disediakan untuk item di dalam list. Sebuah "key" adalah atribut string spesial yang perlu anda sertakan dalam pembuatan list elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya
+Ketika anda menjalankan code ini, anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk item di dalam *list*. Sebuah "*key*" adalah atribut string spesial yang perlu anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya
 
-Mari kita sertakan `key` ke dalam list item kita pada `numbers.map()` dan memperbaiki masalah key yang hilang.
+Mari kita sertakan `*key*` ke dalam *list* item kita pada `numbers.map()` dan memperbaiki masalah *key* yang hilang.
 
 ```javascript{4}
 function NumberList(props) {
@@ -99,9 +100,9 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
-## Keys {#keys}
+## *Key* {#keys}
 
-Key membantu React untuk mengidentifikasi item mana yang telah diubah, ditambahkan, atau dihilangkan. Key harus diberikan di dalam elemen yang terdapat di dalam sebuah array untuk memberikan elemen tersebut identitas yang stabil:
+*Key* membantu React untuk mengidentifikasi item mana yang telah diubah, ditambahkan, atau dihilangkan. *Key* harus diberikan di dalam elemen yang terdapat di dalam sebuah array untuk memberikan elemen tersebut identitas yang stabil:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -112,7 +113,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-Cara terbaik untuk menentukan key yang akan digunakan adalah menggunakan string unik untuk mengidentifikasikan item dalam sebuah list dari item-item lain yang menjadi saudaranya. Seringkali anda akan menggunakan ID dari data anda sebagai key:
+Cara terbaik untuk menentukan *key* yang akan digunakan adalah menggunakan string unik untuk mengidentifikasikan item dalam sebuah *list* dari item-item lain yang menjadi saudaranya. Seringkali anda akan menggunakan ID dari data anda sebagai *key*:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -122,7 +123,7 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-Ketika anda tidak memiliki ID yang stabil untuk me-render item, anda bisa menggunakan index dari item sebagai key sebagai key untuk pilihan terakhir:
+Ketika anda tidak memiliki ID yang stabil untuk me-*render* item, anda bisa menggunakan index dari item sebagai *key* sebagai *key* untuk pilihan terakhir:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
@@ -134,24 +135,23 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-Kami tidak merekomendasikan menggunakan indeks untuk key jika urutan item nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan state komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan index sebagai key](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan key pada list item maka React secara bawaan akan menggunakan indeks sebagai key.
+Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan item nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan state komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan index sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list* item maka React secara bawaan akan menggunakan indeks sebagai *key*.
 
-Berikut adalah [penjelasan lebih dalam tentang kenapa key sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
+Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
 
-### Mengextrak Komponen dengan Key {#extracting-components-with-keys}
+### Mengekstrak Komponen dengan *Key* {#extracting-components-with-keys}
 
-Key hanya akan di gunakan di konteks array yang mengurung item dengan key tersebut
+*Key* hanya akan di gunakan di konteks array yang mengurung item dengan *key* tersebut
 
-Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan key pada elemen `<ListItem />` di dalam array daripada di elemen `<li>` yang ada pada `ListItem`. 
+Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam array daripada di elemen `<li>` yang ada pada `ListItem`. 
 
-**Contoh: Penggunaan Key yang Salah**
+**Contoh: Penggunaan *Key* yang Salah**
 
 ```javascript{4,5,14,15}
 function ListItem(props) {
   const value = props.value;
   return (
-    // Wrong! There is no need to specify the key here:
-    // Salah! Tidak diperlukan untuk menentukan key disini:
+    // Salah! Tidak diperlukan untuk menentukan *key* disini:
     <li key={value.toString()}>
       {value}
     </li>
@@ -161,8 +161,7 @@ function ListItem(props) {
 function NumberList(props) {
   const numbers = props.numbers;
   const listItems = numbers.map((number) =>
-    // Wrong! The key should have been specified here:
-    // Salah! Key seharusnya ditentukan disini:
+    // Salah! *Key* seharusnya ditentukan disini:
     <ListItem value={number} />
   );
   return (
@@ -179,20 +178,18 @@ ReactDOM.render(
 );
 ```
 
-**Contoh: Penggunaan Key yang Benar**
+**Contoh: Penggunaan *Key* yang Benar**
 
 ```javascript{2,3,9,10}
 function ListItem(props) {
-  // Correct! There is no need to specify the key here:
-  // Betul! Karena tidak perlu menentukan key disini:
+  // Betul! Karena tidak perlu menentukan *key* disini:
   return <li>{props.value}</li>;
 }
 
 function NumberList(props) {
   const numbers = props.numbers;
   const listItems = numbers.map((number) =>
-    // Correct! Key should be specified inside the array.
-    // Betul! Key harus ditentukan di dalam array
+    // Betul! *Key* harus ditentukan di dalam array
     <ListItem key={number.toString()}
               value={number} />
   );
@@ -212,12 +209,12 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
 
-Sebuah aturan yang mudah diingat adalah elemen di dalam pemanggilan `map()` akan membutuhkan key.
+Sebuah aturan yang mudah diingat adalah elemen di dalam pemanggilan `map()` akan membutuhkan *key*.
 
-### Key Harus Bersifat Unik Diantara Saudaranya {#keys-must-only-be-unique-among-siblings}
+### *Key* Harus Bersifat Unik Diantara Saudaranya {#keys-must-only-be-unique-among-siblings}
 
 
-Key digunakan didalam array harus bersifat unik di antara saudaranya. Namun mereka tidak perlu unik secara global. Kita dapat menggunakan key yang sama ketika kita menghasilkan dua array yang berbeda:
+Key digunakan didalam array harus bersifat unik di antara saudaranya. Namun mereka tidak perlu unik secara global. Kita dapat menggunakan *key* yang sama ketika kita menghasilkan dua array yang berbeda:
 
 ```js{2,5,11,12,19,21}
 function Blog(props) {
@@ -257,7 +254,7 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-Key berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen anda. Jika anda membutuhkan nilai yang sama di dalam komponen anda, oper secara eksplisit sebagai sebuah prop dengan nama yang berbeda:
+*Key* berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen anda. Jika anda membutuhkan nilai yang sama di dalam komponen anda, oper secara eksplisit sebagai sebuah prop dengan nama yang berbeda:
 
 ```js{3,4}
 const content = posts.map((post) =>

From 760e6e0dd7828ee76f9c32f6f66fda347838277e Mon Sep 17 00:00:00 2001
From: aisy <aisymuhammad@gmail.com>
Date: Wed, 13 Feb 2019 20:57:10 +0700
Subject: [PATCH 3/8] fix the wrong words that compared with glossary

---
 content/docs/lists-and-keys.md | 43 +++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 6d0fbaa4d..62bea5c83 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -8,8 +8,8 @@ next: forms.html
 
 Pertama-tama, mari kita tinjau kembali bagaimana anda dapat mentransformasi *list* di JavaScript.
 
-Jika melihat kode di bawah, kita menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) untuk mengambil array `numbers` dan menggandakan nilainya.
-Kita akan menaruh array baru yang dikembalikan oleh `map()` ke dalam sebuah variabel `doubled` dan me-*log*-nya:
+Jika melihat kode di bawah, kita menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) untuk mengambil senarai `numbers` dan menggandakan nilainya.
+Kita akan menaruh senarai baru yang dikembalikan oleh `map()` ke dalam sebuah variabel `doubled` dan me-*log*-nya:
 
 ```javascript{2}
 const numbers = [1, 2, 3, 4, 5];
@@ -19,16 +19,15 @@ console.log(doubled);
 
 Kode ini akan me-*log* `[2,4,6,8,10]` ke dalam konsol.
 
-<!-- In React, transforming arrays into lists of [elements](/docs/rendering-elements.html) is nearly identical. -->
-Di React, mengubah array ke dalam *list* [elemen](/docs/rendering-elements.html) kurang lebih sama.
+Di React, mengubah senarai ke dalam *list* [elemen](/docs/rendering-elements.html) kurang lebih sama.
 
 ### Me-*render* Banyak Komponen {#rendering-multiple-components}
 
 Anda dapat membangun koleksi dari beberapa elemen dan [menyertakannya dalam JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) menggunakan tanda kurung kurawal `{}`.
 
-Di bawah ini, kita loop melalui array `numbers` menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) JavaScript.
-Kita akan mengembalikan elemen `<li>` untuk setiap item.
-Akhirnya, kita akan menetapkan array elemen dari hasil proses tersebut ke dalam `listItems`:
+Di bawah ini, kita perulangan melalui senarai `numbers` menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) JavaScript.
+Kita akan mengembalikan elemen `<li>` untuk setiap *item*.
+Akhirnya, kita akan menetapkan senarai elemen dari hasil proses tersebut ke dalam `listItems`:
 
 ```javascript{2-4}
 const numbers = [1, 2, 3, 4, 5];
@@ -37,7 +36,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-Kita akan menyertakan seluruh array `listItems` ke dalam elemen `<ul>`, dan [me-*render*-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
+Kita akan menyertakan seluruh senarai `listItems` ke dalam elemen `<ul>`, dan [me-*render*-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
 
 ```javascript{2}
 ReactDOM.render(
@@ -48,13 +47,13 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
-Kode ini akan menampilkan sebuah *list* bullet dari angka 1 sampai 5
+Kode ini akan menampilkan sebuah *list bullet* dari angka 1 sampai 5.
 
 ### *List* Komponen Dasar {#basic-list-component}
 
-Biasanya anda akan me-*render* *list* di dalam sebuah [komponen](/docs/components-and-props.html).
+Biasanya anda akan me-*render list* di dalam sebuah [komponen](/docs/components-and-props.html).
 
-Kita bisa merefaktor contoh sebelumnya kedalam sebuah komponen yang menerima array `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan 
+Kita bisa merefaktor contoh sebelumnya kedalam sebuah komponen yang menerima senarai `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan. 
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -74,7 +73,7 @@ ReactDOM.render(
 );
 ```
 
-Ketika anda menjalankan code ini, anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk item di dalam *list*. Sebuah "*key*" adalah atribut string spesial yang perlu anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya
+Ketika anda menjalankan kode ini, anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk *item* di dalam *list*. Sebuah "*key*" adalah atribut *string* spesial yang perlu anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya.
 
 Mari kita sertakan `*key*` ke dalam *list* item kita pada `numbers.map()` dan memperbaiki masalah *key* yang hilang.
 
@@ -102,7 +101,7 @@ ReactDOM.render(
 
 ## *Key* {#keys}
 
-*Key* membantu React untuk mengidentifikasi item mana yang telah diubah, ditambahkan, atau dihilangkan. *Key* harus diberikan di dalam elemen yang terdapat di dalam sebuah array untuk memberikan elemen tersebut identitas yang stabil:
+*Key* membantu React untuk mengidentifikasi *item* mana yang telah diubah, ditambahkan, atau dihilangkan. *Key* harus diberikan di dalam elemen yang terdapat di dalam sebuah senarai untuk memberikan elemen tersebut identitas yang stabil:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -113,7 +112,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-Cara terbaik untuk menentukan *key* yang akan digunakan adalah menggunakan string unik untuk mengidentifikasikan item dalam sebuah *list* dari item-item lain yang menjadi saudaranya. Seringkali anda akan menggunakan ID dari data anda sebagai *key*:
+Cara terbaik untuk menentukan *key* yang akan digunakan adalah menggunakan *string* unik untuk mengidentifikasikan *item* dalam sebuah *list* dari *list item* lain yang menjadi saudaranya. Seringkali anda akan menggunakan ID dari data anda sebagai *key*:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -123,7 +122,7 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-Ketika anda tidak memiliki ID yang stabil untuk me-*render* item, anda bisa menggunakan index dari item sebagai *key* sebagai *key* untuk pilihan terakhir:
+Ketika anda tidak memiliki ID yang stabil untuk me-*render item*, anda bisa menggunakan index dari *item* sebagai *key* untuk pilihan terakhir:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
@@ -135,15 +134,15 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan item nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan state komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan index sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list* item maka React secara bawaan akan menggunakan indeks sebagai *key*.
+Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan state komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan index sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
 
 Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
 
 ### Mengekstrak Komponen dengan *Key* {#extracting-components-with-keys}
 
-*Key* hanya akan di gunakan di konteks array yang mengurung item dengan *key* tersebut
+*Key* hanya akan di gunakan di konteks senarai yang mengurung *item* dengan *key* tersebut.
 
-Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam array daripada di elemen `<li>` yang ada pada `ListItem`. 
+Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
 
 **Contoh: Penggunaan *Key* yang Salah**
 
@@ -182,14 +181,14 @@ ReactDOM.render(
 
 ```javascript{2,3,9,10}
 function ListItem(props) {
-  // Betul! Karena tidak perlu menentukan *key* disini:
+  // Benar! Karena tidak perlu menentukan *key* disini:
   return <li>{props.value}</li>;
 }
 
 function NumberList(props) {
   const numbers = props.numbers;
   const listItems = numbers.map((number) =>
-    // Betul! *Key* harus ditentukan di dalam array
+    // Benar! *Key* harus ditentukan di dalam senarai
     <ListItem key={number.toString()}
               value={number} />
   );
@@ -214,7 +213,7 @@ Sebuah aturan yang mudah diingat adalah elemen di dalam pemanggilan `map()` akan
 ### *Key* Harus Bersifat Unik Diantara Saudaranya {#keys-must-only-be-unique-among-siblings}
 
 
-Key digunakan didalam array harus bersifat unik di antara saudaranya. Namun mereka tidak perlu unik secara global. Kita dapat menggunakan *key* yang sama ketika kita menghasilkan dua array yang berbeda:
+*Key* digunakan didalam senarai harus bersifat unik di antara saudaranya. Namun mereka tidak perlu unik secara global. Kita dapat menggunakan *key* yang sama ketika kita menghasilkan dua senarai yang berbeda:
 
 ```js{2,5,11,12,19,21}
 function Blog(props) {
@@ -265,7 +264,7 @@ const content = posts.map((post) =>
 );
 ```
 
-Dengan contoh diatas, komponen `Post` dapat membaca `props.id`, bukan `props.key`.
+Dengan contoh di atas, komponen `Post` dapat membaca `props.id`, bukan `props.key`.
 
 ### Menanamkan map() pada JSX {#embedding-map-in-jsx}
 

From 6e5df1f2aafa6b6f350438d89cc3b7292f97068a Mon Sep 17 00:00:00 2001
From: aisy <aisymuhammad@gmail.com>
Date: Wed, 13 Feb 2019 22:28:51 +0700
Subject: [PATCH 4/8] fix loadnwords header and some word

---
 content/docs/lists-and-keys.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 62bea5c83..cd0e06caf 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -21,7 +21,7 @@ Kode ini akan me-*log* `[2,4,6,8,10]` ke dalam konsol.
 
 Di React, mengubah senarai ke dalam *list* [elemen](/docs/rendering-elements.html) kurang lebih sama.
 
-### Me-*render* Banyak Komponen {#rendering-multiple-components}
+### Me-render Banyak Komponen {#rendering-multiple-components}
 
 Anda dapat membangun koleksi dari beberapa elemen dan [menyertakannya dalam JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) menggunakan tanda kurung kurawal `{}`.
 
@@ -49,11 +49,11 @@ ReactDOM.render(
 
 Kode ini akan menampilkan sebuah *list bullet* dari angka 1 sampai 5.
 
-### *List* Komponen Dasar {#basic-list-component}
+### List Komponen Dasar {#basic-list-component}
 
 Biasanya anda akan me-*render list* di dalam sebuah [komponen](/docs/components-and-props.html).
 
-Kita bisa merefaktor contoh sebelumnya kedalam sebuah komponen yang menerima senarai `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan. 
+Kita bisa merefaktor contoh sebelumnya ke dalam sebuah komponen yang menerima senarai `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan. 
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -75,7 +75,7 @@ ReactDOM.render(
 
 Ketika anda menjalankan kode ini, anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk *item* di dalam *list*. Sebuah "*key*" adalah atribut *string* spesial yang perlu anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya.
 
-Mari kita sertakan `*key*` ke dalam *list* item kita pada `numbers.map()` dan memperbaiki masalah *key* yang hilang.
+Mari kita sertakan `*key*` ke dalam *list item* kita pada `numbers.map()` dan memperbaiki masalah *key* yang hilang.
 
 ```javascript{4}
 function NumberList(props) {
@@ -99,7 +99,7 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
-## *Key* {#keys}
+## Key {#keys}
 
 *Key* membantu React untuk mengidentifikasi *item* mana yang telah diubah, ditambahkan, atau dihilangkan. *Key* harus diberikan di dalam elemen yang terdapat di dalam sebuah senarai untuk memberikan elemen tersebut identitas yang stabil:
 
@@ -122,25 +122,25 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-Ketika anda tidak memiliki ID yang stabil untuk me-*render item*, anda bisa menggunakan index dari *item* sebagai *key* untuk pilihan terakhir:
+Ketika anda tidak memiliki ID yang stabil untuk me-*render item*, anda bisa menggunakan indexs dari *item* sebagai *key* untuk pilihan terakhir:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
   // Only do this if items have no stable IDs
-  // Hanya lakukan ini jika item tidak memiliki ID yang stabil
+  // Hanya lakukan ini jika *item* tidak memiliki ID yang stabil
   <li key={index}>
     {todo.text}
   </li>
 );
 ```
 
-Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan state komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan index sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
+Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan *state* komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan indexs sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
 
 Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
 
-### Mengekstrak Komponen dengan *Key* {#extracting-components-with-keys}
+### Mengekstrak Komponen dengan Key {#extracting-components-with-keys}
 
-*Key* hanya akan di gunakan di konteks senarai yang mengurung *item* dengan *key* tersebut.
+*Key* hanya perlu digunakan di dalam konteks senarai yang mengurung *item* dengan *key* tersebut.
 
 Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
 
@@ -210,7 +210,7 @@ ReactDOM.render(
 
 Sebuah aturan yang mudah diingat adalah elemen di dalam pemanggilan `map()` akan membutuhkan *key*.
 
-### *Key* Harus Bersifat Unik Diantara Saudaranya {#keys-must-only-be-unique-among-siblings}
+### Key Harus Bersifat Unik Diantara Saudaranya {#keys-must-only-be-unique-among-siblings}
 
 
 *Key* digunakan didalam senarai harus bersifat unik di antara saudaranya. Namun mereka tidak perlu unik secara global. Kita dapat menggunakan *key* yang sama ketika kita menghasilkan dua senarai yang berbeda:
@@ -253,7 +253,7 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-*Key* berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen anda. Jika anda membutuhkan nilai yang sama di dalam komponen anda, oper secara eksplisit sebagai sebuah prop dengan nama yang berbeda:
+*Key* berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen anda. Jika anda membutuhkan nilai yang sama di dalam komponen anda, oper secara eksplisit sebagai sebuah *props* dengan nama yang berbeda:
 
 ```js{3,4}
 const content = posts.map((post) =>
@@ -268,7 +268,7 @@ Dengan contoh di atas, komponen `Post` dapat membaca `props.id`, bukan `props.ke
 
 ### Menanamkan map() pada JSX {#embedding-map-in-jsx}
 
-Pada contoh diatas kita mendeklarasikan variabel terpisah `listItems` dan memasukkannya ke dalam JSX:
+Pada contoh di atas kita mendeklarasikan variabel terpisah `listItems` dan memasukkannya ke dalam JSX:
 
 ```js{3-6}
 function NumberList(props) {
@@ -285,7 +285,7 @@ function NumberList(props) {
 }
 ```
 
-JSX memperbolehkan [menanamkan ekspresi](/docs/introducing-jsx.html#embedding-expressions-in-jsx) di dalam tanda kurung kurawal oleh karenanya kita dapat memasukkan hasil `map()` secaran inline:
+JSX memperbolehkan [menanamkan ekspresi](/docs/introducing-jsx.html#embedding-expressions-in-jsx) di dalam tanda kurung kurawal oleh karenanya kita dapat memasukkan hasil `map()` secara *inline*:
 
 ```js{5-8}
 function NumberList(props) {

From 4afd27c5e5fdd23262bda4984864cd8401071705 Mon Sep 17 00:00:00 2001
From: aisy <aisymuhammad@gmail.com>
Date: Fri, 15 Feb 2019 16:15:35 +0700
Subject: [PATCH 5/8] fix typo word and capitalize some word

---
 content/docs/lists-and-keys.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index cd0e06caf..eec293139 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -51,7 +51,7 @@ Kode ini akan menampilkan sebuah *list bullet* dari angka 1 sampai 5.
 
 ### List Komponen Dasar {#basic-list-component}
 
-Biasanya anda akan me-*render list* di dalam sebuah [komponen](/docs/components-and-props.html).
+Biasanya Anda akan me-*render list* di dalam sebuah [komponen](/docs/components-and-props.html).
 
 Kita bisa merefaktor contoh sebelumnya ke dalam sebuah komponen yang menerima senarai `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan. 
 
@@ -73,7 +73,7 @@ ReactDOM.render(
 );
 ```
 
-Ketika anda menjalankan kode ini, anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk *item* di dalam *list*. Sebuah "*key*" adalah atribut *string* spesial yang perlu anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya.
+Ketika Anda menjalankan kode ini, Anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk *item* di dalam *list*. Sebuah "*key*" adalah atribut *string* spesial yang perlu Anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya.
 
 Mari kita sertakan `*key*` ke dalam *list item* kita pada `numbers.map()` dan memperbaiki masalah *key* yang hilang.
 
@@ -112,7 +112,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-Cara terbaik untuk menentukan *key* yang akan digunakan adalah menggunakan *string* unik untuk mengidentifikasikan *item* dalam sebuah *list* dari *list item* lain yang menjadi saudaranya. Seringkali anda akan menggunakan ID dari data anda sebagai *key*:
+Cara terbaik untuk menentukan *key* yang akan digunakan adalah menggunakan *string* unik untuk mengidentifikasikan *item* dalam sebuah *list* dari *list item* lain yang menjadi saudaranya. Seringkali Anda akan menggunakan ID dari data Anda sebagai *key*:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -122,7 +122,7 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-Ketika anda tidak memiliki ID yang stabil untuk me-*render item*, anda bisa menggunakan indexs dari *item* sebagai *key* untuk pilihan terakhir:
+Ketika Anda tidak memiliki ID yang stabil untuk me-*render item*, Anda bisa menggunakan indeks dari *item* sebagai *key* untuk pilihan terakhir:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
@@ -134,7 +134,7 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan *state* komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan indexs sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
+Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan *state* komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan indeks sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
 
 Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
 
@@ -142,7 +142,7 @@ Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/
 
 *Key* hanya perlu digunakan di dalam konteks senarai yang mengurung *item* dengan *key* tersebut.
 
-Sebagai contoh, jika anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
+Sebagai contoh, jika Anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
 
 **Contoh: Penggunaan *Key* yang Salah**
 
@@ -253,7 +253,7 @@ ReactDOM.render(
 
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-*Key* berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen anda. Jika anda membutuhkan nilai yang sama di dalam komponen anda, oper secara eksplisit sebagai sebuah *props* dengan nama yang berbeda:
+*Key* berfungsi sebagai petunjuk bagi React namun mereka tidak akan muncul di komponen Anda. Jika Anda membutuhkan nilai yang sama di dalam komponen Anda, oper secara eksplisit sebagai sebuah *props* dengan nama yang berbeda:
 
 ```js{3,4}
 const content = posts.map((post) =>
@@ -304,4 +304,4 @@ function NumberList(props) {
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
 Terkadang penulisan seperti ini akan menghasilkan kode yang lebih jelas, namun cara seperti ini juga dapat disalahgunakan.
-Seperti di JavaScript, menjadi pilihan anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah di baca penting bagi anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
\ No newline at end of file
+Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah di baca penting bagi anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
\ No newline at end of file

From eeb6a9d7b9d22447b7d09914f676e3f0256ffce9 Mon Sep 17 00:00:00 2001
From: Aisy Muhammad <aisymuhammad@gmail.com>
Date: Tue, 5 Mar 2019 20:28:32 +0700
Subject: [PATCH 6/8] fix some words

---
 content/docs/lists-and-keys.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index eec293139..0b99c74ab 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -6,7 +6,7 @@ prev: conditional-rendering.html
 next: forms.html
 ---
 
-Pertama-tama, mari kita tinjau kembali bagaimana anda dapat mentransformasi *list* di JavaScript.
+Pertama-tama, mari kita tinjau kembali bagaimana Anda dapat mentransformasi *list* di JavaScript.
 
 Jika melihat kode di bawah, kita menggunakan fungsi [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) untuk mengambil senarai `numbers` dan menggandakan nilainya.
 Kita akan menaruh senarai baru yang dikembalikan oleh `map()` ke dalam sebuah variabel `doubled` dan me-*log*-nya:
@@ -53,7 +53,7 @@ Kode ini akan menampilkan sebuah *list bullet* dari angka 1 sampai 5.
 
 Biasanya Anda akan me-*render list* di dalam sebuah [komponen](/docs/components-and-props.html).
 
-Kita bisa merefaktor contoh sebelumnya ke dalam sebuah komponen yang menerima senarai `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan. 
+Kita bisa melalukan *refaktor* contoh sebelumnya ke dalam sebuah komponen yang menerima senarai `numbers` dan mengeluarkan sebuah *list* elemen yang tidak berurutan.
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -134,15 +134,15 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan *state* komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan indeks sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
+Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan *state* komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan indeks sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika Anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
 
-Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika anda tertarik untuk belajar lebih lanjut.
+Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika Anda tertarik untuk belajar lebih lanjut.
 
 ### Mengekstrak Komponen dengan Key {#extracting-components-with-keys}
 
 *Key* hanya perlu digunakan di dalam konteks senarai yang mengurung *item* dengan *key* tersebut.
 
-Sebagai contoh, jika Anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
+Sebagai contoh, jika Anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, Anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
 
 **Contoh: Penggunaan *Key* yang Salah**
 
@@ -150,7 +150,7 @@ Sebagai contoh, jika Anda [mengekstrak](/docs/components-and-props.html#extracti
 function ListItem(props) {
   const value = props.value;
   return (
-    // Salah! Tidak diperlukan untuk menentukan *key* disini:
+    // Salah! Tidak diperlukan untuk menentukan *key* di sini:
     <li key={value.toString()}>
       {value}
     </li>
@@ -160,7 +160,7 @@ function ListItem(props) {
 function NumberList(props) {
   const numbers = props.numbers;
   const listItems = numbers.map((number) =>
-    // Salah! *Key* seharusnya ditentukan disini:
+    // Salah! *Key* seharusnya ditentukan di sini:
     <ListItem value={number} />
   );
   return (
@@ -181,7 +181,7 @@ ReactDOM.render(
 
 ```javascript{2,3,9,10}
 function ListItem(props) {
-  // Benar! Karena tidak perlu menentukan *key* disini:
+  // Benar! Karena tidak perlu menentukan *key* di sini:
   return <li>{props.value}</li>;
 }
 
@@ -304,4 +304,4 @@ function NumberList(props) {
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
 Terkadang penulisan seperti ini akan menghasilkan kode yang lebih jelas, namun cara seperti ini juga dapat disalahgunakan.
-Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah di baca penting bagi anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
\ No newline at end of file
+Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah dibaca penting bagi Anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
\ No newline at end of file

From 627ee2c45c83f7a9c9d431352a83b01fac0f8be7 Mon Sep 17 00:00:00 2001
From: Griko Nibras <grikomsn@gmail.com>
Date: Mon, 8 Jul 2019 02:52:33 +0700
Subject: [PATCH 7/8] Apply translation recommendation

---
 content/docs/lists-and-keys.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index c2f06c476..9c28edeb7 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -73,7 +73,7 @@ ReactDOM.render(
 );
 ```
 
-Ketika Anda menjalankan kode ini, Anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk *item* di dalam *list*. Sebuah "*key*" adalah atribut *string* spesial yang perlu Anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan kenapa ini penting di bagian berikutnya.
+Ketika Anda menjalankan kode ini, Anda akan mendapatkan peringatan bahwa *key* harus disediakan untuk *item* di dalam *list*. Sebuah "*key*" adalah atribut *string* spesial yang perlu Anda sertakan dalam pembuatan *list* elemen. Kita akan mendiskusikan mengapa ini penting di bagian berikutnya.
 
 Mari kita sertakan `*key*` ke dalam *list item* kita pada `numbers.map()` dan memperbaiki masalah *key* yang hilang.
 
@@ -142,7 +142,7 @@ Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/
 
 *Key* hanya perlu digunakan di dalam konteks senarai yang mengurung *item* dengan *key* tersebut.
 
-Sebagai contoh, jika Anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, Anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`. 
+Sebagai contoh, jika Anda [mengekstrak](/docs/components-and-props.html#extracting-components) sebuah komponen `ListItem`, Anda harus menyimpan *key* pada elemen `<ListItem />` di dalam senarai daripada di elemen `<li>` yang ada pada `ListItem`.
 
 **Contoh: Penggunaan *Key* yang Salah**
 
@@ -304,4 +304,4 @@ function NumberList(props) {
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
 Terkadang penulisan seperti ini akan menghasilkan kode yang lebih jelas, namun cara seperti ini juga dapat disalahgunakan.
-Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah dibaca penting bagi Anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
\ No newline at end of file
+Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah dibaca penting bagi Anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).

From 30cec9c24de4d4c7f46bee411dbcf92cbca986e4 Mon Sep 17 00:00:00 2001
From: Griko Nibras <grikomsn@gmail.com>
Date: Mon, 8 Jul 2019 02:57:42 +0700
Subject: [PATCH 8/8] Apply various translation recommendations

---
 content/docs/lists-and-keys.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 9c28edeb7..f5c5cf036 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -36,7 +36,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-Kita akan menyertakan seluruh senarai `listItems` ke dalam elemen `<ul>`, dan [me-*render*-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
+Kita akan menyertakan seluruh senarai `listItems` ke dalam elemen `<ul>` dan [me-*render*-nya ke dalam DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
 
 ```javascript{2}
 ReactDOM.render(
@@ -49,7 +49,7 @@ ReactDOM.render(
 
 Kode ini akan menampilkan sebuah *list bullet* dari angka 1 sampai 5.
 
-### List Komponen Dasar {#basic-list-component}
+### Daftar Komponen Dasar {#basic-list-component}
 
 Biasanya Anda akan me-*render list* di dalam sebuah [komponen](/docs/components-and-props.html).
 
@@ -136,7 +136,7 @@ const todoItems = todos.map((todo, index) =>
 
 Kami tidak merekomendasikan menggunakan indeks untuk *key* jika urutan *item* nantinya berubah. Ini berdampak negatif terhadap kinerja dan dapat menyebabkan masalah dengan *state* komponen. Simak artikel Robin Pokorny untuk [penjelasan lebih dalam mengenai dampak negatif penggunaan indeks sebagai *key*](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). Jika Anda memilih untuk tidak menetapkan *key* pada *list item* maka React secara bawaan akan menggunakan indeks sebagai *key*.
 
-Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika Anda tertarik untuk belajar lebih lanjut.
+Berikut adalah [penjelasan lebih dalam tentang kenapa *key* sangat diperlukan](/docs/reconciliation.html#recursing-on-children) Jika Anda tertarik untuk mempelajari lebih lanjut.
 
 ### Mengekstrak Komponen dengan Key {#extracting-components-with-keys}
 
@@ -304,4 +304,4 @@ function NumberList(props) {
 [**Coba di CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
 Terkadang penulisan seperti ini akan menghasilkan kode yang lebih jelas, namun cara seperti ini juga dapat disalahgunakan.
-Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah dibaca penting bagi Anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).
+Seperti di JavaScript, menjadi pilihan Anda apakah mengekstrak sebuah variabel tersendiri agar lebih mudah di baca penting bagi Anda. Perlu diingat bahwa jika di dalam `map()` terdapat banyak perulangan, bisa jadi ini adalah saat yang tepat untuk [mengekstrak sebuah komponen](/docs/components-and-props.html#extracting-components).