Merge pull request #55 from javascript-tutorial/sync-5b195795

Sync with upstream @ 5b19579

Author: thickkoezz

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

@@ -38,7 +38,7 @@ Engine sangat rumit. Tapi basicnya mudah.
 2. Lalu ia mengkonversi ("mengkompilasi") script tersebut menjadi bahasa mesin.
 3. Dan kemudian kode mesin berjalan, lumayan cepat.
 
-Engine melakukan optimisasi di setiap langkah proses. Dia bahkan memperhatikan script yang telah dikompilasi saat sedang berjalan, menganalisa data yang mengalir di dalam, dan melakukan optimisasi ke kode mesin berdasarkan pengetahuan itu. Ketika selesai, script berjalan lumayan cepat.
+Engine melakukan optimisasi di setiap langkah proses. Dia bahkan memperhatikan script yang telah dikompilasi saat sedang berjalan, menganalisa data yang mengalir di dalam, dan melakukan optimisasi ke kode mesin berdasarkan pengetahuan itu.
 ```
 
 ## Apa yang bisa dilakukan *in-browser JavaScript*?

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

@@ -29,10 +29,15 @@ Tampilan persisnya tools pengembang tergantung versi Chrome kamu. Ia berubah dar
 - Di sini kita bisa melihat pesan error berwarna merah. Di sini, scriptnya mengandung perintah asing "lalala".
 - Di kanan, ada link yang bisa diklik ke sumber `bug.html:12` dengan nomor baris di mana error itu muncul.
 
-Di bawah pesan error, ada simbol `>` berwarna biru. Ia menandakan "command line" di mana kita bisa mengetik perintah JavaScript. Tekan `key:Enter` untuk menjalankannya (`key:Shift+Enter` untuk menginput perintah multi-baris).
+Di bawah pesan error, ada simbol `>` berwarna biru. Ia menandakan "command line" di mana kita bisa mengetik perintah JavaScript. Tekan `key:Enter` untuk menjalankannya.
 
 Sekarang kita bisa melihat error, dan itu sudah cukup untuk permulaan. Kita nanti akan kembali ke tools pengembang dan mengcover debugging lebih dalam di bab <info:debugging-chrome>.
 
+```smart header="Multi-line input"
+Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+
+To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+```
 
 ## Firefox, Edge, dan lainnya
 
@@ -50,12 +55,6 @@ Buka Preferences dan pergi ke "Advanced" pane. Di sana ada checkbox di sebelah b
 
 Sekarang `key:Cmd+Opt+C` bisa mentoggle konsol. Lalu, menu "Develop" muncul pada menu item di atas. Ia punya banyak perintah dan opsi.
 
-```smart header="Input baris-ganda"
-Biasanya, ketika kita menaruh sebaris kode ke konsol, dan menekan `key:Enter`, dia akan berjalan.
-
-Untuk menyisipkan lebih dari satu baris, tekan `key:Shift+Enter`. Dengan cara ini kamu bisa mengenter fragment yang panjang dari kode JavaScript.
-```
-
 ## Kesimpulan
 
 - Tools pengembang memungkinkan kita melihat error, menjalankan perintah, memeriksa variabel, dan sebagainya.

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

@@ -62,14 +62,33 @@ Nilai numerik spesial formalnya merupakan bagian dari tipe "number". Tentu saja
 
 Kita akan melihat lebih tentang cara bekerja dengan angka di bab <info:number>.
 
+## BigInt
+
+  Di JavaScript, tipe "number" tidak bisa mewakili nilai integer yang lebih dari <code>2<sup>53</sup></code> (atau kurang dari <code>-2<sup>53</sup></code> untuk negatives), itu batasan teknikal yang disebabkan representasi internal mereka. Itu sekitar 16 digit desimal, jadi untuk banyak tujuan limitasi itu bukan masalah, tapi kadang kita butuh butuh big number yang sangat besar, misanya: cryptography or microsecond-precision timestamps.
+
+`BigInt` type was recently added to the language to represent integers of arbitrary length.
+
+A `BigInt` is created by appending `n` to the end of an integer literal:
+
+```js
+// the "n" at the end means it's a BigInt
+const bigInt = 1234567890123456789012345678901234567890n;
+```
+
+As `BigInt` numbers are rarely needed, we devoted them a separate chapter <info:bigint>.
+
+```smart header="Compatability issues"
+Right now `BigInt` is supported in Firefox and Chrome, but not in Safari/IE/Edge.
+```
+
 ## String
 
 String di JavaScript harus dikelilingi petik.
 
 ```js
 let str = "Hello";
 let str2 = 'Single quotes are ok too';
-let phrase = `can embed ${str}`;
+let phrase = `can embed another ${str}`;
 ```
 
 Di JavaScript, ada 3 tipe petik.
@@ -198,6 +217,8 @@ typeof undefined // "undefined"
 
 typeof 0 // "number"
 
+typeof 10n // "bigint"
+
 typeof true // "boolean"
 
 typeof "foo" // "string"
@@ -223,12 +244,12 @@ Tiga baris terakhir mungkin butuh penjelasan tambahan:
 2. Hasil `typeof null` yaitu `"object"`. Itu salah. Ia merupakan error yang terkenal resmi dalam `typeof`, yang dijaga untuk kompatibilitas. Tentu saja, `null` bukanlah objek. Ia merupakan nilai spesial dengan tipe terpisah miliknya sendiri. Jadi, lagi, ini merupakan error dalam bahasa.
 3. Hasil dari `typeof alert` yaitu `"function"`, karena `alert` merupakan fungsi. Kita akan belajar fungsi di bab berikutnya di mana kita juga akan melihat bahwa tak ada tipe "fungsi" spesial di JavaScript. Fungsi merupakan bagian dari tipe objek. Tapi `typeof` memperlakukan mereka secara berbeda, yang mengembalikan `"fungsi"`. Itu tak sepenuhnya benar, tapi sangat nyaman pada praktiknya.
 
-
 ## Kesimpulan
 
 Ada 7 tipe data dasar dalam JavaScript.
 
 - `number` untuk angka jenis manapun: integer atau floating-point.
+- `bigint` untuk angka integer dengan panjang sembarang.
 - `string` untuk string. String mungkin punya satu atau lebih karakter, tak ada tipe katakter tunggal terpisah.
 - `boolean` untuk `true`/`false`.
 - `null` untuk nilai tak-diketahui -- tipe mandiri yang punya nilai tunggal `null`.

1-js/02-first-steps/06-type-conversions/article.md

@@ -81,18 +81,7 @@ alert( Number(false) );       // 0
 
 Tolong diingat bahwa kelakuan `null` dan `undefined` berbeda di sini: `null` menjadi nol namun `undefined` menjadi `NaN`.
 
-````smart header="Penambahan '+' mengkonkatenasi string"
-Hampir semua operasi matematik mengkonversi nilai ke angka. Pengecualian yang penting ialah penambahan `+`. Jika satu dari nilai yang ditambahkan berupa string, nilai lainnya juga dikonversi ke string.
-
-Maka, ia mengkonkatenasi (menggabungkan) mereka:
-
-```js run
-alert( 1 + '2' ); // '12' (string ke kanan)
-alert( '1' + 2 ); // '12' (string ke kiri)
-```
-
-Ini cuma terjadi ketika setidaknya satu dari argumen yaitu string. Sebaliknya, nilai dikonversi ke angka.
-````
+Hampir semua operasi matematik melakukan konversi semacam ini, yang akan kita lihat di bab berikutnya.
 
 ## Boolean Conversion
 

1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md renamed to 1-js/02-first-steps/07-operators/3-primitive-conversions-questions/solution.md

@@ -13,7 +13,7 @@ null === +"\n0\n" → false
 Beberapa alasan:
 
 1. Sudah jelas, true.
-2. Pembandingan kamus, jadi false.
+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.

1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md renamed to 1-js/02-first-steps/07-operators/3-primitive-conversions-questions/task.md

@@ -355,7 +355,7 @@ Itu juga untuk keterbacaan yang lebih baik, karena lebih mudah melihat `function
 ...Tapi jika Deklarasi Fungsi tak cocok untuk beberapa alasan, atau kita butuh deklarasi kondisional (kita sudah lihat contohnya), maka Expresi Fungsi sebaiknya digunakan.
 ```
 
-## Summary
+## Kesimpulan
 
 - Fungsi adalah nilai. Mereka bisa diset, dikopi atau dideklarasi di kode manapun.
 - Jika fungsi dideklarasi sebagai pernyataan terpisah di aliran kode utama, ia disebut "Deklarasi Fungsi".

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

@@ -22,6 +22,17 @@ The value of `this` is one for the whole function, code blocks and object litera
 
 So `ref: this` actually takes current `this` of the function.
 
+We can rewrite the function and return the same `this` with `undefined` value: 
+
+```js run
+function makeUser(){
+  return this; // this time there's no object literal
+}
+
+alert( makeUser().name ); // Error: Cannot read property 'name' of undefined
+```
+As you can see the result of `alert( makeUser().name )` is the same as the result of `alert( user.ref.name )` from the previous example.
+
 Here's the opposite case:
 
 ```js run

1-js/02-first-steps/15-function-expressions/article.md

@@ -1,8 +1,12 @@
 # Numbers
 
-All numbers in JavaScript are stored in 64-bit format [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), also known as "double precision floating point numbers".
+In modern JavaScript, there are two types of numbers:
 
-Let's expand upon what we currently know about them.
+1. Regular numbers in JavaScript are stored in 64-bit format [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), also known as "double precision floating point numbers". These are numbers that we're using most of the time, and we'll talk about them in this chapter.
+
+2. BigInt numbers, to represent integers of arbitrary length. They are sometimes needed, because a regular number can't exceed <code>2<sup>53</sup></code> or be less than <code>-2<sup>53</sup></code>. As bigints are used in few special areas, we devote them a special chapter <info:bigint>.
+
+So here we'll talk about regular numbers. Let's expand our knowledge of them.
 
 ## More ways to write a number
 
@@ -29,14 +33,13 @@ In other words, `"e"` multiplies the number by `1` with the given zeroes count.
 1.23e6 = 1.23 * 1000000
 ```
 
-
 Now let's write something very small. Say, 1 microsecond (one millionth of a second):
 
 ```js
 let ms = 0.000001;
 ```
 
-Just like before, using `"e"` can help. If we'd like to avoid writing the zeroes explicitly, we could say:
+Just like before, using `"e"` can help. If we'd like to avoid writing the zeroes explicitly, we could say the same as:
 
 ```js
 let ms = 1e-6; // six zeroes to the left from 1
@@ -271,13 +274,11 @@ JavaScript doesn't trigger an error in such events. It does its best to fit the
 ```smart header="Two zeroes"
 Another funny consequence of the internal representation of numbers is the existence of two zeroes: `0` and `-0`.
 
-That's because a sign is represented by a single bit, so every number can be positive or negative, including a zero.
+That's because a sign is represented by a single bit, so it can be set or not set for any number including a zero.
 
 In most cases the distinction is unnoticeable, because operators are suited to treat them as the same.
 ```
 
-
-
 ## Tests: isFinite and isNaN
 
 Remember these two special numeric values?
@@ -409,10 +410,10 @@ There are more functions and constants in `Math` object, including trigonometry,
 
 ## Summary
 
-To write big numbers:
+To write numbers with many zeroes:
 
-- Append `"e"` with the zeroes count to the number. Like: `123e6` is `123` with 6 zeroes.
-- A negative number after `"e"` causes the number to be divided by 1 with given zeroes. That's for one-millionth or such.
+- Append `"e"` with the zeroes count to the number. Like: `123e6` is the same as `123` with 6 zeroes `123000000`.
+- A negative number after `"e"` causes the number to be divided by 1 with given zeroes. E.g. `123e-6` means `0.000123` (`123` millionth).
 
 For different numeral systems: