translations of all task.md and solution.md in Object methods, 'this' are done according to #1 (comment)

Author: dummyeuy

1-js/04-object-basics/04-object-methods/2-check-syntax/solution.md

@@ -1,6 +1,6 @@
 **Error**!
 
-Try it:
+Coba ini:
 
 ```js run
 let user = {
@@ -11,19 +11,19 @@ let user = {
 (user.go)() // error!
 ```
 
-The error message in most browsers does not give us much of a clue about what went wrong.
+Pesan error pada kebanyakan peramban tidak memberitahukan kita cukup petunjuk tentang hal apa yang salah.
 
-**The error appears because a semicolon is missing after `user = {...}`.**
+**Error muncul karena tidak adanya sebuah titik koma setelah `user = {...}`.**
 
-JavaScript does not auto-insert a semicolon before a bracket `(user.go)()`, so it reads the code like:
+JavaScript tidak secara otomatis menyisipkan sebuah tanda titik koma setelah tanda kurung kurawa `(user.go)()`, jadi JavaScript membaca kode seperti ini:
 
 ```js no-beautify
 let user = { go:... }(user.go)()
 ```
 
-Then we can also see that such a joint expression is syntactically a call of the object `{ go: ... }` as a function with the argument `(user.go)`. And that also happens on the same line with `let user`, so the `user` object has not yet even been defined, hence the error.
+Lalu kita juga bisa melihat bahwa ekspresi gabungan semacam itu adalah sebuah panggilan objek `{ go: ... }` secara sintaks yang juga sebagai sebuah fungsi dengan argumen `(user.go)`. Dan hal tersebut juga terjadi pada baris yang sama dengan `let user`, jadi objek `user` belum didefinisikan, oleh karena itu terjadi error.
 
-If we insert the semicolon, all is fine:
+Jika kita menyisipkan tanda titik koma, semuanya akan baik-baik saja:
 
 ```js run
 let user = {
@@ -34,4 +34,4 @@ let user = {
 (user.go)() // John
 ```
 
-Please note that brackets around `(user.go)` do nothing here. Usually they setup the order of operations, but here the dot `.` works first anyway, so there's no effect. Only the semicolon thing matters.
+Tolong ingat bahwa tanda kurung kurawa yang merangkap `(user.go)` tidak melakukan apapun di sini. Biasanya  Biasanya tanda kurung kurawa mengatur urutan operasi, tapi di sini tanda titik-lah (`.`) yang berjalan terlebih dulu, jadi tidak ada pengaruh apapun. Hanya tanda titik koma yang berpengaruh.

1-js/04-object-basics/04-object-methods/2-check-syntax/task.md

@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Syntax check
+# Cek sintaks
 
-What is the result of this code?
+Apa hasil dari kode berikut ini?
 
 
 ```js no-beautify
@@ -16,4 +16,4 @@ let user = {
 (user.go)()
 ```
 
-P.S. There's a pitfall :)
+P.S. Ada jebakannya :)

1-js/04-object-basics/04-object-methods/3-why-this/solution.md

@@ -1,22 +1,21 @@
 
-Here's the explanations.
+Ini dia penjelasannya.
 
-1. That's a regular object method call.
+1. Itu adalah sebuah panggilan metode objek biasa.
 
-2. The same, brackets do not change the order of operations here, the dot is first anyway.
+2. Sama halnya, tanda kurung kurawa tidak merubah urutan operasi di sini, lagi pula tanda titik lah yang pertama di urutan operasi.
 
-3. Here we have a more complex call `(expression).method()`. The call works as if it were split into two lines:
+3. Di sini kita memiliki sebuah panggilan yang lebih kompleks lagi yakni `(expression).method()`. Pagnggilan tersebut bekerja sebagaimana jika panggilan itu dipisah menjadi dua baris kode:
 
     ```js no-beautify
-    f = obj.go; // calculate the expression
-    f();        // call what we have
+    f = obj.go; // mengkalkulasi ekspresi
+    f();        // memanggil apa yang kita punya 
     ```
 
-    Here `f()` is executed as a function, without `this`.
+    Di sini `f()` dieksekusi sebagai sebuah fungsi, tanpa `this`.
 
-4. The similar thing as `(3)`, to the left of the dot `.` we have an expression.
+4. Hal serupa pada panggilan `(3)`, di sebelah kiri tanda titik `.` kita memiliki sebuah ekspresi.
 
-To explain the behavior of `(3)` and `(4)` we need to recall that property accessors (dot or square brackets) return a value of the Reference Type.  
-
-Any operation on it except a method call (like assignment `=` or `||`) turns it into an ordinary value, which does not carry the information allowing to set `this`.
+Untuk menjelaskan perilaku panggilan `(3)` dan `(4)` kita perlu memanggil ulang, yang mana properti pengakses (tanda titik atau tanda kurung siku) mengembalikan sebuah nilai dari tipe referensi (*Reference Type*).  
 
+Operasi apapun kecuali sebuah panggilan metode (seperti penugasan `=` atau `||`) membuat membuat ekspresi tersebut menjadi sebuah nilai biasa, yang tidak membawa informasi yang memungkinkan untuk menentukan `this`.

1-js/04-object-basics/04-object-methods/3-why-this/task.md

@@ -2,11 +2,11 @@ importance: 3
 
 ---
 
-# Explain the value of "this"
+# Jelaskan nilai dari "this"
 
-In the code below we intend to call `obj.go()` method 4 times in a row.
+Dalam kode di bawah ini kita bermaksud untuk memanggil metode `obj.go()` sebanyak 4 kali sekaligus.
 
-But calls `(1)` and `(2)` works differently from `(3)` and `(4)`. Why?
+Tapi panggilan `(1)` dan `(2)` bekerja berbeda dibanding dengan `(3)` dan `(4)`. Mengapa demikian?
 
 ```js run no-beautify
 let obj, method;
@@ -15,9 +15,9 @@ obj = {
   go: function() { alert(this); }
 };
 
-obj.go();               // (1) [object Object]
+obj.go();               // (1) [objek Object]
 
-(obj.go)();             // (2) [object Object]
+(obj.go)();             // (2) [objek Object]
 
 (method = obj.go)();    // (3) undefined
 

1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md

@@ -1,6 +1,6 @@
-**Answer: an error.**
+**Jawaban: error.**
 
-Try it:
+Coba ini:
 ```js run
 function makeUser() {
   return {
@@ -11,18 +11,18 @@ function makeUser() {
 
 let user = makeUser();
 
-alert( user.ref.name ); // Error: Cannot read property 'name' of undefined
+alert( user.ref.name ); // Error: Tidak bisa membaca properti 'name' dari undefined
 ```
 
-That's because rules that set `this` do not look at object definition. Only the moment of call matters.
+Hal itu karena aturan-aturan yang mengatur `this` tidak melihat definisi objek. Yang penting hanya momen saat panggilan terjadi.
 
-Here the value of `this` inside `makeUser()` is `undefined`, because it is called as a function, not as a method with "dot" syntax.
+Di sini nilai dari `this` dalam `makeUser()` adalah `undefined`, karena dipanggil sebagai sebuah fungsi, tidak sebagai sebuah metode dengan sintaks "tanda titik".
 
-The value of `this` is one for the whole function, code blocks and object literals do not affect it.
+Nilai `this` adalah satu untuk keseluruhan fungsi, blok kode serta penulisan objek tidak mempengaruhi nilai tersebut.
 
-So `ref: this` actually takes current `this` of the function.
+Jadi `ref: this` sebenarnya mengambil `this` yang sekarang dari fungsi tersebut.
 
-Here's the opposite case:
+Berikut ini contoh kasus kebalikannya:
 
 ```js run
 function makeUser() {
@@ -41,4 +41,4 @@ let user = makeUser();
 alert( user.ref().name ); // John
 ```
 
-Now it works, because `user.ref()` is a method. And the value of `this` is set to the object before dot `.`.
+Kini kode itu berfugsi, karena `user.ref()` adalah sebuah metode. Dan nilai dari `this` ditentukan ke objek sebelum tanda titik `.`.

1-js/04-object-basics/04-object-methods/4-object-property-this/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Using "this" in object literal
+# Menggunakan "this" dalam penulisan objek
 
-Here the function `makeUser` returns an object.
+Berikut ini adalah fungsi `makeUser` yang mengembalikan sebuah objek.
 
-What is the result of accessing its `ref`? Why?
+Apa hasil dari mengakses `ref`? Mengapa demikian?
 
 ```js
 function makeUser() {
@@ -18,6 +18,6 @@ function makeUser() {
 
 let user = makeUser();
 
-alert( user.ref.name ); // What's the result?
+alert( user.ref.name ); // Apa hasilnya?
 ```
 

1-js/04-object-basics/04-object-methods/7-calculator/task.md

@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Create a calculator
+# Membuat sebuah kalkulator
 
-Create an object `calculator` with three methods:
+Buatlah sebuah objek `calculator` dengan tiga metode:
 
-- `read()` prompts for two values and saves them as object properties.
-- `sum()` returns the sum of saved values.
-- `mul()` multiplies saved values and returns the result.
+- `read()` mendorong kedua nilai dan menyimpan nilai-nilai tersebut sebagai properti objek.
+- `sum()` mengembalikan jumlah dari nilai-nilai yang disimpan.
+- `mul()` mengalikan nilai-nilai yang disimpan dan mengembalikan hasilnya.
 
 ```js
 let calculator = {

1-js/04-object-basics/04-object-methods/8-chain-calls/solution.md

@@ -1,4 +1,4 @@
-The solution is to return the object itself from every call.
+Solusinya adalah untuk mengembalikan objek itu sendiri dari setiap panggilan.
 
 ```js run demo
 let ladder = {
@@ -26,7 +26,7 @@ let ladder = {
 ladder.up().up().down().up().down().showStep(); // 1
 ```
 
-We also can write a single call per line. For long chains it's more readable:
+Kita juga bisa menuliskan sebuah panggilan di setiap baris. Untuk rantai kode yang panjang jadi lebih mudah dibaca seperti ini:
 
 ```js
 ladder

1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Chaining
+# *Chaining* (merantaikan)
 
-There's a `ladder` object that allows to go up and down:
+Ada sebuah objek layaknya tangga (`ladder`) yang dapat naik dan turun:
 
 ```js
 let ladder = {
@@ -15,13 +15,13 @@ let ladder = {
   down() { 
     this.step--;
   },
-  showStep: function() { // shows the current step
+  showStep: function() { // menunjukkan langkah yang sekarang
     alert( this.step );
   }
 };
 ```
 
-Now, if we need to make several calls in sequence, can do it like this:
+Kini, jika kita perlu untuk membuat beberapa panggilan secara berurutan, bisa dilakukan dengan cara seperti ini:
 
 ```js
 ladder.up();
@@ -30,10 +30,10 @@ ladder.down();
 ladder.showStep(); // 1
 ```
 
-Modify the code of `up`, `down` and `showStep` to make the calls chainable, like this:
+Modifikasi kode `up`, `down` dan `showStep` untuk membuat panggilan-panggilan tersebut dapat dirantaikan satu sama lain, seperti ini:
 
 ```js
 ladder.up().up().down().showStep(); // 1
 ```
 
-Such approach is widely used across JavaScript libraries.
+Pendekatan demikian digunakan secara luas di banyak *library* JavaScript.