Sync with upstream @ 23da191b

1-js/01-getting-started/4-devtools/article.md

@@ -8,7 +8,11 @@ Supaya bisa melihat error dan memperoleh informasi berfaedah lainnya dari script
 
 Kebanyakan pengembang memakai Chrome atau Firefox untuk pengembangan karena tools pengembangan yang mereka punya paling mantap. Peramban lain punya juga koq, ada with special features, but are usually playing "catch-up" to Chrome or Firefox. So most developers have a "favorite" browser and switch to others if a problem is browser-specific.
 
+<<<<<<< HEAD
 Tools pengembang mengandung faedah; mereka punya banyak fitur. Untuk memulainya, kita akan belajar cara membuka mereka, mencari error, dan menjalankan perintah JavaScript.
+=======
+Developer tools are potent, they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 ## Google Chrome
 

1-js/02-first-steps/01-hello-world/article.md

@@ -9,7 +9,11 @@ Jadi pertama, kita lihat bagaimana kita menyisipkan script ke laman web. Untuk l
 
 ## Tag "script"
 
+<<<<<<< HEAD
 Program JavaScript bisa disisipkan ke dalam bagian mana saja dari dokumen HTML dengan bantuan tag `<script>`.
+=======
+JavaScript programs can be inserted almost anywhere into an HTML document using the `<script>` tag.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 Contoh:
 

1-js/04-object-basics/01-object/article.md

@@ -92,6 +92,7 @@ let user = {
 ```
 Itu disebut koma "buntut" atau "menggantung". Memudahkan kita menambah/menghapus/memindahkan properti, karena semua barus menjadi mirip.
 
+<<<<<<< HEAD
 ````smart header="Objek dengan const bisa diubah"
 Perhatikan: sebuah object yang dideklarasikan dengan `const` *bisa* diubah.
 
@@ -117,6 +118,9 @@ Ada cara lain untuk mengubah properti objek konstan(constant), kita akan mengula
 ````
 
 ## Kurung siku
+=======
+## Square brackets
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 Untuk properti multi-kata, akses dot tak bekerja:
 

1-js/04-object-basics/02-object-copy/article.md

@@ -99,6 +99,7 @@ admin.name = 'Pete'; // mengganti admin dengan menggunakan "referensi"
 alert(*!*user.name*/!*); // 'Pete', perubahan akan terlihat pada "user"
 ```
 
+<<<<<<< HEAD
 <<<<<<< HEAD
 Contoh diatas mendemonstrasikan bahwa disana hanya ada satu objek. Seperti jika kita punya sebuah lemari dengan dua kunci dan satunya (`admin`) digunakan untuk masuk kedalamnya. Lalu, jika kita nanti menggunakan kunci lainnya (`user`) kita bisa melihat perubahannya.
 
@@ -111,6 +112,8 @@ Operator pembanding `==` dan pembanding ketat `===` untuk objek bekerja sama saj
 Dibawah adalah dua variabel yang mereferensi ke objek yang sama, dengan demikian mereka sama:
 =======
 
+=======
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 It's just as if we had a cabinet with two keys and used one of them (`admin`) to get into it. Then, if we later use another key (`user`) we can see changes.
 
 ## Comparison by reference
@@ -284,7 +287,35 @@ Kita bisa menggunakan rekursi untuk mengimplementasikannya. Atau, jangan ambil p
 We can use recursion to implement it. Or, not to reinvent the wheel, take an existing implementation, for instance [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) from the JavaScript library [lodash](https://lodash.com).
 >>>>>>> ff152b126ec70a9de919bfdc1913215539d37187
 
+<<<<<<< HEAD
 ## Ringkasan
+=======
+```smart header="Const objects can be modified"
+An important "side effect" of storing objects as references is that an object declared as `const` *can* be modified.
+
+For instance:
+
+```js run
+const user = {
+  name: "John"
+};
+
+*!*
+user.name = "Pete"; // (*)
+*/!*
+
+alert(user.name); // Pete
+```
+
+It might seem that the line `(*)` would cause an error, but no. The value of `user` is constant, it must always reference the same object. But properties of that object are free to change.
+
+In other words, the `const user` gives an error only if we try to set `user=...` as a whole, and that's all.
+
+That said, if we really need to make constant object properties, it's also possible, but using totally different methods, we'll mention that in the chapter <info:property-descriptors>.
+```
+
+## Summary
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 objek dibuat dan disalin dengan menggunakan referensi. Dengan kata lain, sebuah variable menyimpan bukanlah "nilai objek", tapi sebuah "referensi" (address/alamat di memori) untuk nilainya. Jadi menyalin sebuah variabel atau memindahkannya sebagai fungsi argumen akan menyalin referensinya, bukan objeknya.
 

1-js/04-object-basics/07-optional-chaining/article.md

@@ -134,7 +134,7 @@ Ini ada cara teraman untuk mengakses `user.address.street`:
 =======
 In other words, `value?.prop`:
 - is the same as `value.prop` if `value` exists,
-- otherwise (when `value` is `undefined/null`) it returns that `value`.
+- otherwise (when `value` is `undefined/null`) it returns `undefined`.
 
 >>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 Here's the safe way to access `user.address.street` using `?.`:

1-js/05-data-types/05-array-methods/article.md

@@ -772,8 +772,12 @@ Metode-metode ini adalah yang paling sering digunakan, mencakupi 99% kasus pengg
 
   The function `fn` is called on each element of the array similar to `map`. If any/all results are `true`, returns `true`, otherwise `false`.
 
+<<<<<<< HEAD
   These methods behave sort of like `||` and `&&` operators: if `fn`  returns a truthy value, `arr.some()` immediately returns `true` and stops iterating over the rest items; if `fn`  returns a falsy value, `arr.every()` immediately returns `false` and stops iterating over the rest items as well.
 >>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
+=======
+  These methods behave sort of like `||` and `&&` operators: if `fn` returns a truthy value, `arr.some()` immediately returns `true` and stops iterating over the rest items; if `fn`  returns a falsy value, `arr.every()` immediately returns `false` and stops iterating over the rest items as well.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 <<<<<<< HEAD
 - [arr.fill(value, start, end)](mdn:js/Array/fill) -- mengisi *array* dengan mengulang `value` dari indeks `start` hingga `end`.

1-js/06-advanced-functions/01-recursion/02-factorial/solution.md

@@ -1,4 +1,8 @@
+<<<<<<< HEAD
 Secara definisi, sebuah faktorial adalah `n!` bisa ditulis juga sebagai `n * (n-1)`.
+=======
+By definition, a factorial `n!` can be written as `n * (n-1)!`.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 Dengan kata lain, hasil dari `factorial(n)` bisa juga dikalkulasikan sebagai `n` dikalikan dengan hasil dari `factorial(n-1)`. Dan pemanggilan untuk `n-1` bisa secara rekursi menurun, dan terus menurun sampai `1`.
 

1-js/06-advanced-functions/01-recursion/article.md

@@ -133,7 +133,11 @@ Kita bisa menggambarkannya seperti:
   </li>
 </ul>
 
+<<<<<<< HEAD
 Itu ketika fungsi mulai dieksekusi. Kondisinya `n == 1` adalah false, jadi alurnya berlanjut ke cabang kedua dari `if`:
+=======
+That's when the function starts to execute. The condition `n == 1` is falsy, so the flow continues into the second branch of `if`:
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 ```js run
 function pow(x, n) {
@@ -190,7 +194,11 @@ Konteks eksekusi baru yang sekarang berada di atas (dan jelas), dan konteks yang
 Ketika kita menyelesaikan subcall -- itu akan mudah untuk melanjutkan konteks sebelumnya, karena itu tetap menyimpan kedua variabel dan tempat yang tepat dimana kode itu berhenti.
 
 ```smart
+<<<<<<< HEAD
 Disini dialam gambar kita gunakan kata "line", sebagai contoh disana terdapat satu subcall didalam baris, tapi secara umum sebuah baris dari kode mungkin mengandung subcall ganda, seperti `pow(…) + pow(…) + somethingElse(…)`.
+=======
+Here in the picture we use the word "line", as in our example there's only one subcall in line, but generally a single line of code may contain multiple subcalls, like `pow(…) + pow(…) + somethingElse(…)`.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 Jadi itu harus menjadi lebih presisi untuk dikatakan eksekusi berlanjut "langsung seterlah subcall".
 ```

1-js/11-async/01-callbacks/article.md

@@ -152,7 +152,7 @@ loadScript('/my/script.js', function(script) {
     });
 */!*
 
-  })
+  });
 
 });
 ```
@@ -229,7 +229,7 @@ loadScript('1.js', function(error, script) {
         });
 
       }
-    })
+    });
   }
 });
 ```
@@ -262,7 +262,7 @@ loadScript('1.js', function(error, script) {
           }
         });
       }
-    })
+    });
   }
 });
 -->
@@ -302,7 +302,7 @@ function step3(error, script) {
   } else {
     // ...berlanjut setelah semua script dimuat(*)
   }
-};
+}
 ```
 
 Lihat? Itu sama saja, dan tidak ada sarang yang dalam sekarang karena kita buat setiap action menjadi fungsi top-level yang terpisah.

1-js/11-async/03-promise-chaining/article.md

@@ -276,7 +276,11 @@ fetch("/article/promise-chaining/user.json")
 
 Sekarang mari lakukan sesuatu dengan memuat pengguna.
 
+<<<<<<< HEAD
 Sebagai contoh, kita dapat membuat satu atau lebih permintaan ke GitHub, muat profil pengguna dan tunjukkan avatarnya:
+=======
+For instance, we can make one more request to GitHub, load the user profile and show the avatar:
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 ```js run
 // Buat permintaan ke user.json

1-js/11-async/05-promise-api/article.md

@@ -184,6 +184,7 @@ Jika peramban tidak mendukung `Promise.allSettled`, mudah untuk melakukan polyfi
 
 ```js
 if (!Promise.allSettled) {
+<<<<<<< HEAD
   Promise.allSettled = function (promises) {
     return Promise.all(
       promises.map((p) =>
@@ -199,6 +200,15 @@ if (!Promise.allSettled) {
         )
       )
     );
+=======
+  const rejectHandler = reason => ({ status: 'rejected', reason });
+
+  const resolveHandler = value => ({ status: 'fulfilled', value });
+
+  Promise.allSettled = function (promises) {
+    const convertedPromises = promises.map(p => Promise.resolve(p).then(resolveHandler, rejectHandler));
+    return Promise.all(convertedPromises);
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
   };
 }
 ```

1-js/11-async/06-promisify/article.md

@@ -99,7 +99,7 @@ function promisify(f) {
       f.call(this, ...args); // panggil fungsi aslinya
     });
   };
-};
+}
 
 // penggunaan:
 let loadScriptPromise = promisify(loadScript);
@@ -113,8 +113,12 @@ The code may look a bit complex, but it's essentially the same that we wrote abo
 
 A call to `promisify(f)` returns a wrapper around `f` `(*)`. That wrapper returns a promise and forwards the call to the original `f`, tracking the result in the custom callback `(**)`.
 
+<<<<<<< HEAD
 Here, `promisiefy` assumes that the original function expects a callback with exactly two arguments `(err, result)`. That's what we encounter most often. Then our custom callback is in exactly the right format, and `promisify` works great for such a case.
 >>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
+=======
+Here, `promisify` assumes that the original function expects a callback with exactly two arguments `(err, result)`. That's what we encounter most often. Then our custom callback is in exactly the right format, and `promisify` works great for such a case.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 Tetapi bagaimana jika `f` asli mengharapkan callback dengan lebih banyak argumen `callback(err, res1, res2, ...)`?
 
@@ -146,11 +150,11 @@ function promisify(f, manyArgs = false) {
       f.call(this, ...args);
     });
   };
-};
+}
 
 // penggunaan:
 f = promisify(f, true);
-f(...).then(arrayOfResults => ..., err => ...)
+f(...).then(arrayOfResults => ..., err => ...);
 ```
 
 <<<<<<< HEAD

1-js/11-async/08-async-await/01-rewrite-async/task.md

@@ -4,13 +4,24 @@ Tulis ulang salah satu contoh di bab ini <info:promise-chaining> menggunakan `as
 
 ```js run
 function loadJson(url) {
+<<<<<<< HEAD
   return fetch(url).then((response) => {
     if (response.status == 200) {
       return response.json();
     } else {
       throw new Error(response.status);
     }
   });
+=======
+  return fetch(url)
+    .then(response => {
+      if (response.status == 200) {
+        return response.json();
+      } else {
+        throw new Error(response.status);
+      }
+    });
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 }
 
 loadJson('no-such-user.json')

1-js/11-async/08-async-await/02-rewrite-async-2/task.md

@@ -2,7 +2,13 @@
 
 Di bawah anda dapat menemukan contoh "rethrow" dari bab <info:promise-chaining>. Tulis ulang menggunakan `async/await` daripada `.then/catch`.
 
+<<<<<<< HEAD
 Dan singkirkan rekursi yang mendukung masuk loop dalam `demoGithubUser`: dengan `async/await` itu menjadi mudah untuk dilakukan.
+=======
+Below you can find the "rethrow" example. Rewrite it using `async/await` instead of `.then/catch`.
+
+And get rid of the recursion in favour of a loop in `demoGithubUser`: with `async/await` that becomes easy to do.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 ```js run
 class HttpError extends Error {
@@ -14,13 +20,24 @@ class HttpError extends Error {
 }
 
 function loadJson(url) {
+<<<<<<< HEAD
   return fetch(url).then((response) => {
     if (response.status == 200) {
       return response.json();
     } else {
       throw new HttpError(response);
     }
   });
+=======
+  return fetch(url)
+    .then(response => {
+      if (response.status == 200) {
+        return response.json();
+      } else {
+        throw new HttpError(response);
+      }
+    });
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 }
 
 // Tanya nama pengguna sampai github mengembalikkan user yang valid

1-js/12-generators-iterators/2-async-iterators-generators/article.md

@@ -307,7 +307,11 @@ Sekarang _value_ datang dengan jeda 1 detik di antara mereka.
 ```smart
 Secara teknis, kita bisa menambahkan `Symbol.iterator` dan `Symbol.asyncIterator` ke objek, jadi keduanya secara sinkron (`for..of`) dan asinkron (`for await..of`) _iterable_.
 
+<<<<<<< HEAD
 Namun dalam praktiknya, itu akan menjadi hal yang aneh untuk dilakukan.
+=======
+In practice though, that would be a weird thing to do.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 ```
 
 ## Contoh kehidupan nyata: _paginated_ data
@@ -371,10 +375,19 @@ Penjelasan lebih lanjut tentang cara kerjanya:
    - URL awalnya adalah `https://api.github.com/repos/<repo>/commits`, dan halaman berikutnya akan berada di `Link` header tanggapan.
    - Metode `fetch` memungkinkan kita untuk memberikan otorisasi dan tajuk lainnya jika diperlukan -- di sini GitHub memerlukan `User-Agent`.
 
+<<<<<<< HEAD
 2. _commits_ dikembalikan dalam format JSON.
 3. Kita harus mendapatkan URL halaman berikutnya dari tajuk `Link` dari respon. Ini memiliki format khusus, jadi kita menggunakan ekspresi reguler untuk itu.
    - URL halaman berikutnya mungkin terlihat seperti ini `https://api.github.com/repositories/93253246/commits?page=2`. Ini dihasilkan oleh GitHub itu sendiri.
 4. Kemudian kita menghasilkan _commits_ yang diterima satu per satu, dan ketika mereka selesai, iterasi `while(url)` berikutnya akan terpicu, membuat satu permintaan lagi.
+=======
+    - The initial URL is `https://api.github.com/repos/<repo>/commits`, and the next page will be in the `Link` header of the response.
+    - The `fetch` method allows us to supply authorization and other headers if needed -- here GitHub requires `User-Agent`.
+2. The commits are returned in JSON format.
+3. We should get the next page URL from the `Link` header of the response. It has a special format, so we use a regular expression for that (we will lern this feature in [Regular expressions](info:regular-expressions)).
+    - The next page URL may look like `https://api.github.com/repositories/93253246/commits?page=2`. It's generated by GitHub itself.
+4. Then we yield the received commits one by one, and when they finish, the next `while(url)` iteration will trigger, making one more request.
+>>>>>>> 23da191b58643387783f38e999f5b05be87d3d93
 
 Contoh penggunaan (menunjukkan penulis _commit_ di konsol):
 

1-js/13-modules/01-modules-intro/article.md

@@ -260,7 +260,7 @@ Compare to regular script below:
 
 <script>
 *!*
-  alert(typeof button); // Error: button is undefined, the script can't see elements below
+  alert(typeof button); // button is undefined, the script can't see elements below
 */!*
   // regular scripts run immediately, before the rest of the page is processed
 </script>

1-js/99-js-misc/01-proxy/01-error-nonexisting/solution.md

@@ -19,5 +19,5 @@ function wrap(target) {
 user = wrap(user);
 
 alert(user.name); // John
-alert(user.age); // ReferenceError: Property doesn't exist "age"
+alert(user.age); // ReferenceError: Property doesn't exist: "age"
 ```

1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md

@@ -27,6 +27,6 @@ user = wrap(user);
 
 alert(user.name); // John
 *!*
-alert(user.age); // ReferenceError: Property doesn't exist "age"
+alert(user.age); // ReferenceError: Property doesn't exist: "age"
 */!*
 ```