1. Apa itu Variable?

Sederhananya:

Variable adalah sebuah nama yang kita berikan kepada suatu tempat untuk menyimpan sebuah nilai.

Bayangkan kita punya sebuah kotak.

┌─────────────┐
│     100     │
└─────────────┘
      num

Kotak tersebut kita beri nama num, dan di dalamnya kita simpan 100.

Dalam TypeScript:

let num = 100;

Artinya:

Buat sebuah variable bernama num, kemudian simpan nilai 100 di dalamnya.

Setelah itu kita tidak perlu menulis 100 berkali-kali.

Misalnya:

let num = 100;

console.log(num);
console.log(num);
console.log(num + 50);

Hasilnya:

100
100
150

Jadi daripada menulis:

console.log(100);
console.log(100);
console.log(100 + 50);

kita bisa menggunakan nama:

num

Ini alasan kenapa variable sangat fundamental dalam programming.

2. Membuat Variable di TypeScript

Untuk membuat variable, kita bisa menggunakan:

let

atau

const

Contoh:

let num = 100;

const str = "Hello World";

Di sini kita mempunyai dua variable:

num → 100

str → "Hello World"

Syntax sederhananya:

let namaVariable = nilai;

atau:

const namaVariable = nilai;

Contoh:

let age = 20;
let score = 90;
let name = "Budi";

const country = "Indonesia";

3. Apa Bedanya let dan const?

Ini salah satu konsep paling penting dalam JavaScript maupun TypeScript.

Perbedaan utamanya:

Mari kita bahas satu-satu.

4. let Bisa Dibuat Tanpa Nilai

Kita bisa melakukan:

let num;

Ini valid.

Artinya kita membuat variable num, tetapi belum memberikan nilai.

Kemudian nanti:

num = 100;

Sekarang num memiliki nilai:

num → 100

Jadi let memungkinkan kita membuat variable terlebih dahulu dan mengisinya kemudian.

Contoh:

let score;

score = 80;

console.log(score);

Hasil:

80

5. const Harus Langsung Diberi Nilai

Kalau menggunakan const:

const num;

Ini akan error.

Kenapa?

Karena const harus langsung memiliki nilai ketika dibuat.

Yang benar:

const num = 100;

Jadi jangan:

const name;
name = "Budi";

Tetapi:

const name = "Budi";

Secara sederhana:

let
↓
boleh kosong dulu
↓
nanti diisi

Sedangkan:

const
↓
harus langsung diisi
↓
tidak boleh kosong

6. let Nilainya Bisa Diubah

Misalnya:

let num = 100;

Kemudian:

num = 1000;

Tidak masalah.

Nilainya berubah:

Awalnya:

num → 100


Kemudian:

num → 1000

Contoh:

let score = 50;

score = 80;

console.log(score);

Hasil:

80

Karena let memang digunakan untuk variable yang nilainya mungkin berubah.

Contoh yang masuk akal:

let age = 20;

age = 21;

Umur seseorang bisa berubah.

7. const Nilainya Tidak Bisa Diubah

Sekarang:

const name = "Budi";

Kemudian kita mencoba:

name = "Andi";

TypeScript akan memberikan error.

Karena name dibuat menggunakan const.

Secara konsep:

const name → "Budi"

dan kita tidak boleh melakukan:

name → "Andi"

pada variable tersebut.

Jadi:

const country = "Indonesia";

country = "Japan";

❌ Error.

8. Kapan Menggunakan let dan const?

Cara gampang mengingatnya:

Gunakan let kalau nilainya akan berubah

let score = 10;

score = 20;
score = 30;

Gunakan const kalau nilainya tidak perlu diganti

const country = "Indonesia";
const pi = 3.14;
const appName = "My App";

Prinsip sederhananya:

Kalau tidak perlu mengubah nilai, biasanya gunakan const.

Kalau memang nilainya akan berubah, gunakan let.

9. Hal Penting: TypeScript Bisa Menebak Type Variable

Sekarang kita masuk ke bagian yang sangat penting dalam TypeScript:

Type Inference

Misalnya kita menulis:

let num = 100;

Kita tidak menulis:

let num: number = 100;

Tetapi TypeScript tetap tahu bahwa:

num adalah number

Kenapa?

Karena kita memberikan nilai:

100

dan 100 adalah angka.

Jadi TypeScript menyimpulkan/infer bahwa num bertipe number.

Konsep ini disebut:

Type inference

Materi sumber juga menjelaskan bahwa TypeScript menentukan tipe variable berdasarkan nilai yang diberikan saat initialization.

10. Contoh Type Inference

let age = 20;

TypeScript melihat:

20
↓
number

Maka:

age → number

Contoh lain:

let name = "Budi";

TypeScript melihat:

"Budi"
↓
string

Maka:

name → string

Contoh:

let isLogin = true;

TypeScript melihat:

true
↓
boolean

Maka:

isLogin → boolean

Jadi TypeScript cukup pintar untuk mengetahui tipe variable tanpa kita selalu menuliskannya secara eksplisit.

11. Type Variable Menjadi Ketat

Ini bagian yang sangat penting.

Misalnya:

let num = 100;

TypeScript menyimpulkan:

num = number

Kemudian kita melakukan:

num = 200;

✅ Boleh.

Karena 200 adalah number.

Tetapi:

num = true;

❌ Error.

Kenapa?

Karena:

num
↓
number

sedangkan:

true
↓
boolean

Kita mencoba memasukkan boolean ke variable yang sudah dianggap number.

TypeScript akan menolak.

12. Analogi Sederhana

Bayangkan ada kotak bernama num.

Ketika kita menulis:

let num = 100;

TypeScript seperti mengatakan:

“Oke, kotak num ini untuk angka.”

Jadi:

┌─────────────┐
│     100     │
│   NUMBER    │
└─────────────┘
      num

Kemudian:

num = 200;

Boleh:

100 → 200

karena keduanya number.

Tetapi:

num = true;

Tidak boleh:

number ← boolean

TypeScript akan mengatakan:

“Tunggu, kotak ini sudah ditentukan untuk number. Kenapa kamu memasukkan boolean?”

Itulah salah satu manfaat TypeScript.

13. Perbandingan dengan JavaScript

Nah, di sini kita bisa melihat perbedaan penting antara JavaScript dan TypeScript.

JavaScript bersifat dynamically typed. Materi sumber menjelaskan bahwa tipe variable JavaScript dapat berubah berdasarkan nilai yang diberikan kepadanya.

Contoh JavaScript:

let value = 100;

Awalnya:

value → number

Kemudian:

value = "Hello";

JavaScript mengizinkan.

Sekarang:

value → string

Kemudian:

value = true;

Bisa lagi.

Sekarang:

value → boolean

Jadi dalam JavaScript:

value
  ↓
number
  ↓
string
  ↓
boolean

Tipe bisa berubah.

14. Sedangkan TypeScript Lebih Ketat

Di TypeScript:

let value = 100;

TypeScript menyimpulkan:

value → number

Kemudian:

value = "Hello";

❌ Error.

Karena:

number ≠ string

Materi sumber menggunakan konsep ini untuk menjelaskan bahwa TypeScript memungkinkan error ditemukan lebih awal, sebelum kode dijalankan.

15. Kenapa Ini Berguna?

Bayangkan kita membuat function:

function add(num1, num2) {
    return num1 + num2;
}

Kita ingin:

add(3, 5);

hasilnya:

8

Tetapi kalau ada data seperti:

add("3", "5");

JavaScript bisa menghasilkan:

"35"

karena dua string digabungkan.

TypeScript membantu kita menentukan bahwa parameter tersebut seharusnya berupa number, sehingga kesalahan bisa diketahui lebih awal. Materi sumber menggunakan contoh add ini untuk menjelaskan manfaat strong typing.

Nanti kita akan belajar cara menulis:

function add(num1: number, num2: number) {
    return num1 + num2;
}

Sehingga TypeScript tahu:

num1 → number
num2 → number

dan kode yang salah bisa langsung ditandai.

16. Type Inference vs Explicit Type

Ada dua cara umum.

Cara pertama: TypeScript menebak

let age = 20;

TypeScript otomatis mengetahui:

age → number

Ini disebut inference.

Cara kedua: Kita menentukan sendiri

let age: number = 20;

Di sini kita mengatakan secara eksplisit:

age harus berupa number.

Syntax:

let namaVariable: tipeData = nilai;

Contoh:

let age: number = 20;
let name: string = "Budi";
let isLogin: boolean = true;

Nanti kita akan membahas type annotation ini lebih dalam.

17. Aturan Penamaan Variable

Lecture ini juga menjelaskan aturan ketika kita memilih nama variable.

Ada 5 aturan utama.

Rule 1 — Boleh menggunakan huruf, angka, _, dan $

Nama variable boleh mengandung:

• huruf a-z
• huruf A-Z
• angka 0-9
• underscore _
• dollar sign $

Contoh valid:

let name;
let firstName;
let first_name;
let user1;
let user123;
let $name;
let _name;

Semuanya valid.

18. Tapi Tidak Semua Karakter Boleh

Misalnya:

let first-name;

❌ Tidak valid.

Karena ada:

-

Hyphen - bukan karakter yang diperbolehkan dalam identifier variable seperti itu.

Begitu juga:

let first%name;

❌ Tidak valid.

Karena % tidak diperbolehkan.

Jadi ingat:

✓ letters
✓ digits
✓ _
✓ $

✗ -
✗ %
✗ @
✗ #

19. Rule 2 — Variable Tidak Boleh Dimulai dengan Angka

Ini penting.

Tidak boleh:

let 1name;

❌

Tidak boleh:

let 123user;

❌

Tetapi angka boleh berada setelah karakter pertama.

Contoh:

let user1;
let user2;
let product123;

✅

Jadi:

123user  ❌
user123  ✅

20. Rule 3 — Variable Bisa Dimulai dengan Huruf, _, atau $

Karakter pertama boleh berupa:

Huruf

let name;
let age;
let user;

Underscore

let _name;

Dollar sign

let $name;

Yang tidak boleh:

let 1name;

21. Rule 4 — Variable Name Case Sensitive

TypeScript membedakan huruf besar dan kecil.

Contoh:

let num = 10;
let Num = 20;

num dan Num dianggap dua variable berbeda.

Begitu juga:

let name = "Budi";
let Name = "Andi";
let NAME = "Citra";

Ketiganya berbeda:

name
Name
NAME

Jangan menganggap mereka sama.

Ini disebut:

Case sensitive

Contoh lain:

let username = "Budi";

console.log(username);

Berbeda dengan:

console.log(UserName);

UserName bukan username.

22. Rule 5 — Tidak Boleh Menggunakan Reserved Keyword

Ada beberapa kata yang sudah memiliki arti khusus di TypeScript/JavaScript.

Kata-kata ini disebut:

Reserved keywords

Contohnya:

class
if
while

Kita tidak boleh melakukan:

let class = "Hello";

❌

Karena class sudah digunakan oleh bahasa untuk konsep tertentu.

Begitu juga:

let if = 10;

❌

dan:

let while = 20;

❌

Jadi jangan menggunakan keyword yang sudah dipesan oleh bahasa sebagai nama variable.

23. Contoh Variable Name yang Valid dan Tidak Valid

24. Ada Satu Hal yang Perlu Diluruskan

Di transcript, ada bagian yang mengatakan kurang lebih bahwa setelah TypeScript menentukan tipe variable, tipe tersebut “tidak bisa berubah sepanjang program”.

Untuk pemahaman dasar lecture ini, anggap seperti itu:

let num = 100;

num = 200;    // ✅
num = true;   // ❌

Tetapi secara teknis TypeScript memiliki konsep yang lebih kompleks seperti type narrowing, widening, union types, dan control-flow analysis.

Nanti kita akan pelajari secara bertahap, jadi untuk sekarang tidak perlu memikirkan pengecualian-pengecualian tersebut.

Yang paling penting sekarang:

Kalau TypeScript mengetahui sebuah variable sebagai number, kita tidak bisa sembarangan memasukkan string atau boolean ke dalamnya.

25. Kesalahan yang Sering Dilakukan Pemula

Kesalahan 1

const age;
age = 20;

❌ Salah.

Gunakan:

const age = 20;

Kesalahan 2

let age = 20;

age = "twenty";

❌ Dalam konteks inference TypeScript, age telah diinfer sebagai number.

Kesalahan 3

let 1name = "Budi";

❌ Variable tidak boleh dimulai dengan angka.

Gunakan:

let name1 = "Budi";

Kesalahan 4

let first-name = "Budi";

❌ - tidak bisa digunakan seperti itu dalam nama variable.

Gunakan:

let firstName = "Budi";

Kesalahan 5

let class = "programming";

❌ class adalah reserved keyword.

26. Cara Berpikir yang Paling Mudah

Kalau kamu melihat:

let age = 20;

baca seperti ini:

“Saya membuat variable bernama age, nilainya sekarang 20, dan TypeScript mengetahui bahwa variable ini bertipe number.”

Kalau:

const name = "Budi";

baca:

“Saya membuat variable bernama name, nilainya Budi, dan variable ini tidak boleh di-assign ulang.”

27. Gambaran Besar Lecture Ini

Secara keseluruhan:

VARIABLE
   │
   ├── let
   │    ├── boleh tanpa nilai awal
   │    └── nilai bisa diubah
   │
   └── const
        ├── harus langsung diberi nilai
        └── tidak bisa di-assign ulang

Kemudian:

let num = 100;
       │
       └── TypeScript melihat 100
                    ↓
                 number

Sehingga:

num = 200;      // ✅
num = 300;      // ✅
num = "hello";  // ❌
num = true;     // ❌

Dan nama variable harus mengikuti aturan:

1. letters, digits, _, $
2. tidak boleh dimulai angka
3. boleh dimulai letter, _, $
4. case sensitive
5. tidak boleh reserved keyword

28. Ringkasan Super Singkat

Kalau kamu hanya ingin mengingat inti lecture ini, ingat 7 poin berikut:

1. Variable adalah tempat menyimpan nilai

let age = 20;

2. Variable bisa dibuat dengan let atau const

let age = 20;
const name = "Budi";

3. let bisa diubah

let age = 20;
age = 21;

4. const tidak bisa di-assign ulang

const name = "Budi";
name = "Andi"; // ❌

5. const harus langsung diinisialisasi

const age = 20; // ✅

bukan:

const age; // ❌

6. TypeScript bisa melakukan type inference

let age = 20;

TypeScript tahu:

age → number

7. Nama variable punya aturan

let firstName; // ✅
let user1;     // ✅
let _user;     // ✅
let $user;     // ✅

let 1user;     // ❌
let first-name;// ❌
let class;     // ❌

Jadi kalimat yang paling penting dari lecture ini adalah:

Kita membuat variable dengan let atau const. TypeScript dapat menyimpulkan tipe variable dari nilai awalnya, dan setelah tipe tersebut diketahui, TypeScript akan membantu mencegah kita memasukkan nilai dengan tipe yang tidak sesuai.

Setelah konsep ini sudah kuat, materi berikutnya tentang data types di TypeScript akan jauh lebih mudah dipahami, karena kita sudah tahu bagaimana sebuah variable bisa memiliki tipe seperti number, string, boolean, dan seterusnya.