Merge pull request #156 from javascript-tutorial/sync-d6e88647

Sync with upstream @ d6e8864

Author: yoga1234

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

@@ -1,6 +1,10 @@
 # Pengenalan JavaScript
 
+<<<<<<< HEAD
 Mari kita lihat apa yang spesial dari JavaScript, apa saja yang bisa kita buat menggunakan JavaScript, dan teknologi apa yang cocok dengan JavaScript.
+=======
+Let's see what's so special about JavaScript, what we can achieve with it, and what other technologies play well with it.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ## Apa itu JavaScript?
 
@@ -129,6 +133,12 @@ Masih banyak lagi. Tentunya, jika kita menggunakan salah satu bahasa yang ditran
 
 ## Kesimpulan
 
+<<<<<<< HEAD
 - JavaScript awalnya diciptakan sebagai bahasa khusus browser, namun sekarang banyak digunakan di lingkungan lain.
 - Sekarang, JavaScript mempunyai posisi unik sebagai bahasa browser paling banyak diadopsi dengan integrasi penuh dengan HTML/CSS.
 - Ada banyak bahasa yang "ditranspile" ke JavaScript dan menyediakan fitur tertentu. Disarankan untuk mempelajari mereka juga, minimal sebentar, setelah menguasai JavaScript.
+=======
+- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
+- Today, JavaScript has a unique position as the most widely-adopted browser language with full integration in HTML/CSS.
+- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d

1-js/02-first-steps/09-comparison/article.md

@@ -57,7 +57,13 @@ algoritma untuk membandingkan dua string sederhana:
 4. Ulangi sampai string berakhir.
 5. Jika kedua string berakhir pada panjang yang sama, maka mereka sama. Sebaliknya, string lebih panjang yang lebih besar.
 
+<<<<<<< HEAD
 Pada contoh di atas, pembandingan `'Z' > 'A'` menghasilkan pada langkah pertama sedangkan string `"Glow"` dan `"Glee"` dibandingkan karakter-demi-karakter:
+=======
+In the first example above, the comparison `'Z' > 'A'` gets to a result at the first step.
+
+The second comparison `'Glow'` and `'Glee'` needs more steps as strings are compared character-by-character:
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 1. `G` sama dengan `G`.
 2. `l` sama dengan `l`.

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

@@ -11,7 +11,11 @@ Hasil dari `a ?? b` adalah:
 - jika `a` belum didefinisikan, maka `b`.
 
 
+<<<<<<< HEAD
 Dengan kata lain, `??` mengembalikan argumen pertama jika argumen tersebut telah didefinisikan. Sebaliknya, mengembalikan argumen kedua jika argumen pertama belum didefinisikan.
+=======
+In other words, `??` returns the first argument if it's not `null/undefined`. Otherwise, the second one.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 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.
 
@@ -39,7 +43,11 @@ let user = "John";
 alert(user ?? "Anonymous"); // John
 ```
 
+<<<<<<< HEAD
 Kita juga bisa menggunakan rentetan `??` untuk mendapatkan nilai yang telah didefinisikan dari sebuah daftar.
+=======
+We can also use a sequence of `??` to select the first value from a list that isn't `null/undefined`.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 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.
 
@@ -77,11 +85,19 @@ alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
 
 Operator OR `||` sudah ada sejak awal mula dari Javascript, jadi sudah sejak lama pengembang menggunakan operator _or_ untuk kebutuhan seperti contoh diatas.
 
+<<<<<<< HEAD
 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.
+=======
+On the other hand, the nullish coalescing operator `??` was added to JavaScript only recently, and the reason for that was that people weren't quite happy with `||`.
+
+The important difference between them is that:
+- `||` returns the first *truthy* value.
+- `??` returns the first *defined* value.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 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.
 
@@ -97,6 +113,7 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
+<<<<<<< HEAD
 Disini, kita memiliki _height_ nol.
 
 - Bagian `height || 100` memeriksa `height` sebagai nilai yang _falsy_, dan ternyata benar.
@@ -105,6 +122,14 @@ Disini, kita memiliki _height_ nol.
     - jadi hasil dari `height` adalah "sebagaimana adanya", yang mana adalah `0`.
 
 Jika kita asumsikan bahwa _height_ nol adalah nilai yang valid, maka nilainya tidak seharusnya diganti dengan nilai _default_, maka `??` melakukan hal yang benar.
+=======
+- The `height || 100` checks `height` for being a falsy value, and it really is.
+    - so the result is the second argument, `100`.
+- The `height ?? 100` checks `height` for being `null/undefined`, and it's not,
+    - so the result is `height` "as is", that is `0`.
+
+If the zero height is a valid value, that shouldn't be replaced with the default, then `??` does just the right thing.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ## Precedence/Hak lebih tinggi
 
@@ -156,7 +181,11 @@ alert(x); // 2
 
 ## Ringkasan
 
+<<<<<<< HEAD
 - operator penggabung nullish `??` menyediakan cara yang pendek untuk memilih nilai *defined* dari sebuah daftar.
+=======
+- The nullish coalescing operator `??` provides a short way to choose the first "defined" value from a list.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
     It's used to assign default values to variables:
     Operator nullish digunakan untuk memberikan nilai default kepada sebuah variabel:
@@ -166,5 +195,10 @@ alert(x); // 2
     height = height ?? 100;
     ```
 
+<<<<<<< HEAD
 - Operator `??` memiliki nilai *precedence* yang sangat rendah, dan sedikit lebih tinggi dari `?` dan `=`.
 - Dilarang untuk menggunakan operator `??` dengan `\\` atau `&&` tanpa kurung yang jelas.
+=======
+- The operator `??` has a very low precedence, only a bit higher than `?` and `=`, so consider adding parentheses when using it in an expression.
+- It's forbidden to use it with `||` or `&&` without explicit parentheses.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d

1-js/02-first-steps/18-javascript-specials/article.md

@@ -144,7 +144,11 @@ Penetapan
 : Ada penetapan simpel: `a = b` dan penetapan kombinasi seperti `a *= 2`.
 
 Bitwise
+<<<<<<< HEAD
 : Operator bitwise bekerja dengan integer 32-bit di bit-level paling kecil: lihat [docs](mdn:/JavaScript/Reference/Operators/Bitwise_Operators) ketika mereka dibutuhkan.
+=======
+: Bitwise operators work with 32-bit integers at the lowest, bit-level: see the [docs](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise) when they are needed.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 Kondisional
 : Satu-satunya operator dengan tiga parameter: `cond ? resultA : resultB`. Jika `cond` truthy, mengembalikan `resultA`, jika tidak `resultB`.

1-js/04-object-basics/01-object/8-multiply-numeric/task.md

@@ -2,9 +2,15 @@ nilai penting: 3
 
 ---
 
+<<<<<<< HEAD
 # Kalikan properti numerik dengan 2
 
 Buatlah sebuah fungsi `multiplyNumerik(obj)` yang mengkalikan seluruh properti numerik dari `obj` dengan `2`.
+=======
+# Multiply numeric property values by 2
+
+Create a function `multiplyNumeric(obj)` that multiplies all numeric property values of `obj` by `2`.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 Contoh:
 

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

@@ -1,10 +1,22 @@
+<<<<<<< HEAD
 # Menyalin objek, referensi
 
 Salah satu perbedaan dasar dari objek dan tipe primitif adalah untuk menyimpan dan menyalin "dengan referensi/*by reference*".
 
 nilai primitif: string, angka, boolean -- akan disalin "seluruh nilainya".
 
 contoh:
+=======
+# Object references and copying
+
+One of the fundamental differences of objects versus primitives is that objects are stored and copied "by reference", as opposed to primitive values: strings, numbers, booleans, etc -- that are always copied "as a whole value".
+
+That's easy to understand if we look a bit "under a cover" of what happens when we copy a value.
+
+Let's start with a primitive, such as a string.
+
+Here we put a copy of `message` into `phrase`:
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ```js
 let message = "Hello!";
@@ -15,21 +27,43 @@ Sebagai hasilnya kita punya dua variabel yang berdiri sendiri, dan keduanya meny
 
 ![](variable-copy-value.svg)
 
+<<<<<<< HEAD
 Objek tidak seperti itu.
 
 **Sebuah variabel tidak menyimpan objek itu sendiri, akan tetapi "disimpan didalam memori", dengan kata lain "mereferensi" kepadanya (ke data didalam memori).**
 
 Dibawah adalah gambar untuk sebuah objek:
+=======
+Quite an obvious result, right?
+
+Objects are not like that.
+
+**A variable assigned to an object stores not the object itself, but its "address in memory", in other words "a reference" to it.**
+
+Let's look at an example of such variable:
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ```js
 let user = {
   name: "John"
 };
 ```
 
+And here's how it's actually stored in memory:
+
 ![](variable-contains-reference.svg)
 
+<<<<<<< HEAD
 Disini, objek disimpan di suatu tempat didalam memori. Dan variabel `user` punya "referensi" ke data objek yang berada didalam memori itu.
+=======
+The object is stored somewhere in memory (at the right of the picture), while the `user` variable (at the left) has a "reference" to it.
+
+We may think of an object variable, such as `user`, as of a sheet of paper with the address.
+
+When we perform actions with the object, e.g. take a property `user.name`, JavaScript engine looks into that address and performs the operation on the actual object.
+
+Now here's why it's important.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 **Ketika sebuah variabel objek disalin -- referensinya akan tersalin, objeknya tidak terduplikasi.**
 
@@ -45,7 +79,13 @@ Kita sekarang punya dua variabel, masing-masing mereferensi ke objek yang sama:
 
 ![](variable-copy-reference.svg)
 
+<<<<<<< HEAD
 Kita bisa menggunakan variabel apapun untuk mengakses objek dan memodifikasi konten didalamnya:
+=======
+As you can see, there's still one object, now with two variables that reference it.
+
+We can use any variable to access the object and modify its contents:
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ```js run
 let user = { name: 'John' };
@@ -59,6 +99,7 @@ admin.name = 'Pete'; // mengganti admin dengan menggunakan "referensi"
 alert(*!*user.name*/!*); // 'Pete', perubahan akan terlihat pada "user"
 ```
 
+<<<<<<< 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.
 
 ## Perbandingan dengan referensi
@@ -68,6 +109,16 @@ Operator pembanding `==` dan pembanding ketat `===` untuk objek bekerja sama saj
 **Dua objek adalah sama jika mereka objek yang sama.**
 
 Dibawah adalah dua variabel yang mereferensi ke objek yang sama, dengan demikian mereka sama:
+=======
+
+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
+
+Two objects are equal only if they are the same object.
+
+For instance, here `a` and `b` reference the same object, thus they are equal:
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ```js run
 let a = {};
@@ -77,7 +128,11 @@ alert( a == b ); // true, kedua variabel mereferensi ke objek yang sama
 alert( a === b ); // true
 ```
 
+<<<<<<< HEAD
 Dan dibawah adalah dua objek yang berdiri sendiri, tidaklah sama, walaupun keduanya kosong:
+=======
+And here two independent objects are not equal, even though they look alike (both are empty):
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ```js run
 let a = {};
@@ -86,7 +141,11 @@ let b = {}; // dua objek yang berdiri sendiri
 alert( a == b ); // false
 ```
 
+<<<<<<< HEAD
 Untuk perbandingan seperti `obj1 > obj2` atau untuk perbandingan dengan sebuah nilai primitif `obj == 5`, objek akan diubah dahulu menjadi primitif. Kita akan belajar bagaimana perubahan objek sebentar lagi, akan tetapi sebenarnya, perbandingan seperti itu muncul sangat jarang, biasanya hanya sebuah hasil dari kesalahan koding.
+=======
+For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are needed very rarely, usually they appear as a result of a programming mistake.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 ## Penggandaan dan penggabungan, Object.assign
 

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

@@ -32,11 +32,19 @@ user.sayHi = function() {
 user.sayHi(); // Hello!
 ```
 
+<<<<<<< HEAD
 Di sini kita hanya menggunakan sebuah fungsi ekspresi untuk membuat fungsi dan menugaskannya ke properti `user.sayHi` pada objek.
 
 Kemudian kita memanggil fungsi tersebut. Kini "pengguna" bisa berbicara!
 
 Sebuah fungsi yang mana merupakan properti dari sebuah objek disebut sebagai *metode*-nya.
+=======
+Here we've just used a Function Expression to create a function and assign it to the property `user.sayHi` of the object.
+
+Then we can call it as `user.sayHi()`. The user can now speak!
+
+A function that is a property of an object is called its *method*.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 Jadi, di sini kita memiliki sebuah metode `sayHi` dari objek`user`.
 
@@ -160,14 +168,24 @@ let user = {
 let admin = user;
 user = null; // timpa/overwrite agar terlihat lebih jelas
 
+<<<<<<< HEAD
 admin.sayHi(); // Uups! dalam sayHi(), nama yang lama sedang digunakan! error!
+=======
+*!*
+admin.sayHi(); // TypeError: Cannot read property 'name' of null
+*/!*
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 ```
 
 Jika kita menggunakan `this.name` ketimbang `user.name` dalam `alert`, maka kodenya akhirnya berfungsi.
 
 ## "this" tidak ditemukan
 
+<<<<<<< HEAD
 Dalam JavaScript, kata kunci `this` berperilaku tidak seperti kebanyak bahasa pemrograman lainnya. 'this' juga bisa digunakan dalam fungsi apapun.
+=======
+In JavaScript, keyword `this` behaves unlike most other programming languages. It can be used in any function, even if it's not a method of an object.
+>>>>>>> d6e88647b42992f204f57401160ebae92b358c0d
 
 Tidak ada *syntax error* dalam contoh berikut ini: