JavaScript Dasar: Tipe Data dan Operator `typeof`

JavaScript adalah bahasa dinamis `dynamic language` dengan tipe data yang dinamis `dynamic types`. Sebuah variabel dapat digunakan untuk menampung tipe data yang berbeda. 

let x = "Hello"; // `x` adalah string

x = 456 // sekarang `x` adalah number

x = {} // sekarang `x` adalah object

JavaScript akan menentukan tipe data secara otomatis saat inisialisasi atau penugasan variabel. 

Tipe Data dalam JavaScript

Terdapat delapan tipe data dalam JavaScript: 

Tipe Data	Deskripsi
String	Merepresentasikan karakter dan teks.
Number	Merepresentasikan angka, baik bilangan bulat maupun desimal.
BigInt	Merepresentasikan bilangan bulat (`interger`) yang sangat besar.
Boolean	Nilai kebenaran: `true` atau `false`.
Null	Tidak memiliki nilai, kosong, tidak ada apa-apa.
Undefined	Variabel belum terdefinisi. Nilai belum diberikan.
Object	Merepresentasikan objek dengan properti dan nilai.
Symbol	Membuat identifier `unik` untuk objek.

Semua tipe data selain `Object` adalah tipe data `primitive`. Object adalah tipe data `non-primitive`. 

Tipe data `primitive` adalah tipe data yang hanya dapat menyimpan nilai tunggal. Sedangkan `non-primitive` dapat menyimpan kumpulan data. 

String

Tipe data `string` digunakan untuk menyimpan sebuah karakter atau lebih yang membentuk teks. Karakter tersebut dapat berupa apapun, termasuk angka atau number. 

String harus dibungkus dengan tanda kutip `quote`. 

• Single quote: 'Halo'
• Double quotes: "Halo"
• Backticks: `Halo`

Tidak ada perbedaan dalam kutip tunggal maupun ganda, keduanya sama dalam JavaScript. Namun ini memungkinkan kita untuk menggunakan tanda petik di dalam data string. 

Jika ingin menggunakan petik tunggal di dalam teks, bungkus `string` dengan petik ganda. 

Contoh: 

let kutipan = "Dia berkata, 'Hidup adalah petualangan!'";

Atau sebaliknya: 

let kutipan = 'Dia berkata, "Hidup adalah petualangan!"';

Backticks atau petik balik memiliki kemampuan yang lebih baik. Ia mengijinkan sebuah `variabel` atau `ekspresi` dimasukkan ke dalam `string` dengan membungkusnya di dalam `${...}`.  

Contoh: 

let nama = "Zend";

// memasukkan variabel

console.log( `${nama} berkata, 'Hidup adalah petualangan!'` ); // Output: Zend berkata, 'Hidup adalah petualangan!'

// memasukkan ekspresi

console.log( `Hasilnya adalah ${1 + 2}` ); // Hasilnya adalah 3

JavaScript tidak memiliki tipe data `character`. 

Bahasa pemrograman lain seperti C dan Java memiliki tipe data karakter yaitu `char`. 

Namun JavaScript hanya memiliki tipe data `string` yang dapat berisi nol karakter (string kosong), satu karakter, atau banyak karakter.  

Kita akan mempelajari lebih detail tipe data `string` dan berbagai `method` yang ada di dalamnya di artikel lain. 

Number

Tipe data `number` mewakili bilangan bulat `interger` dan bilangan desimal `floating point`. Namun sebenarnya, tidak ada `interger` dalam JavaScript, yang ada hanya `floating point` yang dianggap sebagai interger. 

JavaScript mendukung operasi matematika tipe data `number` dengan berbagai `operator` seperti perkalian (*), pengurangan (-), penjumlahan (+), pembagian (/). Kita akan membahasnya di artikel terpisah. 

Di dalam tipe data `number`, terdapat dua nilai khusus yaitu `Infinity` dan `NaN` untuk menangani beberapa situsi. 

• `Infinity` adalah bilangan tanpa batas, tak terhingga `∞`. Ia mewakili bilangan yang tidak bisa direpresentasikan oleh JavaScript.
  
  Infinity juga bisa dihasilkan dari pembagian bilangan dengan nol, contoh `(1 / 0)`.
  
  Contoh Infinity number: 
  
  
  console.log(1 / 0); // Output: Infinity

  console.log(-1 / 0); // Output: -Infinity

  console.log(1.5 / 0); // Output: Infinity
  
  
• `NaN` atau `Not a Number` menunjukkan adanya kesalahan perhitungan. Ia adalah hasil dari operasi matematika yang salah. 
  
  Ketika terjadi situasi di mana operasi matematika tidak valid atau tidak memiliki hasil numerik yang benar, JavaScript mengembalikan `NaN` sebagai hasilnya. 
  
  Contohnya ketika melakukan operasi string dengan number: 
  
  
  console.log( "satu" * 2) // Output: NaN
  
  Atau mengkonversi string yang tidak valid ke number: 
  
  
  console.log( Number("123ABC")) // Output: NaN
  
  Fungsi `Number()` digunakan untuk mengkonversi tipe data lain ke number. String `123ABC` tidak dapat diubah ke number karena mengandung karakter huruf. 
  
  Selain itu, bisa juga karena operasi yang tidak valid: 
  
  
  console.log(Math.sqrt(-1)) // Output: NaN
  
  `Math.sqrt()` digunakan untuk menghitung akar kuadrat. Tetapi hanya valid jika argumen atau inputnya berupa nol atau bilangan positif. Bilangan negatif akan menghasilkan `NaN`. 
  
  
  Perlu diingat, bilangan berapapun yang dioperasi dengan `NaN` akan menghasilkan `NaN`. 
  
  Tetapi ada pengecualian, `NaN ** 0` (NaN pangkat nol) sama dengan `1`. 
  
  
  

Menjumlahkan number dengan string akan mengubah number menjadi string dan menggabungkannya. 

Contoh: 

console.log( "Satu" + 2) // Output: Satu2

JavaScript menganggap (+) sebagai operator `string concatenation` atau penggabungan string.  

BigInt

Tipe data `number` dapat merepresentasikan interger dengan aman yang terbatas pada rentang  -9007199254740991 hingga 9007199254740991. 

Ini adalah nilai yang dihasilkan dari:

console.log(Number.MAX_SAFE_INTEGER); // Output: 9007199254740991

console.log(Number.MIN_SAFE_INTEGER); // Output: -9007199254740991

Nilai yang diluar rentang itu akan menjadi tidak akurat atau hanya berupa nilai perkiraan. Ketidakakuratan ini disebabkan karena penyimpanan 64-bit pada setiap data number. 

Sebagai contoh, saat menambahkan 1 atau 2 ke angka yang berada tepat di atas rentang aman, hasilnya tidak akurat:

console.log(9007199254740991 + 1); // Output: 9007199254740992

console.log(9007199254740991 + 2); // Output: 9007199254740992 (Seharusnya 9007199254740993) 

Meskipun rentang interger tersebut sudah cukup besar, ada kasus di mana kita perlu bekerja dengan rentang integer yang jauh lebih besar, seperti dalam kriptografi atau penanda waktu dengan presisi mikrodetik.

Nilai `BigInt` dibuat dengan menambahkan `n` di akhir bilangan integer:

// "n" di akhir menandakan itu adalah BigInt

const bigInt = 1234567890123456789012345678901234567890n;

Atau dengan `BigInt()`: 

BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n

Boolean

Boolean adalah tipe data yang menunjukkan kebenaran atau ketidakbenaran suatu kondisi. Boolean hanya dapat berupa dua nilai: `true` yang berarti "benar" atau "ya", dan `false` yang berarti "salah" atau "tidak". 

 Boolean dapat dihasilkan dari perbandingan atau `comparisons`: 

console.log(10 > 5) // Output: true

Pernyataan perbandingan `10 lebih besar dari 5` adalah benar, maka hasilnya `true`. 

Nilai Boolean juga dapat diassign (diberikan) secara eksplisit ke variabel: 

const isTrue = true;

Boolean banyak digunakan dalam percabangan atau atau pernyataan kondisional (`conditional statements`). Kita akan membahas lebih detail tentang `Boolean` dan `conditional statements` di artikel lain. 

`null`

Nilai `null` berarti `kosong`, `tidak ada`, `tidak diketahui`. Ia dihasilkan ketika merujuk pada sebuah objek, tetapi objek tersebut tidak ada, sehingga menghasilkan `null`. 

Contohnya dalam `Document Object Model` (DOM): 

const menu = document.getElementById("menu")

console.log(menu) // dapat berisi `null` jika objek dengan id `menu` tidak ditemukan.

Nilai `null` juga dapat diberikan secara langsung pada variabel: 

const kosong = null;

`undefined` 

 Nilai `undefined` memiliki arti `belum terdefinisi`. Ia dihasilkan dari sebuah variabel yang belum terdefinisi. 

Terdefinisi artinya sudah dideklarasi dan diberi nilai dengan inisialisasi atau assignment. 

let x = 5; // Terdefinisi

let y; // Undefined - belum terdefinisi

y = 10; // Terdefinisi

Bisa juga diberikan secara langsung ke variabel: 

let z = undefined;

Sebuah fungsi yang tidak mengembalikan nilai dengan `return` akan menghasilkan `undefined`. 

function getData() {

    // Tidak ada pernyataan `return`

}

 

const result = getData();

console.log(result); // Output: undefined

`undefined` tidak sama dengan `null`

`undefined` belum terdefinisi, sedangkan `null` sudah terdefinisi tetapi nilainya kosong, tidak ada. 

Object

Objek adalah tipe data `non-primitif`, yaitu tipe data yang dapat menyimpan banyak nilai dengan berbagai tipe data. 

Objek dibuat dengan kurung kurawal `{ }`. Objek memiliki properti dan nilai yang ditulis dengan format `properti : nilai`. Masing-masing properti dipisahkan dengan koma. 

Properti dalam objek berupa `string`, ia juga disebut dengan `object keys`. Dan nilai atau value dari properti dapat berupa tipe data apapun, termasuk objek yang lain. 

Contoh: 

const article = {

    title : "JavaScript Dasar: Tipe Data",

    author: "Kurnia"

}

// `article` adalah objek

// `title` dan `author` adalah properti dari `article`

Objek juga dapat berisi fungsi. Fungsi di dalam objek kita sebut `method`. 

const motor = {

    merek: "Harley Davidson",

    harga: 250000000,

    startEngine: function(){

        console.log("Mesin hidup!")

    }

}

motor.startEngine() // Output: Mesin hidup!

`Array Object`

JavaScript tidak memiliki tipe data `array`, melainkan sebuah objek `Array`. 

Sama seperti bahasa pemrograman lain, array digunakan untuk menyimpan sekumpulan data dengan berbagai tipe dalam sebuah variabel. 

const array = ["String", 123, true, false, {properti: "Nilai"}];

console.log(array);

// Output:

//          0: "String" (string)

//          1: 123      (number)

//          2: true     (boolean)

//          3: false    (boolean)

//          4: properti: "nilai" (objek)

Karena `array` adalah objek, maka array juga dapat berisi objek atau array yang lain. 

Sebuah variabel array yang berisi array yang lain disebut `multidimensional array`. 

const arrayDuaDimensi = [

//   0  1  2  3

    [1, 2, 3, 4], // 0

    [5, 6, 7, 8]  // 1

]

console.log(arrayDuaDimensi[0][0]) // Output: 1

const arrayTigaDimensi = [

    [

    //    0    1    2

        ['d', 'e', 'f'] // 0

    ] // 0

]

console.log(arrayTigaDimensi[0][0][0]) // Output: d

`multidimensional array` adalah topik advance. Jika kamu belum memahaminya sekarang, tidak apa. Cukup menjadi pengetahuan saja. 

Kamu akan mempelajarinya setelah menyelesaikan JavaScript Dasar. 

Symbol

Symbol diperkenalkan pada JavaScript ES6. Symbol adalah tipe data primitif dan immutable (tidak dapat diubah) yang digunakan untuk membuat nama properti objek yang unik. 

Symbol memastikan setiap properti objek unik atau berbeda dengan yang lain sehingga tidak ada konflik nama properti. 

Sintaks: `Symbol("Description")` 

Symbol "selalu unik" meskipun deskripsinya sama. 

const id1 = Symbol('deskripsi');

const id2 = Symbol('deskripsi');

console.log(id1 === id2); // false

Deskripsi tidak mempengaruhi Symbol, ia hanya sebagai informasi untuk symbol tersebut. 

Kita dapat mengakses deskripsi symbol dengan:

`id1.description // Output: deskripsi`

Operator ` typeof `

`typeof ` adalah sebuah `unary operator` yang melakukan operasi hanya pada satu nilai yang disebut `operand`. 

Sintak: `typeof operand`

Operator `typeof` digunakan untuk mengecek tipe data dari suatu nilai atau ekspresi. Operator ini mengembalikan `string` yang mewakili tipe data dari nilai yang diberikan. 

const array = [];

typeof array; // Output: "object"

Dalam contoh di atas, variabel `array` adalah operand atau nilai yang dioperasi. 

Kita coba mengecek ekspresi (tanpa dimasukkan ke variabel) : 

typeof 12; // Output: "number"

typeof "Halo"; // Output: "string"

typeof true; // Output: "boolean"

typeof (1 > 2); // Output: "boolean"

typeof {}; // Output: "object"

typeof []; // Output: "object"

typeof null; // Output: "object"

typeof undefined; // Output: "undefined"

typeof Symbol() // Output: "symbol" 

typeof 1n; // Output: "bigint"

`typeof null` menghasilkan `object` karena kesalahan implementasi. Pada implementasi awal JavaScript, nilai-nilai JavaScript direpresentasikan sebagai tanda tipe dan nilai. 

Tipe data untuk objek ditandai dengan angka `0`. Sedangkan `null` direpresentasikan sebagai pointer NULL (0x00 pada sebagian besar platform). 

Oleh karena itu, `null` memiliki tipe data dengan tanda `0`, dan inilah sebabnya mengapa hasil `typeof` mengembalikan nilai "object". (Lihat Sumber Referensi)

Meskipun demikian, `null` bukanlah objek. 

Jika ingin mengecek apakah sebuah nilai adalah null, gunakan strict equality (===) daripada hanya mengandalkan `typeof`. 

const nilai = null;

console.log(nilai === null) // True