Translate Prototypal inheritance into Vietnamese

Author: Phùng Hùng

1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/solution.md

@@ -1,4 +1,4 @@
 
-1. `true`, taken from `rabbit`.
-2. `null`, taken from `animal`.
-3. `undefined`, there's no such property any more.
+1. `true`, lấy từ `rabbit`.
+2. `null`, lấy từ `animal`.
+3. `undefined`, lấy từ `Object.prototype` nhưng nó không có thuộc tính `jumps`.

1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Working with prototype
+# Làm việc với nguyên mẫu
 
-Here's the code that creates a pair of objects, then modifies them.
+Đây là mã tạo một cặp đối tượng, sau đó sửa chúng.
 
-Which values are shown in the process?
+Giá tri nào sẽ được hiển thị?
 
 ```js
 let animal = {
@@ -28,4 +28,4 @@ delete animal.jumps;
 alert( rabbit.jumps ); // ? (3)
 ```
 
-There should be 3 answers.
+Sẽ có 3 câu trả lời.

1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md

@@ -1,5 +1,5 @@
 
-1. Let's add `__proto__`:
+1. Thêm `__proto__` như sau:
 
     ```js run
     let head = {
@@ -27,6 +27,6 @@
     alert( table.money ); // undefined
     ```
 
-2. In modern engines, performance-wise, there's no difference whether we take a property from an object or its prototype. They remember where the property was found and reuse it in the next request.
+2. Trong các JavaScript engine hiện đại, hiệu năng rất tốt, không có khác biệt nào giữa việc lấy thuộc tính từ đối tượng hay từ nguyên mẫu. Chúng nhớ nơi thuộc tính được tìm thấy để tái sử dụng trong những lần sau.
 
-    For instance, for `pockets.glasses` they remember where they found `glasses` (in `head`), and next time will search right there. They are also smart enough to update internal caches if something changes, so that optimization is safe.
+    Ví dụ, với `pockets.glasses` engine nhớ nơi nó tìm thấy `glasses` (trong `head`), và trong lần sau sẽ tìm ngay trong đó. Nó cũng đủ thông minh để cập nhật lại nếu có gì đó thay đổi, để việc tối ưu hóa vẫn an toàn.

1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Searching algorithm
+# Thuật toán tìm thuộc tính
 
-The task has two parts.
+Bài tập có hai phần.
 
-We have an object:
+Chúng ta có một đối tượng:
 
 ```js
 let head = {
@@ -27,5 +27,5 @@ let pockets = {
 };
 ```
 
-1. Use `__proto__` to assign prototypes in a way that any property lookup will follow the path: `pockets` -> `bed` -> `table` -> `head`. For instance, `pockets.pen` should be `3` (found in `table`), and `bed.glasses` should be `1` (found in `head`).
-2. Answer the question: is it faster to get `glasses` as `pockets.glasses` or `head.glasses`? Benchmark if needed.
+1. Sử dụng `__proto__` để tạo chuỗi nguyên mẫu, sao cho bất kỳ thuộc tính nào đều được tìm theo thứ tự: `pockets` -> `bed` -> `table` -> `head`. Ví dụ, `pockets.pen` là `3` (tìm thấy trong `table`), và `bed.glasses` là `1` (tìm thấy trong `head`).
+2. Trả lời câu hỏi: có thể lấy `glasses` bằng `pockets.glasses` hoặc `head.glasses`, cách nào nhanh hơn?

1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md

@@ -1,6 +1,6 @@
-**The answer: `rabbit`.**
+**Trả lời: `rabbit`.**
 
-That's because `this` is an object before the dot, so `rabbit.eat()` modifies `rabbit`.
+Bởi vì `this` là đối tượng trước dấu chấm, nên `rabbit.eat()` thay đổi `rabbit`.
 
-Property lookup and execution are two different things.
-The method `rabbit.eat` is first found in the prototype, then executed with `this=rabbit`
+Tìm thuộc tính và chạy thuộc tính là hai việc khác nhau.
+Phương thức `rabbit.eat` tìm thấy trong nguyên mẫu, nhưng lại chạy trong `rabbit`.

1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Where it writes?
+# Dữ liệu ghi vào đối tượng nào?
 
-We have `rabbit` inheriting from `animal`.
+Chúng ta có `rabbit` thừa kế từ `animal`.
 
-If we call `rabbit.eat()`, which object receives the `full` property: `animal` or `rabbit`? 
+Nếu chúng ta gọi `rabbit.eat()`, đối tượng nào nhận được thuộc tính `full`: `animal` hay `rabbit`? 
 
 ```js
 let animal = {

1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md

@@ -1,26 +1,26 @@
-Let's look carefully at what's going on in the call `speedy.eat("apple")`.
+Cùng xem xét cẩn thận chuyện xảy ra khi gọi `speedy.eat("apple")`.
 
-1. The method `speedy.eat` is found in the prototype (`=hamster`), then executed with `this=speedy` (the object before the dot).
+1. Phương thức `speedy.eat` tìm thấy trong nguyên mẫu (`=hamster`), sau đó chạy trong `speedy` (`this=speedy`).
 
-2. Then `this.stomach.push()` needs to find `stomach` property and call `push` on it. It looks for `stomach` in `this` (`=speedy`), but nothing found.
+2. Tiếp theo `this.stomach.push()` cần tìm thuộc tính `stomach` và gọi phương thức `push` từ đó. Trước tiên `stomach` được tìm trong `this` (`=speedy`), nhưng không thấy.
 
-3. Then it follows the prototype chain and finds `stomach` in `hamster`.
+3. Sau đó `stomach` được tìm thấy trong nguyên mẫu `hamster` từ giờ `this.stomach` là `hamster.stomach`.
 
-4. Then it calls `push` on it, adding the food into *the stomach of the prototype*.
+4. Khi gọi `this.stomach.push` thì `"apple"` được thêm vào `hamster.stomach`.
 
-So all hamsters share a single stomach!
+Vậy nên cả hai con hamsters đều dùng chung `hamster.stomach` - tức có cùng một cái dạ dày! Khi một con no, con kia cũng no là vì thế.
 
-Every time the `stomach` is taken from the prototype, then `stomach.push` modifies it "at place".
+Mỗi khi `stomach` được lấy từ nguyên mẫu, thì `this.stomach.push` lại làm thay đổi `hamster.stomach`.
 
-Please note that such thing doesn't happen in case of a simple assignment `this.stomach=`:
+Chú ý rằng chuyện này không xảy ra nếu ta gán `this.stomach=`:
 
 ```js run
 let hamster = {
   stomach: [],
 
   eat(food) {
 *!*
-    // assign to this.stomach instead of this.stomach.push
+    // gán tới to this.stomach thay vì this.stomach.push
     this.stomach = [food];
 */!*
   }
@@ -34,17 +34,17 @@ let lazy = {
   __proto__: hamster
 };
 
-// Speedy one found the food
+// Speedy ăn táo
 speedy.eat("apple");
 alert( speedy.stomach ); // apple
 
-// Lazy one's stomach is empty
-alert( lazy.stomach ); // <nothing>
+// Lazy không được ăn theo
+alert( lazy.stomach ); // <không có gì>
 ```
 
-Now all works fine, because `this.stomach=` does not perform a lookup of `stomach`. The value is written directly into `this` object.
+Giờ tất cả làm việc, vì `this.stomach=` là hành động ghi nên không sử dụng thuộc tính `stomach` của nguyên mẫu `hamster`. Giá trị được ghi vào đối tượng `this` (tức đối tượng được thừa kế).
 
-Also we can totally evade the problem by making sure that each hamster has their own stomach:
+Ta cũng có thể tránh được vấn đề trên bằng cách tạo riêng cho mỗi con hamster một cái dạ dày:
 
 ```js run
 let hamster = {
@@ -69,12 +69,12 @@ let lazy = {
 */!*
 };
 
-// Speedy one found the food
+// Speedy ăn táo
 speedy.eat("apple");
 alert( speedy.stomach ); // apple
 
-// Lazy one's stomach is empty
-alert( lazy.stomach ); // <nothing>
+// Dạ dày của Lazy vẫn trống
+alert( lazy.stomach ); // <không có gì>
 ```
 
-As a common solution, all properties that describe the state of a particular object, like `stomach` above, are usually written into that object. That prevents such problems.
+Đây là giải pháp tổng quát, các thuộc tính mô tả trạng thái của đối tượng, giống `stomach` ở trên nên được ghi riêng vào đối tượng đó, không nên dùng chung từ một nguyên mẫu. Điều này giúp ta không gặp phải vấn đề trên.

1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Why two hamsters are full?
+# Tại sao cả hai con hamster đều no?
 
-We have two hamsters: `speedy` and `lazy` inheriting from the general `hamster` object. 
+Ta có hai con hamster: `speedy` và `lazy` đều thừa kế từ đối tượng `hamster`. 
 
-When we feed one of them, the other one is also full. Why? How to fix it?
+Khi chúng ta cho một trong số chúng ăn no, con kia cũng no. Tại sao? Sửa lại như thế nào?
 
 ```js run
 let hamster = {
@@ -25,11 +25,11 @@ let lazy = {
   __proto__: hamster
 };
 
-// This one found the food
+// Cho một con ăn no
 speedy.eat("apple");
 alert( speedy.stomach ); // apple
 
-// This one also has it, why? fix please.
+// Con kia cũng vậy! Tại sao? Hãy sửa lại?
 alert( lazy.stomach ); // apple
 ```