chore(i18n): 1.02.05 done

Author: thickkoezz

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

@@ -12,57 +12,57 @@ Bahasa pemrograman yang memperbolehkan hal semacam ini dibsebut "dynamically typ
 
 Ada tujuh tipe data dasar di JavaScript. Di sini, kita akan mengcover mereka secara umum dan di bab berikutnya kita akan berbicara tentang setiap dari mereka secara detil.
 
-## Angka
+## Number
 
 ```js
 let n = 123;
 n = 12.345;
 ```
 
-Tipe *angka* merepresentasikan baik angka integer maupun floating point.
+Tipe *number* merepresentasikan angka baik integer maupun floating point.
 
 Ada banyak operasi untuk angka, misal perkalian `*`, pembagian `/`, penambahan `+`, pengurangan `-`, dan lainnya.
 
-Besides regular numbers, there are so-called "special numeric values" which also belong to this data type: `Infinity`, `-Infinity` and `NaN`.
+Selain angka reguler, ada yang disebut "nilai numerik spesial" yang juga bagian dari tipe data ini: `Infinity`, `-Infinity` dan `NaN`.
 
-- `Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. It is a special value that's greater than any number.
+- `Infinity` mewakili [Infinity](https://en.wikipedia.org/wiki/Infinity) matematis ∞. Ia merupakan nilai spesial yang lebih besar dari angka apapun.
 
-    We can get it as a result of division by zero:
+    Kita bisa mendapatkannya sebagai hasil dari pembagian oleh nol:
 
     ```js run
     alert( 1 / 0 ); // Infinity
     ```
 
-    Or just reference it directly:
+    Atau langsung referensikan saja dia:
 
     ```js run
     alert( Infinity ); // Infinity
     ```
-- `NaN` represents a computational error. It is a result of an incorrect or an undefined mathematical operation, for instance:
+- `NaN` mewakili error komputasional. Ia merupakan hasil operasi matematis yang salah atau tak-terdefinisi, misalnya:
 
     ```js run
-    alert( "not a number" / 2 ); // NaN, such division is erroneous
+    alert( "not a number" / 2 ); // NaN, pembagian macam ini keliru
     ```
 
-    `NaN` is sticky. Any further operation on `NaN` returns `NaN`:
+    `NaN` itu lengket. Operasi lanjutan apapun pada `NaN` menghasilkan `NaN`:
 
     ```js run
     alert( "not a number" / 2 + 5 ); // NaN
     ```
 
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result.
+    Jadi, jika ada `NaN` di manapun di expresi matematika, ia mempropagasi hasil keseluruhan.
 
-```smart header="Mathematical operations are safe"
-Doing maths is "safe" in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
+```smart header="Operasi matematika itu aman"
+Melakukan matematika itu "aman" dalam JavaScript. Kita bisa melakukan apapun: pembagian dengan nol, memperlakukan string non-numerik sebagai angka, dll.
 
-The script will never stop with a fatal error ("die"). At worst, we'll get `NaN` as the result.
+Script ini takkan pernah stop dengan fatal error ("die"). Paling buruk, kita akan mendapat `NaN` sebagai hasilnya.
 ```
 
-Special numeric values formally belong to the "number" type. Of course they are not numbers in the common sense of this word.
+Nilai numerik spesial formalnya merupakan bagian dari tipe "number". Tentu saja mereka bukan angka dalam pandangan umum dari kata ini.
 
-We'll see more about working with numbers in the chapter <info:number>.
+Kita akan melihat lebih tentang cara bekerja dengan angka di bab <info:number>.
 
-## A string
+## String
 
 String di JavaScript harus dikelilingi petik.
 
@@ -78,89 +78,89 @@ Di JavaScript, ada 3 tipe petik.
 2. Petik tunggal: `'Hello'`.
 3. Backtick: <code>&#96;Hello&#96;</code>.
 
-Double and single quotes are "simple" quotes. There's no difference between them in JavaScript.
+Petik tunggal dan ganda merupakan petik "simpel". Tak ada perbedaan antara mereka di JavaScript.
 
-Backticks are "extended functionality" quotes. They allow us to embed variables and expressions into a string by wrapping them in `${…}`, for example:
+Backtick merupakan petik "fungsional lanjutan". Mereka memungkinkan kita mengembed variabel dan expresi ke dalam string dengan membungkus mereka dalam `${…}`, misalnya:
 
 ```js run
 let name = "John";
 
-// embed a variable
+// mengembed satu variabel
 alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
 
-// embed an expression
-alert( `the result is *!*${1 + 2}*/!*` ); // the result is 3
+// mengembed expresi
+alert( `the result is *!*${1 + 2}*/!*` ); // hasilnya 3
 ```
 
-The expression inside `${…}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
+Expresi di dalam `${…}` dievaluasi dan hasilnya menjadi bagian dari string. Kita bisa menaruh apapun di sana: variabel seperti `name` atau expresi aritmatika seperti `1 + 2` atau sesuatu yang lebih rumit.
 
-Please note that this can only be done in backticks. Other quotes don't have this embedding functionality!
+Tolong diingat bahwa ini hanya bisa dilakukan dalam backtick. Petik lain tidak punya fungsionalitas pengembedan!
 ```js run
-alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)
+alert( "the result is ${1 + 2}" ); // hasilnya ${1 + 2} (petik ganda tak akan berpengaruh)
 ```
 
-We'll cover strings more thoroughly in the chapter <info:string>.
+Kita akan mengcover string lebih dalam di bab <info:string>.
 
-```smart header="There is no *character* type."
-In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is `char`.
+```smart header="Tidak ada tipe *character*."
+Dalam beberapa bahasa, ada tipe "character" spesial untuk karakter tunggal. Misalnya, di bahasa C dan di Java adalah `char`.
 
-In JavaScript, there is no such type. There's only one type: `string`. A string may consist of only one character or many of them.
+Di JavaScript, tak ada tipe semacam itu. Cuma ada satu tipe: `string`. String bisa berisi satu karakter atau lebih.
 ```
 
-## A boolean (logical type)
+## Boolean (tipe logika)
 
-The boolean type has only two values: `true` and `false`.
+Tipe boolean cuma punya dua nilai: `true` dan `false`.
 
-This type is commonly used to store yes/no values: `true` means "yes, correct", and `false` means "no, incorrect".
+Tipe ini umumnya digunakan untuk menyimpan niai ya/tidak: `true` artinya "ya, betul", dan `false` artinya "tidak, salah".
 
-For instance:
+Misalnya:
 
 ```js
-let nameFieldChecked = true; // yes, name field is checked
-let ageFieldChecked = false; // no, age field is not checked
+let nameFieldChecked = true; // ya, field nama dicek
+let ageFieldChecked = false; // tidak, field usia tak dicek
 ```
 
-Boolean values also come as a result of comparisons:
+Nilai boolean juga datang dari perbandingan:
 
 ```js run
 let isGreater = 4 > 1;
 
-alert( isGreater ); // true (the comparison result is "yes")
+alert( isGreater ); // benar (hasil perbandingan yaitu "ya")
 ```
 
-We'll cover booleans more deeply in the chapter <info:logical-operators>.
+Kita akan mengcover boolean lebih dalam di bab <info:logical-operators>.
 
-## The "null" value
+## Nilai "null"
 
-The special `null` value does not belong to any of the types described above.
+Nilai `null` spesial bukan bagian dari tipe apapun yang dijelaskan di atas.
 
-It forms a separate type of its own which contains only the `null` value:
+Ia membentuk tipe terpisah miliknya sendiri yang cuma berisi nilai `null`:
 
 ```js
 let age = null;
 ```
 
-In JavaScript, `null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
+Di JavaScript, `null` tidak "mereferensi ke objek yang tak ada" atau "null pointer" seperti beberapa bahasa lain.
 
-It's just a special value which represents "nothing", "empty" or "value unknown".
+Ia cuma nilai spesial yang mewakili "hampa", "kosong" atau "nilai tak-diketahui".
 
-The code above states that `age` is unknown or empty for some reason.
+Kode di atas menyatakan bahwa `age` tak diketahui atau kosong untuk beberapa alasan.
 
-## The "undefined" value
+## Nilai "undefined"
 
-The special value `undefined` also stands apart. It makes a type of its own, just like `null`.
+Nilai spesial `undefined` juga berbeda lagi. Ia punya tipe miliknya sendiri, sama seperti `null`.
 
-The meaning of `undefined` is "value is not assigned".
+Arti `undefined` ialah "nilai yang tak diassign".
 
-If a variable is declared, but not assigned, then its value is `undefined`:
+Jika variabel dideklarasi, namun tak diassign, maka nilainya `undefined`:
 
 ```js run
 let x;
 
-alert(x); // shows "undefined"
+alert(x); // menampilkan "undefined"
 ```
 
-Technically, it is possible to assign `undefined` to any variable:
+Secara teknis, mungkin saja mengassign `undefined` ke variabel apapun:
 
 ```js run
 let x = 123;
@@ -170,28 +170,28 @@ x = undefined;
 alert(x); // "undefined"
 ```
 
-...But we don't recommend doing that. Normally, we use `null` to assign an "empty" or "unknown" value to a variable, and we use `undefined` for checks like seeing if a variable has been assigned.
+...Tapi kita tidak menyarankan itu. Normalnya, kita gunakan `null` untuk mengassign nilai "kosong" atau "tak-diketahui" ke variabel, dan kita gunakan `undefined` untuk pengecekan seperti melihat apakah variabel telah diassign.
 
-## Objects and Symbols
+## Objek dan Simbol
 
-The `object` type is special.
+Tipe `object` itu special.
 
-All other types are called "primitive" because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities. We'll deal with them later in the chapter <info:object> after we learn more about primitives.
+Semua tipe lain disebut "primitive" karena nilainya bisa mengandung sesuatu yang tunggal (bisa jadi string atau angka atau apapun). Sebaliknya, objek digunakan untuk menyimpan koleksi data dan entitas lebih rumit. Kita akan berhadapan dengannya nanti di bab <info:object> setelah kita belajar tentang primitive.
 
-The `symbol` type is used to create unique identifiers for objects. We have to mention it here for completeness, but it's better to study this type after objects.
+Tipe `symbol` digunakan untuk membuat identifier unik untuk objek. Kita harus menyebutkannya demi kelengkapan, tapi lebih baik untuk belajar tipe ini setelah objek.
 
-## The typeof operator [#type-typeof]
+## Operator typeof [#type-typeof]
 
-The `typeof` operator returns the type of the argument. It's useful when we want to process values of different types differently or just want to do a quick check.
+Operator `typeof` mengembalikan tipe argumen. Berguna ketika kita ingin memproses nilai dari tipe berbeda secara berbeda atau cuma ingin mengecek sekilas.
 
-It supports two forms of syntax:
+Ia mendukung dua bentuk syntax:
 
-1. As an operator: `typeof x`.
-2. As a function: `typeof(x)`.
+1. Sebagai operator: `typeof x`.
+2. Sebagai fungsi: `typeof(x)`.
 
-In other words, it works with parentheses or without them. The result is the same.
+Dengan kata lain, ia berjalan dengan atau tanpa kurung. Hasilnya sama saja.
 
-The call to `typeof x` returns a string with the type name:
+Panggilan ke `typeof x` mengembalikan string dengan nama tipenya:
 
 ```js
 typeof undefined // "undefined"
@@ -217,29 +217,29 @@ typeof alert // "function"  (3)
 */!*
 ```
 
-The last three lines may need additional explanation:
+Tiga baris terakhir mungkin butuh penjelasan tambahan:
 
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
-2. The result of `typeof null` is `"object"`. That's wrong. It is an officially recognized error in `typeof`, kept for compatibility. Of course, `null` is not an object. It is a special value with a separate type of its own. So, again, this is an error in the language.
-3. The result of `typeof alert` is `"function"`, because `alert` is a function of the language. We'll study functions in the next chapters where we'll see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently. Formally, it's incorrect, but very convenient in practice.
+1. `Math` ialah objek built-in yang menyediakan operasi matematik. Kita akan belajar itu di bab <info:number>. Di sini, itu cuma sekedar contoh dari objek.
+2. Hasil `typeof null` yaitu `"object"`. Itu salah. Ini 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 dari bahasa. Kita akan belajar fungsi di bab berikutnya di mana kita akan melihat bahwa tak ada tipe "function" spesial di JavaScript. Fungsi merupakan bagian dari tipe objek. Tapi `typeof` memperlakukan mereka secara berbeda. Formalnya, itu salah, tapi sangat nyaman pada praktiknya.
 
 
-## Summary
+## Kesimpulan
 
-There are 7 basic data types in JavaScript.
+Ada 7 tipe data dasar dalam JavaScript.
 
-- `number` for numbers of any kind: integer or floating-point.
-- `string` for strings. A string may have one or more characters, there's no separate single-character type.
-- `boolean` for `true`/`false`.
-- `null` for unknown values -- a standalone type that has a single value `null`.
-- `undefined` for unassigned values -- a standalone type that has a single value `undefined`.
-- `object` for more complex data structures.
-- `symbol` for unique identifiers.
+- `number` untuk angka jenis manapun: integer atau floating-point.
+- `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`.
+- `undefined` untuk nilai tak-diassign -- tipe mandiri yang punya nilai tunggal `undefined`.
+- `object` untuk struktur data lebih rumit.
+- `symbol` untuk identifier unik.
 
-The `typeof` operator allows us to see which type is stored in a variable.
+Operator `typeof` memungkinkan kita melihat tipe mana yang disimpan dalam variable.
 
-- Two forms: `typeof x` or `typeof(x)`.
-- Returns a string with the name of the type, like `"string"`.
-- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
+- Dua form: `typeof x` atau `typeof(x)`.
+- Mengembalikan string dengan nama tipe, seperti `"string"`.
+- Untuk `null` mengembalikan `"object"` -- ada error dalam bahasa, yang sebenarnya bukan objek.
 
-In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.
+Di bab berikutnya, kita akan fokus pada nilai primitive dan sekali kita familiar dengan mereka, kita akan lanjut ke objek.