Map and Set

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

@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# Lọc các phần tử array duy nhất
 
-Let `arr` be an array.
+Đặt `arr` là một array.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Tạo một hàm `unique(arr)` sẽ trả về một array với các phần tử duy nhất của `arr`.
 
-For instance:
+Ví dụ:
 
 ```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.
+Tái bút: Ở đây các chuỗi được sử dụng, nhưng có thể là các giá trị thuộc bất kỳ loại nào.
 
-P.P.S. Use `Set` to store unique values.
+Tái bút nữa: Sử dụng `Set` để lưu trữ các giá trị duy nhất.

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.
+Để tìm tất cả các đảo chữ, hãy tách từng từ thành các chữ cái và sắp xếp chúng. Khi sắp xếp theo chữ cái, tất cả các đảo chữ đều giống nhau.
 
-For instance:
+Ví dụ:
 
 ```
 nap, pan -> anp
@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Chúng ta sẽ sử dụng các biến thể được sắp xếp theo chữ làm khóa map để chỉ lưu trữ một giá trị cho mỗi khóa:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // tách từ bằng các chữ, sắp xếp chúng và nối lại
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -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 `(*)`.
+Việc phân loại chữ cái được thực hiện bởi chuỗi các cuộc gọi trong dòng `(*)`.
 
-For convenience let's split it into multiple lines:
+Để thuận tiện, hãy chia nó thành nhiều dòng:
 
 ```js
 let sorted = word // PAN
@@ -43,21 +43,21 @@ let sorted = word // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+Hai từ khác nhau `'PAN'` và `'nap'` có cùng dạng sắp xếp theo chữ cái `'anp'`.
 
-The next line put the word into the map:
+Dòng tiếp theo đưa từ vào 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.
+Nếu chúng ta gặp lại một từ có cùng dạng sắp xếp theo chữ cái, thì từ đó sẽ ghi đè lên giá trị trước đó bằng cùng một khóa trong map. Vì vậy, chúng ta sẽ luôn có tối đa một từ cho mỗi mẫu dạng ký tự.
 
-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.
+Cuối cùng, `Array.from(map.values())` có thể lặp lại các giá trị map (chúng ta không cần khóa trong kết quả) và trả về một array của chúng.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Ở đây chúng ta cũng có thể sử dụng một đối tượng đơn giản thay vì `Map`, vì các khóa là các chuỗi.
 
-That's how the solution can look:
+Đó là cách giải pháp có thể giống:
 
 ```js run demo
 function aclean(arr) {

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

@@ -2,27 +2,27 @@ importance: 4
 
 ---
 
-# Filter anagrams
+# Lọc đảo chữ
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Đảo chữ](https://vi.wikipedia.org/wiki/Phép_đảo_chữ) là những từ có cùng số lượng chữ cái giống nhau, nhưng theo thứ tự khác nhau.
 
-For instance:
+Ví dụ:
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Viết một hàm `aclean(arr)` trả về một array đã được làm sạch từ đảo chữ.
 
-For instance:
+Ví dụ:
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+alert( aclean(arr) ); // "nap,teachers,ear" hoặc "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
+Từ mỗi nhóm đảo chữ chỉ nên còn lại một từ, bất kể đó là từ nào.
 

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

@@ -1,19 +1,19 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
+Đó là bởi vì `map.keys()` trả về một iterable, nhưng không phải là một array.
 
-We can convert it into an array using `Array.from`:
+Chúng ta có thể chuyển đổi nó thành một array bằng cách sử dụng `Array.from`:
 
 
 ```js run
 let map = new Map();
 
-map.set("name", "John");
+map.set("tên", "John");
 
 *!*
 let keys = Array.from(map.keys());
 */!*
 
-keys.push("more");
+keys.push("thêm");
 
-alert(keys); // name, more
+alert(keys); // tên, thêm
 ```

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

@@ -2,23 +2,23 @@ importance: 5
 
 ---
 
-# Iterable keys
+# Khóa iterable
 
-We'd like to get an array of `map.keys()` in a variable and then apply array-specific methods to it, e.g. `.push`.
+Chúng ta muốn lấy một array `map.keys()` trong một biến và sau đó áp dụng các phương thức dành riêng cho array đó, ví dụ: `.push`.
 
-But that doesn't work:
+Nhưng nó không hoạt động:
 
 ```js run
 let map = new Map();
 
-map.set("name", "John");
+map.set("tên", "John");
 
 let keys = map.keys();
 
 *!*
 // Error: keys.push is not a function
-keys.push("more");
+keys.push("thêm");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+Tại sao? Chúng ta có thể sửa mã để làm cho `keys.push` hoạt động bằng cách nào?