Merge branch 'master' into abdmmar-branch

Author: abdmmar

1-js/01-getting-started/1-intro/article.md

@@ -24,9 +24,15 @@ Browser punya engine yang tertanam didalamnya yang disebut "JavaScript virtual m
 
 Tiap engine punya *codename*-nya sendiri. Misalnya:
 
+<<<<<<< HEAD
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- di Chrome dan Opera.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- di Firefox.
 - ...Ada juga codename lain seperti "Trident" dan "Chakra" untuk versi berbeda dari IE, "ChakraCore" untuk Microsoft Edge, "Nitro" dan "SquirrelFish" untuk Safari, dll.
+=======
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+- ...There are other codenames like "Chakra" for IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari, etc.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Istilah di atas sebaiknya diingat karena akan sering digunakan dalam artikel para developer di internet. Kita akan menggunakannya juga. Misalnya, jika "fitur X didukung V8", kemungkinan ia bisa jalan di Chrome dan Opera.
 

1-js/02-first-steps/05-types/article.md

@@ -81,15 +81,23 @@ const bigInt = 1234567890123456789012345678901234567890n;
 
 Sebenarnya `BigInt` jarang dibutuhkan, kita tidak akan mempelajarinya disini, tetapi akan dipisahkan didalam bagian <info:bigint>. Baca saja saat kamu membutuhkan nilai *integer* yang sangat panjang.
 
+<<<<<<< HEAD
 <<<<<<< HEAD
 ```smart header="Masalah Kompabilitas"
 Sekarang `BigInt` sudah didukung oleh Firefox/Chrome/Edge, tapi tidak didalam Safari/Internet Explorer.
 =======
 ```smart header="Compatibility issues"
 Right now `BigInt` is supported in Firefox/Chrome/Edge, but not in Safari/IE.
 >>>>>>> f830bc5d9454d85829e011d914f215eb5896579a
+=======
+
+```smart header="Compatibility issues"
+Right now, `BigInt` is supported in Firefox/Chrome/Edge/Safari, but not in IE.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 ```
 
+You can check [*MDN* BigInt compatibility table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) to know which versions of a browser are supported.
+
 ## String
 
 String di JavaScript harus dikelilingi petik.

1-js/02-first-steps/08-operators/4-fix-prompt/solution.md

@@ -9,12 +9,16 @@ let b = "2"; // prompt("Angka kedua?", 2);
 alert(a + b); // 12
 ```
 
+<<<<<<< HEAD
 <<<<<<< HEAD
 Apa yang kita harus lakukan untuk mengubah string menjadi angka sebelum `+`, gunakan `Number()` atau menambahkannya dengan `+`.
 =======
 What we should do is to convert strings to numbers before `+`. For example, using `Number()` or
 prepending them with `+`.
 >>>>>>> ff152b126ec70a9de919bfdc1913215539d37187
+=======
+What we should do is to convert strings to numbers before `+`. For example, using `Number()` or prepending them with `+`.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Contoh, tepat sebelum `prompt`:
 

1-js/02-first-steps/08-operators/article.md

@@ -183,7 +183,11 @@ Tanda kurung mengesampingkan presedensi apapun, jadi jika kita tak puas dengan u
 
 Ada banyak operator di JavaScript. Tiap operator punya nomor presedensi masing-masing. Nomor yang lebih besar dieksekusi terlebih dahulu. Jika presedensinya sama, urutan eksekusinya dari kiri ke kanan.
 
+<<<<<<< HEAD
 Di sini adalah extrak dari [tabel presedensi](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (kamu tak usah mengingat ini, tapi catat bahwa operator unary lebih tinggi dari binary terkait):
+=======
+Here's an extract from the [precedence table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (you don't need to remember this, but note that unary operators are higher than corresponding binary ones):
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 | Presedensi | Nama | Tanda |
 |------------|------|------|

1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

@@ -12,10 +12,20 @@ null === +"\n0\n" → false
 
 Beberapa alasan:
 
+<<<<<<< HEAD
 1. Sudah jelas, true.
 2. Pembandingan kamus, jadi false. `"a"` lebih kecil dari `"p"`.
 3. Lagi, pembandingan kamus, karakter pertama `"2"` lebih besar dari karakter pertama `"1"`.
 4. Nilai `null` dan `undefined` selalu bernilai sama.
 5. Equalitas ketat memang ketat. Tipe berbeda dari kedua sisi menghasilkan false.
 6. Serupa dengan `(4)`, `null` hanya sama dengan `undefined`.
 7. Equalitas ketat dari tipe berbeda.
+=======
+1. Obviously, true.
+2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
+3. Again, dictionary comparison, first char `"2"` is greater than the first char `"1"`.
+4. Values `null` and `undefined` equal each other only.
+5. Strict equality is strict. Different types from both sides lead to false.
+6. Similar to `(4)`, `null` only equals `undefined`.
+7. Strict equality of different types.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d

1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md

@@ -4,6 +4,10 @@ nilai penting: 3
 
 # Cek kisaran antara
 
+<<<<<<< HEAD
 Tulis satu kondisi "if" untuk mengecek bahwa `age` ada di antara `14` dan `90` secara inklusif.
+=======
+Write an `if` condition to check that `age` is between `14` and `90` inclusively.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 "Secara inklusif" artinya bahwa `age` bisa mencapai `14` atau `90`.

1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md

@@ -4,6 +4,10 @@ nilai penting: 3
 
 # Cek kisaran luar
 
+<<<<<<< HEAD
 Tulis satu kondisi `if` untuk mengecek bahwa `age` BUKAN di antara 14 dan 90 secara inklusif.
+=======
+Write an `if` condition to check that `age` is NOT between `14` and `90` inclusively.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Buat dua varian: pertama menggunakan NOT `!`, kedua -- tanpaanya.

1-js/02-first-steps/11-logical-operators/9-check-login/solution.md

@@ -3,19 +3,19 @@
 ```js run demo
 let userName = prompt("Who's there?", '');
 
-if (userName == 'Admin') {
+if (userName === 'Admin') {
 
   let pass = prompt('Password?', '');
 
-  if (pass == 'TheMaster') {
+  if (pass === 'TheMaster') {
     alert( 'Welcome!' );
-  } else if (pass == '' || pass == null) {
+  } else if (pass === '' || pass === null) {
     alert( 'Canceled' );
   } else {
     alert( 'Wrong password' );
   }
 
-} else if (userName == '' || userName == null) {
+} else if (userName === '' || userName === null) {
   alert( 'Canceled' );
 } else {
   alert( "I don't know you" );

1-js/02-first-steps/11-logical-operators/article.md

@@ -84,7 +84,11 @@ Operator OR `||` melakukan hal berikut:
 
 Nilai dikembalikan di bentuk originalnya, tanpa konversi.
 
+<<<<<<< HEAD
 Dengan kata lain, rantai OR `"||"` mengembalikan nilai truthy pertama atau yang terakhir jika tak ada nilai truthy.
+=======
+In other words, a chain of OR `||` returns the first truthy value or the last one if no truthy value is found.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 Misalnya:
 
@@ -101,9 +105,15 @@ Hal ini menjadikan penggunaan yang menarik dibanding "OR booleanpure, classical,
 
 1. **Dapatkan nilai truthy dari daftar variabel atau expresi.**
 
+<<<<<<< HEAD
     Untuk contoh, kita punya variabel `firstName`, `lastName` dan `nickName`, semuanya bersifat opsional.
 
     Kita gunakan OR `||` untuk memilih satu-satunya yang memiliki data dan menampilkannya (atau `anonymous` jika belum ada yang ditentukan atau di set):
+=======
+    For instance, we have `firstName`, `lastName` and `nickName` variables, all optional (i.e. can be undefined or have falsy values).
+
+    Let's use OR `||` to choose the one that has the data and show it (or `"Anonymous"` if nothing set):
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
     ```js run
     let firstName = "";
@@ -115,7 +125,11 @@ Hal ini menjadikan penggunaan yang menarik dibanding "OR booleanpure, classical,
     */!*
     ```
 
+<<<<<<< HEAD
     Jika semua variabel bernilai falsy, `Anonymous` akan muncul.
+=======
+    If all variables were falsy, `"Anonymous"` would show up.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 
 2. **Evaluasi Short-circuit.**
 
@@ -223,11 +237,15 @@ Presedensi operator AND `&&` lebih tinggi dari OR `||`.
 Jadi kode `a && b || c && d` esensinya sama dengan jika expresi `&&` dibungkus tanda kurung: `(a && b) || (c && d)`.
 ````
 
+<<<<<<< HEAD
 <<<<<<< HEAD
 ````warn header="Jangan ganti `if` dengan || atau &&"
 Terkadang, orang-orang menggunakan operator AND `&&` untuk "memperpendek instruksi `if`".
 =======
 ````warn header="Don't replace `if` with || or &&"
+=======
+````warn header="Don't replace `if` with `||` or `&&`"
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 Sometimes, people use the AND `&&` operator as a "shorter way to write `if`".
 >>>>>>> f830bc5d9454d85829e011d914f215eb5896579a
 
@@ -249,7 +267,11 @@ let x = 1;
 if (x > 0) alert( 'Greater than zero!' );
 ```
 
+<<<<<<< HEAD
 Walaupun, versi dengan `&&` muncul lebih pendek, `if` menjadi jelas dan sedikit lebih mudah dibaca. Jadi kita merekomendasikan menggunakannya untuk setiap kebutuhan: gunakan `if` jika kita ingin if dan gunakan `&&` jika kita ingin AND.
+=======
+Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
+>>>>>>> f489145731a45df6e369a3c063e52250f3f0061d
 ````
 
 

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -2,56 +2,93 @@
 
 [recent browser="new"]
 
-Operator penggabungan *nullish* `??` menyediakan sintaks yang pendek untuk memilih nilai yang telah didefinisikan/*defined* dari daftar.
+Disini, didalam artikel ini, kita bisa mengatakan sebuah ekspresi telah "didefinisikan" ketika nilainya bukanlah `null` ataupun `undefined`.
 
-Hasil dari sebuah `a ?? b` adalah:
-- `a` jika nilainya tidak `null` atau `undefined`,
-- `b` jika sebaliknya.
+Operator penggabungan nullish ditulis sebagai dua tanda tanya `??`.
 
-Jadi, `x = a ?? b` adalah kependekan yang sama seperti:
+Hasil dari `a ?? b` adalah:
+- jika `a` telah didefinisikan, maka `a`,
+- jika `a` belum didefinisikan, maka `b`.
+
+
+Dengan kata lain, `??` mengembalikan argumen pertama jika argumen tersebut telah didefinisikan. Sebaliknya, mengembalikan argumen kedua jika argumen pertama belum didefinisikan.
+
+Operator penggabung nullish bukanlah sesuatu yang benar-benar baru. Operator itu hanyalah sebuah sintaks yang bagus untuk mendapatkan nilai pertama yang telah "didefinisikan" dari dua nilai.
+
+Kita bisa menulis ulang `result = a ?? b` menggunakan operator yang sudah kita ketahui, seperti ini:
 
 ```js
-x = (a !== null && a !== undefined) ? a : b;
+result = (a !== null && a !== undefined) ? a : b;
 ```
 
-Kita lihat contoh yang lebih panjang.
+Penggunaan umum untuk `??` adalah untuk menyediakan nilai _default_ untuk variabel yang mungkin _undefined_.
 
-Bayangkan, kita mempunyai seorang pengguna, dan terdapat variabel `firstName`, `lastName` atau `nickName` untuk nama depan, nama belakang atau nama panggilan. Semuanya akan menjadi *undefined*, jika pengguna tidak memasukan nilai apapun.
+Sebagai contoh, kita disini menampilkan `Anonymous` jika `user` belum didefinisikan:
 
-Kita ingin menampilkan nama penggunanya: Salah satu dari nilai variabel tersebut atau tampilkan Anonim jika tidak ada nama yang dimasukan.
+```js run
+let user;
 
-Ayo kita gunakan operator `??` untuk memilih nilai pertama yang sudah terdefinisikan:
+alert(user ?? "Anonymous"); // Anonymous
+```
+
+tentu saja, jika `user` memiliki nilai apapun kecuali `null/undefined`, maka kita akan bisa melihat nilainya:
+
+```js run
+let user = "John";
+
+alert(user ?? "Anonymous"); // John
+```
+
+Kita juga bisa menggunakan rentetan `??` untuk mendapatkan nilai yang telah didefinisikan dari sebuah daftar.
+
+Katakan kita memiliki sebuah data _user_ didalam sebuah variabel `firstName`, `lastName`, atau `nickName`. Semuanya mungkin saya memiliki nilai _undefined_, jika _user_ nya tidak memasukan nilainya.
+
+Kita ingin menampilkan nama _user_ menggunakan salah satu dari variabel ini, atau menampilkan "Anonymous" jika semua nilainya adalah _undefined_.
+
+Kita coba gunakan operator `??` untuk hal itu:
 
 ```js run
 let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// tampilkan nilai pertama yang tidak bernilai null/undefined
+// tampilkan nilai pertama yang telah didefinisikan:
 *!*
 alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
 */!*
 ```
 
 ## Perbandingan dengan ||
 
-Operator OR `||` bisa digunakan dengan cara yang sama dengan operator `??`. Sebenarnya kita bisa menggantikan `??` dengan `||` di kode diatas dan mendapatkan hasil yang sama, seperti yang dijelaskan di [bab sebelumnya](info:logical-operators#or-finds-the-first-truthy-value).
-
-Perbedaan yang paling penting adalah:
-- `||` mengembalikan nilai *truthy* pertama.
-- `??` mengembalikan nilai *defined*/terdefinisikan pertama.
+Operator OR `||` bisa digunakan dengan cara yag sama seperti `??`, seperti yang telah dijelaskan didalam [bab sebelumnya](info:logical-operators#or-finds-the-first-truthy-value).
 
-Hal ini menjadi perhatian ketika kita ingin memperlakukan nilai `null/undefined` secara berbeda dengan `0`.
+Untuk contoh, pada kode diatas kita bisa mengganti `??` dengan `||` dan tetap mendapatkan hasil yang sama:
 
-Contoh, coba perhatikan:
+```js run
+let firstName = null;
+let lastName = null;
+let nickName = "Supercoder";
 
-```js
-height = height ?? 100;
+// tampilkan nilai pertama yang bernilai truthy:
+*!*
+alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
+*/!*
 ```
 
-Potongan kode diatas akan memberikan nilai `100` jika `height` tidak terdefinisikan/*undefined*.
+Operator OR `||` sudah ada sejak awal mula dari Javascript, jadi sudah sejak lama pengembang menggunakan operator _or_ untuk kebutuhan seperti contoh diatas.
+
+Disisi yang lain, operator penggabung nullish `??` baru saja ditambahkan, dan alasan penambahannya adalah karena para pengembang kurang senang dengan `||`.
+
+Perbedaan halus, tapi penting adalah:
+- `||` mengembalikan nilai *truthy* pertama.
+- `??` mengembalikan nilai *terdefinisi* pertama.
+
+Dengan kata lain, `||` tidak membedakan antara `false`, `0`, sebuah string kosong `""` dan `null/undefined`. Mereka dilihat sama oleh `||` -- nilai _falsy_. Jika salah satu nilai tersebut berada pada argumen pertama dari `||`, maka kita akan mendapatkan argumen kedua sebagai hasilnya.
+
+Didalam penggunaannya, kita mungkin ingin menggunakan nilai _default_ hanya ketika variabelnya adalah `null/undefined`. Itulah, ketika nilainya benar-benar tidak diketahui/tidak diset.
 
-Lalu kita coba bandingkan dengan `||`:
+
+Contoh, perhatikan ini:
 
 ```js run
 let height = 0;
@@ -60,20 +97,20 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-Disini, `height || 100` akan memperlakukan `0` sebagai belum didefinisikan/*undefined*, sama seperti `null`, `undefined` atau nilai *falsy* lainnya. Jadi nilainya adalah `100`.
+Disini, kita memiliki _height_ nol.
 
-Sedangkan `height ?? 100` akan mengembalikan `100` hanya jika `height` nilainya `null` atau `undefined`. Jadi `alert`nya akan menampilkan nilai `height` sama dengan `0`.
+- Bagian `height || 100` memeriksa `height` sebagai nilai yang _falsy_, dan ternyata benar.
+    - jadi hasilnya adalah argumen kedua, `100`.
+- Bagian `height ?? 100` memeriksa `height` sebagai `null/undefined`, dan ternyata tidak.
+    - jadi hasil dari `height` adalah "sebagaimana adanya", yang mana adalah `0`.
 
-Jadi mana yang lebih baik, tergantung pada kasus-kasus tertentu atau kasus yang dihadapi.
-Ketika nilai `0` adalah nilai yang valid, maka `??` menjadi rekomendasi.
+Jika kita asumsikan bahwa _height_ nol adalah nilai yang valid, maka nilainya tidak seharusnya diganti dengan nilai _default_, maka `??` melakukan hal yang benar.
 
 ## Precedence/Hak lebih tinggi
 
-Operator `??` memiliki nilai *precedence*: `5` didalam [Tabel MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
-
-Jadi `??` akan dievaluasi setelah kebanyakan operasi lainnya, tapi sebelum `=` dan `?`.
+_Precedence_ dari operator `??` agak rendah: `5` didalam [tabel MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). Jadi `??` akan dievaluasi sebelum `=` dan `?`, tapi setelah di kebanyakan dari operasi lainnya, seperti `+`, `*`.
 
-Jika kita ingin memilih sebuah nilai dengan `??` didalam ekspresi yang kompleks, cobalah untuk menggunakan kurung:
+Jadi jika kita ingin memilih sebuah nilai dengan `??` didalam sebuah ekspresi dengan operator lain, cobalah untuk menggunakan kurung:
 
 ```js run
 let height = null;
@@ -85,18 +122,19 @@ let area = (height ?? 100) * (width ?? 50);
 alert(area); // 5000
 ```
 
-Sebaliknya, jika kita menghilangkan kurung, `*` akan memiliki nilai *precedence* lebih tinggi dari `??` dan akan dijalankan lebih dulu.
-
-Dan akan dijalankan sama seperti:
+Sebaliknya, jika kita menghilangkan kurungnya, maka operator `*` akan memiliki nilai _precedence_ yang lebih tinggi dari `??`, yang mana akan dieksekusi pertama, yang akan menghasilkan nilai yang salah.
 
 ```js
-// mungkin kurang tepat
+// tanpa kurung
+let area = height ?? 100 * width ?? 50;
+
+// ...akan dieksekusi sama seperti ini (mungkin bukan ini yang kita inginkan):
 let area = height ?? (100 * width) ?? 50;
 ```
 
-Dan juga terdapat sebuah batasan untuk level-bahasa.
+### Menggunakan ?? dengan && atau ||
 
-**Karena masalah keamanan, sangat tidak direkomendasikan untuk menggunakan `??` bersamaan dengan operator `&&` dan `||`.**
+Karena masalah keamanan, javascript melarang menggunakan operator `??` bersama dengan `&&` dan `||`, kecuali jika kita secara jelas menggunakan kurung.
 
 Kode dibawah akan menampilkan sintaks error: