Kotlin: Var dan Val
Tags: kotlin, android, webdev, programming
Published: 2023-11-15 11:19:39


![Beauty landscape](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/51lctr2812u7d8nm542j.gif)
`Untuk membuka tautan, lebih di sarankan --> klik kanan, lalu pilih buka link di tab baru agar tidak menutup artikel ini.`<br>
Kali ini kita akan belajar terkait `var` dan `val` pada bahasa [kotlin](https://kotlinlang.org/)

Jadi Ketika kita membuat suatu [variabel](https://en.m.wikipedia.org/wiki/Variable_(computer_science)), Kita wajib memutuskan terlebih dahulu apakah suatu [variabel](https://en.m.wikipedia.org/wiki/Variable_(computer_science)) tersebut dapat di-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) ulang atau tidak pada saat melakukan penyimpanan data.

Ketika kita membuat [identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)) variabel untuk merujuk pada elemen di dalam program Kita. Keputusan paling dasar terhadap [identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)) adalah apakah ia dapat mengubah isinya selama eksekusi program atau ia hanya dapat di-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) sekali saja. Hal ini dikontrol oleh dua kata kunci:

- `var`, singkatan dari [variabel](https://en.wikipedia.org/wiki/Variable_(computer_science)), yang berarti Kita dapat mengubah isinya.
- `val`, singkatan dari [value](https://en.m.wikipedia.org/wiki/Value_(computer_science)), yang berarti Kita hanya dapat melakukan [inisialisasi](https://en.m.wikipedia.org/wiki/Initialization_%28programming%29) saja namun variabel tersebut tidak dapat di-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) ulang.

Cara penulisan `var` seperti ini:

```kotlin
var identifier = initialization
```

Kata kunci `var` diikuti dengan [identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)), lalu tanda sama dengan `=`, dan kemudian nilai yg di [inisialisasi](https://en.m.wikipedia.org/wiki/Initialization_%28programming%29). Deklarasi [Identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)) dimulai dengan **huruf** atau **garis bawah**, diikuti oleh **huruf**, **angka**, dan atau **garis bawah**. Huruf **besar** dan **kecil** akan dibedakan di dalam kotlin, hal ini disebut dengan [case-sensitive](https://en.m.wikipedia.org/wiki/Case_sensitivity) (jadi antara `thisvalue` dan `thisValue` adalah dua hal yg berbeda).

Berikut adalah beberapa definisi `var`:

```kotlin
// VarAndVal/Vars.kt

fun main() {

  var whole = 13              // [1]

  var fractional = 1.8        // [2]

  var words = "Kotlin Sangat Cerdas"  // [3]

  println(whole)

  println(fractional)

  println(words)

}
```

**Output:**

```
13

1.8

Kotlin Sangat Cerdas
```

Dalam artikel ini, Kita menandai baris kode dengan nomor yang dikomentari dalam tanda kurung siku, ini ditujukan agar kita dapat merujuk pada urutan contoh-contoh dalam teks seperti ini:

- [1] Buat suatu `var` dengan nama `whole` dan simpan 13 di dalamnya.
- [2] Simpan "angka pecahan" 1.8 dalam `var` dengan nama `fractional`.
- [3] Simpan beberapa teks (String) dalam `var` dengan nama `words`.

Perhatikan: `println()` dapat mengambil **nilai tunggal** apa pun **sebagai argumen**.

Seperti namanya, `var` yg merepresentasikan [variabel](https://en.wikipedia.org/wiki/Variable_(computer_science)), nilainya dapat bervariasi. Artinya, Kita dapat **mengubah data** yang disimpan dalam suatu `var` . Istilah umumnya adalah **mutable**, contoh suatu `var` bersifat mutable:

```kotlin
// VarAndVal/AVarIsMutable.kt

fun main() {

  var sum = 3

  var suml = sum + 9

  sum += 5

  println(suml)

  print(sum)

}
```

**Output:**

```
12
8
```

[Assignment](https://en.wikipedia.org/wiki/Assignment_(computer_science)) `sum = sum + 9` mengambil nilai saat ini dari `sum`, lalu menambahkan sembilan, dan meng-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) hasilnya kembali ke `sum`.

[Assignment](https://en.wikipedia.org/wiki/Assignment_(computer_science)) `sum += 5` berarti sama dengan `sum = sum + 5`. Operator `+=` mengambil nilai sebelumnya yang disimpan dalam `sum` dan menambahkan 5 pada `sum` tersebut, kemudian meng-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) hasil baru tersebut kembali ke `sum`.

Mengubah nilai yang disimpan dalam suatu `var` adalah cara yang berguna untuk menyatakan perubahan. Namun, ketika kompleksitas program meningkat, kode Kita lebih jelas, lebih aman, dan lebih mudah dipahami jika nilai yang direpresentasikan oleh [identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)) Kita tidak dapat berubah—artinya, mereka tidak dapat di-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) ulang. Kita menentukan [identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)) yang tidak berubah menggunakan kata kunci `val` alih-alih menggunakan `var`. Suatu `val` hanya dapat di-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) sekali saja pada saat dibuat:

```kotlin
val identifier = initialization
```

Kata kunci `val` berasal dari kata **value**/**nilai** dalam bahasa indonesia, namun maksud dari `nilai` disini bukan merepresentasikan suatu data yang ditugaskan di dalam variabel, melainkan merujuk kepada **sesuatu** yang tidak dapat berubah/diubah, maka dari itu`val` memiliki sifat [immutable](https://en.m.wikipedia.org/wiki/Immutable_object). Kebanyakan Programmer Kotlin lebih memilih menggunakan `val` daripada `var` bila memungkinkan untuk di deklarasikan di semua situasi (_tergantung kebutuhan, jika kita ingin agar variabel tersebut tidak dapat diubah setelah dilakukan 
Assignment_). Contoh pada `Vars.kt` dapat ditulis ulang menggunakan `val` seperti berikut ini:

```kotlin
// VarAndVal/Vals.kt

fun main() {

  val whole = 13

  // whole = 23 // Error jika kita me-reassign dengan nilai baru di 23  // [1]

  val fractional = 1.3

  val words = "Kotlin Realm"

  println(whole)

  println(fractional)

  println(words)

}
```

**Output:**

```
13

1.3

Kotlin Realm
```

- [1] Setelah Kita meng[inisialisasi](https://en.m.wikipedia.org/wiki/Initialization_%28programming%29) suatu `val`, Kita tidak dapat meng-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) ulangnya. Jika kita mencoba meng-[assign](https://en.wikipedia.org/wiki/Assignment_(computer_science)) ulang `whole` ke angka yang berbeda, Kotlin akan memberikan peringatan error, ia akan memberikan output "Val cannot be reassigned."

Memilih nama yang deskriptif untuk [identifier](https://en.wikipedia.org/wiki/Identifier_(computer_languages)) membuat kode Kita lebih mudah dipahami dan seringkali mengurangi kebutuhan untuk pemberian komentar pada source code. Pada `Vals.kt`, Kita tidak tahu apa yang `whole` wakili. Jika program Kita menyimpan angka 7 untuk mewakili waktu ngeteh, lebih jelas bagi orang lain untuk memahaminya jika Kita menamainya dengan kata `teatime` dan lebih mudah dibaca jika itu ditulis menjadi aeperti ini: `teaTime` (mengikuti gaya penulisan standar Kotlin, Kita membuat huruf pertama menjadi huruf kecil lalu kata kedua dibedakan dengan awalan huruf kapital).

`var` berguna ketika data **harus berubah** saat program berjalan. Ini terdengar seperti kebutuhan umum, tetapi ternyata dapat dihindari dalam praktiknya. Secara umum, program Kita lebih mudah untuk diperluas dan dipelihara jika Kita menggunakan `val`. Namun, dalam keadaan yang jarang terjadi, terlalu kompleks untuk memecahkan masalah hanya menggunakan `val`. Untuk alasan itu, Kotlin memberi Kita fleksibilitas dengan penggunaan keyword `var`. Namun, seiring berjalannya waktu dengan `val`, Kita akan menemukan bahwa Kita hampir tidak pernah membutuhkan `var` dan program Kita lebih aman dan lebih dapat diandalkan tanpanya (sekali lagi ini bersifat tentatif merujuk kepada situasi & kondisi tertentu).

[Sumber - Atomic Kotlin Sample ](https://stepik.org/lesson/103806/step/1)