Translate Property getters and setters into Vietnamese

Author: Phùng Hùng

1-js/07-object-properties/02-property-accessors/article.md

@@ -1,144 +1,144 @@
 
-# Property getters and setters
+# Các thuộc tính getter và setter
 
-There are two kinds of properties.
+Có hai loại thuộc tính.
 
-The first kind is *data properties*. We already know how to work with them. All properties that we've been using till now were data properties.
+Đầu tiên là *thuộc tính dữ liệu* (data properties). Chúng ta đã biết và làm việc với chúng. Tất cả các thuộc tính chúng ta đã sử dụng cho đến giờ đều là các thuộc tính dữ liệu.
 
-The second type of properties is something new. It's *accessor properties*. They are essentially functions that work on getting and setting a value, but look like regular properties to an external code.
+Loại thứ hai sẽ được học trong bài này gọi là các *thuộc tính truy cập* (accessor properties). Về cơ bản chúng là các hàm có tác dụng lấy và cài đặt một giá trị - (tức là các phương thức), nhưng cách sử dụng giống một thuộc tính bình thường.
 
-## Getters and setters
+## Getter và Setter
 
-Accessor properties are represented by "getter" and "setter" methods. In an object literal they are denoted by `get` and `set`:
+Các thuộc tính truy cập được biểu diễn bằng hai phương thức gọi là "getter" và "setter". Trong literal đối tượng chúng được nhận biết bởi hai từ khóa `get` và `set`:
 
 ```js
 let obj = {
   *!*get propName()*/!* {
-    // getter, the code executed on getting obj.propName
+    // getter, phương thức này chạy khi truy cập "obj.propName"
   },
 
   *!*set propName(value)*/!* {
-    // setter, the code executed on setting obj.propName = value
+    // setter, phương thức này chạy khi gán "obj.propName = value"
   }
 };
 ```
 
-The getter works when `obj.propName` is read, the setter -- when it is assigned.
+Phương thức getter chạy khi truy cập `obj.propName`, setter chạy khi gán một giá trị cho nó.
 
-For instance, we have a `user` object with `name` and `surname`:
+Ví dụ, ta có đối tượng `user` với thuộc tính `name` và `surname`:
 
 ```js run
 let user = {
-  name: "John",
-  surname: "Smith"
+  name: "Hùng",
+  surname: "Phùng"
 };
 ```
 
-Now we want to add a "fullName" property, that should be "John Smith". Of course, we don't want to copy-paste existing information, so we can implement it as an accessor:
+Giờ ta muốn thêm thuộc tính `fullName` có giá trị là `"Phùng Hùng"`. Tất nhiên, chúng ta không sao chép thủ công các thông tin hiện có làm giá trị của `fullName`. Chúng ta có thể thực hiện việc này bằng một getter:
 
 ```js run
 let user = {
-  name: "John",
-  surname: "Smith",
+  name: "Hùng",
+  surname: "Phùng",
 
 *!*
   get fullName() {
-    return `${this.name} ${this.surname}`;
+    return `${this.surname} ${this.name}`;
   }
 */!*
 };
 
 *!*
-alert(user.fullName); // John Smith
+alert(user.fullName); // Phùng Hùng
 */!*
 ```
 
-From outside, an accessor property looks like a regular one. That's the idea of accessor properties. We don't *call* `user.fullName` as a function, we *read* it normally: the getter runs behind the scenes.
+Từ bên ngoài, các thuộc tính truy cập trông như thuộc tính dữ liệu. Nó cũng là ý tưởng cho sự xuất hiện của các thuộc tính truy cập. Chúng ta không gọi `user.fullName` như gọi phương thức, mà gọi giống như *đọc* một thuộc tính bình thường: getter sẽ tự động chạy "phía sau hậu trường".
 
-As of now, `fullName` has only a getter. If we attempt to assign `user.fullName=`, there will be an error.
+Đến giờ, `fullName` mới chỉ có getter. Nếu chúng ta muốn thay đổi giá trị của nó bằng cách gán `user.fullName=` thì sẽ có lỗi:
 
-Let's fix it by adding a setter for `user.fullName`:
+Để có thể gán giá trị cho một thuộc tính truy cập, cần tạo setter cho nó. Cùng thêm một setter cho `user.fullName`:
 
 ```js run
 let user = {
-  name: "John",
-  surname: "Smith",
+  name: "Hùng",
+  surname: "Phùng",
 
   get fullName() {
-    return `${this.name} ${this.surname}`;
+    return `${this.surname} ${this.name}`;
   },
 
 *!*
   set fullName(value) {
-    [this.name, this.surname] = value.split(" ");
+    [this.surname, this.name] = value.split(" ");
   }
 */!*
 };
 
-// set fullName is executed with the given value.
-user.fullName = "Alice Cooper";
+// Khi gán setter được chạy, đối số value lấy từ vế phải của =
+user.fullName = "Phùng Ngọc";
 
-alert(user.name); // Alice
-alert(user.surname); // Cooper
+alert(user.name); // Ngọc
+alert(user.surname); // Phùng
 ```
 
-As the result, we have a "virtual" property `fullName`. It is readable and writable, but in fact does not exist.
+Kết quả là chúng ta có một thuộc tính "ảo" `fullName`. Ta có thể đọc và ghi nó, nhưng thực tế nó không tồn tại trong đối tượng.
 
-```smart header="Accessor properties are only accessible with get/set"
-Once a property is defined with `get prop()` or `set prop()`, it's an accessor property, not a data property any more.
+```smart header="Các thuộc tính truy cập chỉ có thể truy cập nhờ getter và setter"
+Khi một thuộc tính đã được định nghĩa với `get prop()` hoặc `set prop()`, nó trở thành một thuộc tính truy cập, không phải là thuộc tính dữ liệu nữa.
 
-- If there's a getter -- we can read `object.prop`, otherwise we can't.
-- If there's a setter -- we can set `object.prop=...`, otherwise we can't.
+- Chúng ta chỉ có thể đọc thuộc tính truy cập `object.prop` nếu có getter cho nó.
+- Chúng ta chỉ có thể ghi thuộc tính truy cập `object.prop=...` nếu có setter cho nó.
 
-And in either case we can't `delete` an accessor property.
+Và trong cả hai trường hợp, ta không thể xóa một thuộc tính truy cập.
 ```
 
 
-## Accessor descriptors
+## Descriptor của thuộc tính truy cập
 
-Descriptors for accessor properties are different -- as compared with data properties.
+Các descriptor của thuộc trính truy cập khác với descriptor của thuộc tính dữ liệu mà ta đã học.
 
-For accessor properties, there is no `value` and `writable`, but instead there are `get` and `set` functions.
+Nó không có `value` và `writable`, mà thay bằng hai hàm `get` và `set`.
 
-So an accessor descriptor may have:
+Cụ thể descriptor của thuộc tính truy cập có:
 
-- **`get`** -- a function without arguments, that works when a property is read,
-- **`set`** -- a function with one argument, that is called when the property is set,
-- **`enumerable`** -- same as for data properties,
-- **`configurable`** -- same as for data properties.
+- **`get`** -- hàm không có tham số, chạy khi đọc thuộc tính,
+- **`set`** -- hàm có một tham số, chạy khi ghi thuộc tính,
+- **`enumerable`** -- giống thuộc tính dữ liệu,
+- **`configurable`** -- giống thuộc tính dữ liệu.
 
-For instance, to create an accessor `fullName` with `defineProperty`, we can pass a descriptor with `get` and `set`:
+Ví dụ, để tạo thuộc tính truy cập `fullName` bằng `defineProperty`, chúng ta có thể truyền một descriptor có hai phương thức `get` và `set`:
 
 ```js run
 let user = {
-  name: "John",
-  surname: "Smith"
+  name: "Hùng",
+  surname: "Phùng"
 };
 
 *!*
 Object.defineProperty(user, 'fullName', {
   get() {
-    return `${this.name} ${this.surname}`;
+    return `${this.surname} ${this.name}`;
   },
 
   set(value) {
-    [this.name, this.surname] = value.split(" ");
+    [this.surname, this.name] = value.split(" ");
   }
 */!*
 });
 
-alert(user.fullName); // John Smith
+alert(user.fullName); // Phùng Hùng
 
 for(let key in user) alert(key); // name, surname
 ```
 
-Please note once again that a property can be either an accessor or a data property, not both.
+Vui lòng chú ý một lần nữa, một thuộc tính chỉ có thể là thuộc tính truy cập hoặc thuộc tính dữ liệu, không thể là cả hai cùng lúc.
 
-If we try to supply both `get` and `value` in the same descriptor, there will be an error:
+Nếu đưa cả `get` và `value` trong một descriptor, sẽ gây ra lỗi:
 
 ```js run
 *!*
-// Error: Invalid property descriptor.
+// Lỗi: Thuộc tính descriptor không hợp lệ
 */!*
 Object.defineProperty({}, 'prop', {
   get() {
@@ -149,11 +149,11 @@ Object.defineProperty({}, 'prop', {
 });
 ```
 
-## Smarter getters/setters
+## Getter/setter thông minh hơn
 
-Getters/setters can be used as wrappers over "real" property values to gain more control over them.
+Getters/setters có thể dùng như một thuộc tính "bao" lấy thuộc tính thực thực, để kiểm soát giá trị được đưa vào.
 
-For instance, if we want to forbid too short names for `user`, we can store `name` in a special property `_name`. And filter assignments in the setter:
+Ví dụ, nếu chúng ta muốn chặn một tên quá ngắn cho `user`, chúng ta có thể tạo một thuộc tính truy cập `name` lưu trong thuộc tính thực `_name` và thêm bước kiểm tra vào trong setter:
 
 ```js run
 let user = {
@@ -163,63 +163,63 @@ let user = {
 
   set name(value) {
     if (value.length < 4) {
-      alert("Name is too short, need at least 4 characters");
+      alert("Tên quá ngắn, cần nhiều hơn 4 ký tự");
       return;
     }
     this._name = value;
   }
 };
 
-user.name = "Pete";
-alert(user.name); // Pete
+user.name = "Hùng";
+alert(user.name); // Hùng
 
-user.name = ""; // Name is too short...
+user.name = ""; // Tên quá ngắn, cần nhiều hơn 4 ký tự
 ```
 
-Technically, the external code may still access the name directly by using `user._name`. But there is a widely known agreement that properties starting with an underscore `"_"` are internal and should not be touched from outside the object.
+Vễ mặt kỹ thuật, mã bên ngoài vẫn có thể truy cập và thay đổi trực tiếp thuộc tính `user._name`. Nhưng có một thỏa thuận được chấp nhận rộng rãi rằng các thuộc tính có tên bắt đầu bằng `"_"` được coi là thuộc tính riêng của đối tượng và không nên truy cập hay thay đổi trực tiếp từ bên ngoài.
 
 
-## Using for compatibility
+## Cung cấp sự tương thích
 
-One of the great ideas behind getters and setters -- they allow to take control over a "regular" data property at any moment by replacing it with getter and setter and tweak its behavior.
+Các getter và setter cho phép ta thay thế một thuộc tính dữ liệu thông thường bằng phiên bản khác sử dụng thuộc tính truy cập với khả năng kiểm soát tốt hơn.
 
-Let's say we started implementing user objects using data properties `name` and `age`:
+Giả sử chúng ta tạo đối tượng người dùng có hai thuộc tính `name` và `age`:
 
 ```js
 function User(name, age) {
   this.name = name;
   this.age = age;
 }
 
-let john = new User("John", 25);
+let hung = new User("Hùng", 33);
 
-alert( john.age ); // 25
+alert( hung.age ); // 33
 ```
 
-...But sooner or later, things may change. Instead of `age` we may decide to store `birthday`, because it's more precise and convenient:
+...Nhưng ngay sau đó, thay vì `age` ta quyết định sử dụng `birthday`, bởi nó chính xác và thuận tiện hơn:
 
 ```js
 function User(name, birthday) {
   this.name = name;
   this.birthday = birthday;
 }
 
-let john = new User("John", new Date(1992, 6, 1));
+let hung = new User("Hùng", new Date(1986, 8, 3));
 ```
 
-Now what to do with the old code that still uses `age` property?
+Giờ ta phải làm gì với những mã cũ vẫn còn sử dụng thuộc tính `age`?
 
-We can try to find all such places and fix them, but that takes time and can be hard to do if that code is written/used by many other people. And besides, `age` is a nice thing to have in `user`, right? In some places it's just what we want.
+Chúng ta có thể tìm và sửa lại, nhưng nó tốn rất nhiều thời gian và rất khó nếu mã được viết bởi những người khác. Hơn nữa sự có mặt của thuộc tính `age` trong đối tượng người dùng vẫn hợp lý và ta chỉ muốn thay đổi ở một số chỗ mà thôi.
 
-Adding a getter for `age` solves the problem:
+Thêm thuộc tính truy cập cho `age` sẽ giải quyết được vấn đề này:
 
 ```js run no-beautify
 function User(name, birthday) {
   this.name = name;
   this.birthday = birthday;
 
 *!*
-  // age is calculated from the current date and birthday
+  // age có thể tính được từ birthday
   Object.defineProperty(this, "age", {
     get() {
       let todayYear = new Date().getFullYear();
@@ -229,10 +229,10 @@ function User(name, birthday) {
 */!*
 }
 
-let john = new User("John", new Date(1992, 6, 1));
+let hung = new User("Hùng", new Date(1986, 8, 3));
 
-alert( john.birthday ); // birthday is available
-alert( john.age );      // ...as well as the age
+alert( john.birthday ); // birthday vẫn truy cập được
+alert( john.age );      // ...và age cũng vậy
 ```
 
-Now the old code works too and we've got a nice additional property.
+Và giờ các đoạn mã cũ sử dụng `age` vẫn làm việc tốt.