Merge pull request #191 from yoga1234/master

translate

Author: yoga1234

1-js/08-prototypes/02-function-prototype/1-changing-prototype/solution.md

@@ -1,20 +1,20 @@
 
-Answers:
+Jawaban:
 
 1. `true`. 
 
-    The assignment to `Rabbit.prototype` sets up `[[Prototype]]` for new objects, but it does not affect the existing ones. 
+    Memasukan ke `Rabbit.prototype` menyetel `[[Prototype]]` untuk objek baru, tapi itu tidak memberikan efek pada yang sudah ada.
 
 2. `false`. 
 
-    Objects are assigned by reference. The object from `Rabbit.prototype` is not duplicated, it's still a single object referenced both by `Rabbit.prototype` and by the `[[Prototype]]` of `rabbit`. 
+    Objek yang dimasukan dengan menggunakan referensi. Objek dari `Rabbit.prototype` bukanlah di duplikasi, itu masih tetap objek tunggal yang direferensikan dari `Rabbit.prototype` dan dari `[[Prototype]]` dari `rabbit`.
 
-    So when we change its content through one reference, it is visible through the other one.
+    Jadi ketika kita mengubah kontennya melalui satu referensi, itu masih terlihat melalui yang lainnya.
 
 3. `true`.
 
-    All `delete` operations are applied directly to the object. Here `delete rabbit.eats` tries to remove `eats` property from `rabbit`, but it doesn't have it. So the operation won't have any effect.
+    Semua operasi `delete` diterapkan langsung ke objeknya. Disini `delete rabbit.eats` mencoba untuk menghapus properti `eats` dari `rabbit`, tapi itu tidak memilikinya. Jadi operasinya tidak akan menghasilkan efek apapun.
 
 4. `undefined`.
 
-    The property `eats` is deleted from the prototype, it doesn't exist any more.
+    Properti `eats` dihapus dari *prototype*, itu tidak akan ada lagi.

1-js/08-prototypes/02-function-prototype/1-changing-prototype/task.md

@@ -1,12 +1,12 @@
-importance: 5
+nilai: 5
 
 ---
 
-# Changing "prototype"
+# Merubah "prototype"
 
-In the code below we create `new Rabbit`, and then try to modify its prototype.
+Di kode dibawah kita membuat `new Rabbit`, dan mencoba memodifikasi prototypenya.
 
-In the start, we have this code:
+Pada awalnya kita memiliki kode ini:
 
 ```js run
 function Rabbit() {}
@@ -20,7 +20,7 @@ alert( rabbit.eats ); // true
 ```
 
 
-1. We added one more string (emphasized). What will `alert` show now?
+1. Kita menambah satu string (ditekankan). What will `alert` show now?
 
     ```js
     function Rabbit() {}
@@ -37,7 +37,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-2. ...And if the code is like this (replaced one line)?
+2. ...Dan jika kodenya seperti ini (diganti satu baris)?
 
     ```js
     function Rabbit() {}
@@ -54,7 +54,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-3. And like this (replaced one line)?
+3. Dan seperti ini (diganti satu baris)?
 
     ```js
     function Rabbit() {}
@@ -71,7 +71,7 @@ alert( rabbit.eats ); // true
     alert( rabbit.eats ); // ?
     ```
 
-4. The last variant:
+4. varian terakhir:
 
     ```js
     function Rabbit() {}

1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/solution.md

@@ -1,6 +1,6 @@
-We can use such approach if we are sure that `"constructor"` property has the correct value.
+Kita bisa menggunakan pendekatan jika kita yakin properti `"constructor"` memiliki nilai yang benar.
 
-For instance, if we don't touch the default `"prototype"`, then this code works for sure:
+Contoh, kita tidak ingin menyentuh `"prototype"` bawaan, maka kode ini akan berjalan dengan semestinya:
 
 ```js run
 function User(name) {
@@ -10,14 +10,14 @@ function User(name) {
 let user = new User('John');
 let user2 = new user.constructor('Pete');
 
-alert( user2.name ); // Pete (worked!)
+alert( user2.name ); // Pete (bekerja!)
 ```
 
-It worked, because `User.prototype.constructor == User`.
+Kode diatas bekerja karena `User.prototype.constructor == User`.
 
-..But if someone, so to speak, overwrites `User.prototype` and forgets to recreate `constructor` to reference `User`, then it would fail.
+Tapi jika seseorang, menimpah `User.prototype` dan lupa untuk membuat ulang `constructor` untuk `User`, maka akan membuat kegagalan.
 
-For instance:
+Contoh:
 
 ```js run
 function User(name) {
@@ -33,12 +33,12 @@ let user2 = new user.constructor('Pete');
 alert( user2.name ); // undefined
 ```
 
-Why `user2.name` is `undefined`?
+Kenapa `user2.name` menghasilan `undefined`?
 
-Here's how `new user.constructor('Pete')` works:
+Ini bagaimana `new user.constructor('Pete')` bekerja:
 
-1. First, it looks for `constructor` in `user`. Nothing.
-2. Then it follows the prototype chain. The prototype of `user` is `User.prototype`, and it also has nothing.
-3. The value of `User.prototype` is a plain object `{}`, its prototype is `Object.prototype`. And there is `Object.prototype.constructor == Object`. So it is used.
+1. Pertama, itu akan mencari `constructor` didalam `user`. Tidak ditemukan.
+2. Lalu akan mengukuti rantai *prototype*. *Prototype* dari `user` adalah `User.prototype`, dan itu juga tidak memilikinya.
+3. Nilai dari `User.prototype` adalah sebuah objek polos `{}`, prototypenya adalah `Object.prototype`. dan disana terdapat `Object.prototype.constructor == Object`. Jadi itu digunakan.
 
-At the end, we have `let user2 = new Object('Pete')`. The built-in `Object` constructor ignores arguments, it always creates an empty object, similar to `let user2 = {}`, that's what we have in `user2` after all.
+Pada akhirnya kita memiliki `let user2 = new Object('Pete')`. Konstruktor `Object` bawaan menghiraukan argumen, itu selalu menciptakan objek kosong, sama seperti `let user2 = {}`, itulah yang kita punya didalam `user2`.

1-js/08-prototypes/02-function-prototype/4-new-object-same-constructor/task.md

@@ -1,15 +1,15 @@
-importance: 5
+nilai: 5
 
 ---
 
-# Create an object with the same constructor
+# Buat sebuah objek dengan konstruktor yang sama
 
-Imagine, we have an arbitrary object `obj`, created by a constructor function -- we don't know which one, but we'd like to create a new object using it.
+Bayangkan, kita memiliki objek yang berubah-ubah, dibuat dengan menggunakan fungsi konstruktor -- kita tidak tahu yang mana, tapi kita ingin membuat sebuah objek menggunakannya.
 
-Can we do it like that?
+Bisakah kita melakukannya?
 
 ```js
 let obj2 = new obj.constructor();
 ```
 
-Give an example of a constructor function for `obj` which lets such code work right. And an example that makes it work wrong.
+Beri sebuah contoh dari menggunakan fungsi konstruktor untuk `obj` yang mana membiarkan kode seperti itu bekerja. Dan sebuah contoh yang mana membuat kodenya menjadi tidak bekerja semestinya.