Merge branch 'master' into sync-a0bfa924

Author: thickkoezz

1-js/02-first-steps/03-strict-mode/article.md

@@ -73,13 +73,13 @@ Jika tidak, cara paling terpercaya ialah memastikan `use strict` adalah menginpu
 
 ## Selalu "use strict"
 
-Kita belum mengcover perbedaan antara mode strict dan mode "default".
+Kita belum mengcover perbedaan antara mode ketat dan mode "default".
 
-Di bab berikutnya, seiring kira mempelajari fitur bahasa, kita akan mencatat perbedaan antara mode strict dan default. Untungnya, itu tidak banyak dan membuat hidup kita lebih baik.
+Di bab berikutnya, seiring kira mempelajari fitur bahasa, kita akan mencatat perbedaan antara mode ketat dan default. Untungnya, itu tidak banyak dan membuat hidup kita lebih baik.
 
 Untuk sekarang, cukup tahu sampai di sini secara umum:
 
 1. Directive `"use strict"` mengganti engine ke mode "modern", changing the behavior of some built-in features. We'll see the details later in the tutorial.
-2. Mode strict aktif dengan menaruh `"use strict"` paling atas dari script atau function. Beberapa fitur bahasa, seperti "classe" dan "module", mengaktifkan mode strict secara otomatis.
-3. Mode strict didukung semua peramban modern.
-4. Kami sarankan selalu mulai script dengan `"use strict"`. Semua contoh di tutorial ini mengasumsikan mode strict kecuali (sangat jarang) dispesifikasi kebalikannya.
+2. Mode ketat aktif dengan menaruh `"use strict"` paling atas dari script atau function. Beberapa fitur bahasa, seperti "classe" dan "module", mengaktifkan mode ketat secara otomatis.
+3. Mode ketat didukung semua peramban modern.
+4. Kami sarankan selalu mulai script dengan `"use strict"`. Semua contoh di tutorial ini mengasumsikan mode ketat kecuali (sangat jarang) dispesifikasi kebalikannya.

1-js/02-first-steps/04-variables/article.md

@@ -222,7 +222,7 @@ num = 5; // variabel "num" dibuat jika ia tak ada
 alert(num); // 5
 ```
 
-Ini kebiasaan buruk dan akan mengakibatkan galat dalam mode strict:
+Ini kebiasaan buruk dan akan mengakibatkan galat dalam mode ketat:
 
 ```js
 "use strict";

1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md

@@ -4,11 +4,7 @@ Nilai penting: 5
 
 # Tulis ulang 'if' menggunakan '?'
 
-<<<<<<< HEAD
-Tulis ulang `if` menggunakan operator ternary` '?' `:
-=======
-Rewrite this `if` using the conditional operator `'?'`:
->>>>>>> 8c30654f694fe8682f5631809980be931ee4ed72
+Tulis ulang `if` menggunakan operator kondisional `'?'`:
 
 ```js
 let result;

1-js/02-first-steps/10-ifelse/article.md

@@ -6,11 +6,7 @@ Untuk melakukan itu, kita dapat menggunakan pernyataan  `if`  dan operator kondi
 
 ## Pernyataan "if"
 
-<<<<<<< HEAD
-Pernyataan `if` mengevaluasi suatu kondisi, dan jika hasil kondisi itu benar (`true`),maka pernyataan tersebut akan mengeksekusi kode di dalam blok `if` tersebut.
-=======
-The `if(...)` statement evaluates a condition in parentheses and, if the result is `true`, executes a block of code.
->>>>>>> 8c30654f694fe8682f5631809980be931ee4ed72
+Pernyataan `if` mengevaluasi suatu kondisi dan, jika hasil kondisi itu `true`, maka blok kode di dalam `if` akan diexekusi.
 
 Sebagai contoh:
 

1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/solution.md

@@ -1,6 +1,6 @@
-To precisely match the functionality of `switch`, the `if` must use a strict comparison `'==='`.
+Supaya fungsionalitas `switch` persis sama, `if` harus memakai pembandingan ketat `'==='`.
 
-For given strings though, a simple `'=='` works too.
+Tapi untuk string yang diberikan, `'=='` sederhana cukup bekerja juga.
 
 ```js no-beautify
 if(browser == 'Edge') {
@@ -15,6 +15,6 @@ if(browser == 'Edge') {
 }
 ```
 
-Please note: the construct `browser == 'Chrome' || browser == 'Firefox' …` is split into multiple lines for better readability.
+Tolong ingat: konstruksi `browser == 'Chrome' || browser == 'Firefox' …` dipecah menjadi beberapa baris untuk kemudahan keterbacaan.
 
-But the `switch` construct is still cleaner and more descriptive.
+Tapi konstruksi `switch` masih lebih bersih dan lebih deskriptif.

1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/task.md

@@ -1,10 +1,10 @@
-importance: 5
+nilai penting: 5
 
 ---
 
-# Rewrite the "switch" into an "if"
+# Tulis kembali "switch" menjadi "if"
 
-Write the code using `if..else` which would correspond to the following `switch`:
+Tulis kode menggunakan `if..else` yang akan berkorespon dengan `switch` berikut:
 
 ```js
 switch (browser) {

1-js/02-first-steps/13-switch/2-rewrite-if-switch/solution.md

@@ -1,4 +1,4 @@
-The first two checks turn into two `case`. The third check is split into two cases:
+Dua cek pertama berubah ke `case`. Cek ketiga dipecah menjadi dua case:
 
 ```js run
 let a = +prompt('a?', '');
@@ -21,6 +21,6 @@ switch (a) {
 }
 ```
 
-Please note: the `break` at the bottom is not required. But we put it to make the code future-proof.
+Tolong ingat: `break` di paling bawah tidak wajib. Tapi kita taruh itu supaya kodenya future-proof.
 
-In the future, there is a chance that we'd want to add one more `case`, for example `case 4`. And if we forget to add a break before it, at the end of `case 3`, there will be an error. So that's a kind of self-insurance.
+Di masa depan, ada kans bahwa kita ingin menambah `case` lebih, misalnya `case 4`. Dan jika kita lupa menambah break sebelum itu, di akhir `case 3`, akan ada error. Jadi itu lebih ke semacam asuransi diri.

1-js/02-first-steps/13-switch/2-rewrite-if-switch/task.md

@@ -1,10 +1,10 @@
-importance: 4
+nilai penting: 4
 
 ---
 
-# Rewrite "if" into "switch"
+# Tulis kembali "if" ke dalam "switch"
 
-Rewrite the code below using a single `switch` statement:
+Tulis ulang kode berikut menggunakan pernyataan `switch` tunggal:
 
 ```js run
 let a = +prompt('a?', '');

1-js/02-first-steps/13-switch/article.md

@@ -1,14 +1,14 @@
-# The "switch" statement
+# Pernyataan "switch"
 
-A `switch` statement can replace multiple `if` checks.
+Pernyataan `switch` bisa mengganti pengecekan ganda `if`.
 
-It gives a more descriptive way to compare a value with multiple variants.
+Ia memberi cara lebih deskriptif untuk membandingkan nilai dengan varian ganda.
 
-## The syntax
+## Syntax
 
-The `switch` has one or more `case` blocks and an optional default.
+`switch` punya satu atau lebih blok `case` dan satu default opsional.
 
-It looks like this:
+Rupanya seperti ini:
 
 ```js no-beautify
 switch(x) {
@@ -26,13 +26,13 @@ switch(x) {
 }
 ```
 
-- The value of `x` is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on.
-- If the equality is found, `switch` starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of `switch`).
-- If no case is matched then the `default` code is executed (if it exists).
+- Nilai `x` dicek ekaulitasnya secara ketat dengan nilaid dari `case` pertama (yaitu, `value1`) lalu ke kedua (`value2`) dan seterusnya.
+- Jika ekualitas ditemukan, `switch` mulai mengexekusi kode mulai dari `case` yang berkorespondensi, hingga `break` terdekat (atau hingga akhir `switch`).
+- Jika tak ada case yang cocok maka kode `default` diexekusi (jika ada).
 
-## An example
+## Contoh
 
-An example of `switch` (the executed code is highlighted):
+Contoh `switch` (kode yang diexekusi dihighlight):
 
 ```js run
 let a = 2 + 2;
@@ -54,13 +54,13 @@ switch (a) {
 }
 ```
 
-Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails.
+Di sini `switch` mulai membandingkan `a` dari varian `case` pertama yang bernilai `3`. Kecocokan gagal.
 
-Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`.
+Lalu `4`. Ada kecocokan, jadi exekusi mulai dari `case 4` hingga `break` terdekat.
 
-**If there is no `break` then the execution continues with the next `case` without any checks.**
+**Jika tak ada `break` maka exekusi lanjut dengan `case` berikutnya tanpa pengecekan.**
 
-An example without `break`:
+Contoh tanpa `break`:
 
 ```js run
 let a = 2 + 2;
@@ -79,18 +79,18 @@ switch (a) {
 }
 ```
 
-In the example above we'll see sequential execution of three `alert`s:
+Di contoh di atas kita akan lihat exekusi sekuensial dari tiga `alert`:
 
 ```js
 alert( 'Exactly!' );
 alert( 'Too big' );
 alert( "I don't know such values" );
 ```
 
-````smart header="Any expression can be a `switch/case` argument"
-Both `switch` and `case` allow arbitrary expressions.
+````smart header="Expresi apapun bisa berupa argumen `switch/case`"
+Baik `switch` maupun `case` membolehkan sembarang expresi.
 
-For example:
+Misalnya:
 
 ```js run
 let a = "1";
@@ -107,14 +107,14 @@ switch (+a) {
     alert("this doesn't run");
 }
 ```
-Here `+a` gives `1`, that's compared with `b + 1` in `case`, and the corresponding code is executed.
+Di sini `+a` memberikan `1`, yang dibandingkan dengan `b + 1` ndalam `case`, and the corresponding code is executed.
 ````
 
-## Grouping of "case"
+## Pengelompokan "case"
 
-Several variants of `case` which share the same code can be grouped.
+Beberapa varian `case` yang berbagi kode yang sama bisa dikelompokkan.
 
-For example, if we want the same code to run for `case 3` and `case 5`:
+Misalnya, jika kita ingin kode yang sama berjalan untuk `case 3` dan `case 5`:
 
 ```js run no-beautify
 let a = 2 + 2;
@@ -137,15 +137,15 @@ switch (a) {
 }
 ```
 
-Now both `3` and `5` show the same message.
+Sekarang baik `3` maupun `5` menampilkan pesan yang sama.
 
-The ability to "group" cases is a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
+Kemampuan "mengelompokkan" case adalah efek samping dari bagaimana `switch/case` bekerja tanpa `break`. Di sini exekusi dari `case 3` mulai dari baris `(*)` dan tembus ke `case 5`, karena tidak ada `break`.
 
-## Type matters
+## Tipe berpengaruh
 
-Let's emphasize that the equality check is always strict. The values must be of the same type to match.
+Mari kita tekankan bahwa pengecekan ekualitas selalu ketat. Nilainya harus bertipe sama supaya cocok.
 
-For example, let's consider the code:
+Misalnya, mari kita pertimbangkan kode ini:
 
 ```js run
 let arg = prompt("Enter a value?");
@@ -167,6 +167,6 @@ switch (arg) {
 }
 ```
 
-1. For `0`, `1`, the first `alert` runs.
-2. For `2` the second `alert` runs.
-3. But for `3`, the result of the `prompt` is a string `"3"`, which is not strictly equal `===` to the number `3`. So we've got a dead code in `case 3`! The `default` variant will execute.
+1. Untuk `0`, `1`, `alert` pertama berjalan.
+2. Untuk `2` `alert` kedua berjalan.
+3. Tapi untuk `3`, hasil dari `prompt` ialah string `"3"`, yang berbeda secara ketat `===` dengan angka `3`. Jadi kita punya kode mati di `case 3`! Varian `default` akan diexekusi.

1-js/02-first-steps/14-function-basics/1-if-else-required/task.md

@@ -1,4 +1,5 @@
-Kepentingan: 4
+nilai penting: 4
+
 ---
 
 # Apakah "else" dibutuhkan ?