JRG 2 · Dasar JRG

Variabel & Tipe

Cara komputer mengingat. Dan satu hal yang membuat banyak orang tersandung di awal: JRG membedakan bilangan bulat dari bilangan berkoma.

dasarMenyimpan nilai dengan nama

Variabel itu seperti kotak berlabel. Kamu taruh nilai di dalamnya, lalu memanggilnya lewat namanya.

variabel.jrg

pub fn main() {
    let nama = "Sari"
    let umur = 17
    wok(nama, "berumur", umur, "tahun")
}

Sari berumur 17 tahun

Tiga kata kunci, dan bedanya nyata

Kata kunci	Bisa diubah?	Dipakai kapan
`let`	Tidak	Nilai yang tidak berubah sepanjang program — ini pilihan bawaan
`let mut` / `var`	Ya	Nilai yang memang harus berubah, misalnya penghitung
`const`	Tidak	Tetapan yang ditulis di luar fungsi, misalnya `PI`

Ini bukan formalitas. Kalau kamu menulis let lalu mencoba mengubahnya, JRG menolak — dan itu menyelamatkanmu dari mengubah sesuatu yang tidak kamu sadari.

ubah.jrg

pub fn main() {
    var skor = 0
    skor = skor + 10
    skor += 5          // sama artinya dengan baris di atas
    wok("Skor:", skor)
}

Skor: 15

let-ditolak.jrg

pub fn main() {
    let skor = 0
    skor = 10
}

error[E0103]: `skor` dideklarasikan dengan `let`, jadi ia tidak bisa ditugasi ulang.
 --> let-ditolak.jrg:3:5
  |
3 |     skor = 10
  |     ^^^^
  |
  = bantuan: pakai `var` atau `let mut` kalau nilainya memang harus berubah
  = catatan: `let` dan `const` mengikat nilainya; `var` dan `:=` tidak

`int` dan `float` itu dua hal berbeda

Angka 7 dan 7.0 terlihat sama nilainya, tapi JRG memperlakukannya berbeda. Yang pertama bilangan bulat (int), yang kedua bilangan berkoma (float).

tipe.jrg

pub fn main() {
    wok(typeof(7), typeof(7.0))
    wok(7.0)             // float selalu tampil dengan koma
    wok(1 + 2.0)         // campur -> hasilnya float
}

int float
7.0
3.0

bagi.jrg

pub fn main() {
    wok(7 / 2)           // int / int -> int
    wok(7.0 / 2.0)       // float / float -> float
    wok(7 as float / 2)  // dipaksa jadi float dulu
}

3
3.5
3.5

Mengubah tipe dengan `as`

as.jrg

pub fn main() {
    let x = 4.9
    wok(x as int)        // dipotong, bukan dibulatkan
    wok(4 as float)
    wok(math::round(x))  // ini baru pembulatan
}

4
4.0
5.0

Anotasi tipe: dokumentasi, bukan penjaga

Kamu boleh menulis tipe di belakang titik dua. JRG memeriksa bahwa nama tipenya ada, tapi tidak memaksa nilainya cocok — JRG bertipe dinamis.

anotasi.jrg

pub fn main() {
    let tinggi: float = 170     // diterima, walau 170 itu int
    wok(tinggi, typeof(tinggi))
}

170 int

anotasi-salah.jrg

pub fn main() {
    let x: Hantu = 5
    wok(x)
}

error[E0103]: tipe `Hantu` tidak ada
 --> anotasi-salah.jrg:2:12
  |
2 |     let x: Hantu = 5
  |            ^^^^^
  |
  = bantuan: deklarasikan `struct Hantu`/`enum Hantu`, atau pakai tipe yang ada
  = catatan: JRG TIDAK menegakkan anotasi tipe — `let x: int = "teks"` diterima — jadi yang diperiksa di sini cuma ADA-tidaknya namanya, bukan cocok-tidaknya nilainya

Kuis 1

Berapa hasil 9 / 2 di JRG?

Tepat. Keduanya int, jadi hasilnya int dan sisanya dibuang.

Ingat: int / int tetap int. Sisanya dibuang, bukan dibulatkan.

Kuis 2

Mana yang menghasilkan 4.5?

Pilihan ketiga membagi dulu (dapat 4), baru diubah — jadi 4.0.

Kuis 3

Kapan sebaiknya pakai var daripada let?

Tepat. Mulai dari let; naikkan ke var hanya ketika perlu.

Kebalikannya — let yang jadi pilihan bawaan.

Latihan mandiri

1. Simpan harga 15000 dan jumlah 3, lalu cetak totalnya.

2. Hitung rata-rata dari 7 dan 8 sehingga hasilnya 7.5, bukan 7.

Jawaban 1: let total = 15000 * 3 lalu wok(total).

Jawaban 2: (7 + 8) as float / 2.0 — kalau ditulis (7+8)/2 hasilnya 7.