Merge pull request #42 from lanasta/master

Translations for js/data-types/map-set

Author: thickkoezz

1-js/05-data-types/07-map-set/01-array-unique-map/task.md

@@ -4,11 +4,11 @@ importance: 5
 
 # Filter unique array members
 
-Let `arr` be an array.
+Anggaplah `arr` sebagai sebuah array.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Ciptakanlah fungsi `unique(arr)` yang harus mengembalikan array yang berisi nilai-nilai unik dari `arr`.
 
-For instance:
+Sebagai contoh:
 
 ```js
 function unique(arr) {
@@ -22,6 +22,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
-P.S. Here strings are used, but can be values of any type.
+P.S. Disini string dipakai sebagai contoh, tetapi nilai dengan tipe apa saja bisa dipakai.
 
-P.P.S. Use `Set` to store unique values.
+P.P.S. Pakailah `Set` untuk menyimpan nilai-nilai yang unik.

1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md

@@ -1,6 +1,6 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+Untuk menemukan semua anagram, mari kita pecahkan setiap kata menjadi huruf-huruf dan urutkanlah. Ketika huruf-huruf terurut, semua anagram adalah sama. 
 
-For instance:
+Sebagai contoh:
 
 ```
 nap, pan -> anp
@@ -9,7 +9,7 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Kita akan menggunakan varian yang diurutkan berdasarkan huruf sebagai kunci map untuk menyimpan hanya satu nilai untuk setiap kunci:
 
 ```js run
 function aclean(arr) {
@@ -31,9 +31,9 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
+Penyortiran huruf dilakukan oleh deretan panggilan di baris `(*)`.
 
-For convenience let's split it into multiple lines:
+Untuk kenyamanan marilah kita pecahkan menjadi beberapa baris:
 
 ```js
 let sorted = arr[i] // PAN
@@ -43,21 +43,21 @@ let sorted = arr[i] // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+Dua kata berbeda `'PAN'` dan`' nap'` mendapatkan form urutan huruf yang sama `'anp'`.
 
-The next line put the word into the map:
+Baris berikutnya menempatkan kata tersebut ke dalam map:
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+Jika kita pernah bertemu kata dengan urutan huruf yang sama lagi, maka kata itu akan menggantikan nilai sebelumnya dengan kunci yang sama di dalam map. Maka dari itu kita akan selalu mempunyai maksimum satu kata untuk setiap form huruf.
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+Akhirnya `Array.from(map.values())` mengambil iterable atas nilai-nilai map (kita tidak memperlukan kunci-kunci dalam hasilnya) dan mengembalikan array dengan isi tersebut.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Disini kita juga bisa menggunakan objek biasa daripada `Map`, karena kunci adalah string.
 
-That's how the solution can look:
+Solusinya bisa terlihat seperti ini:
 
 ```js run demo
 function aclean(arr) {

1-js/05-data-types/07-map-set/02-filter-anagrams/task.md

@@ -1,28 +1,27 @@
-importance: 4
+nilai penting: 4
 
 ---
 
-# Filter anagrams
+# Filter anagram
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagram](https://en.wikipedia.org/wiki/Anagram) adalah kata-kata yang mempunyai jumlah huruf-huruf yang sama, tetapi dengan susunan yang berbeda. 
 
-For instance:
+Sebagai contoh:
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Ciptakanlah fungsi `aclean(arr)` yang mengembalikan array yang bersih dari anagram.
 
-For instance:
+Sebagai contoh:
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
 alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
-
+Dari setiap grup anagram hanya harus tersisa satu kata, boleh yang mana saja.

1-js/05-data-types/07-map-set/03-iterable-keys/solution.md

@@ -1,8 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
-
-We can convert it into an array using `Array.from`:
+Itu karena `map.keys()`  mengembalikan iterable, tetapi bukan sebuah array.
 
+Kita bisa mengubahnya ke sebuah array menggunakan `Array.from`:
 
 ```js run
 let map = new Map();

1-js/05-data-types/07-map-set/03-iterable-keys/task.md

@@ -1,12 +1,12 @@
-importance: 5
+nilai penting: 5
 
 ---
 
-# Iterable keys
+# Kunci-kunci iterable
 
-We'd like to get an array of `map.keys()` in a variable and then do apply array-specific methods to it, e.g. `.push`.
+Kami ingin mendapatkan array daripada `map.keys()` dalam satu variabel lalu mengaplikasikan metode yang array spesifik kepadanya, contoh `.push`.
 
-But that doesn't work:
+Tapi itu tidak berhasil:
 
 ```js run
 let map = new Map();
@@ -21,4 +21,4 @@ keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+Mengapa? Bagaimana kita bisa membenarkan kode ini untuk membuat `keys.push` berhasil?