10 Tipe Apa Pun (Any) di TypeScript

1. Apa itu any?

any secara sederhana berarti:

“Variable ini boleh berisi nilai apa saja.”

Misalnya:

let dynamicData: any;

Karena type-nya any, kita bebas memasukkan berbagai jenis data.

dynamicData = 10;

Boleh.

Kemudian:

dynamicData = true;

Juga boleh.

Kemudian:

dynamicData = "Hello";

Juga boleh.

Bahkan:

dynamicData = [1, 2, 3];

boleh.

Dan:

dynamicData = {
  name: "John",
  age: 30
};

juga boleh.

Jadi:

any
│
├── number       ✅
├── string       ✅
├── boolean      ✅
├── array        ✅
├── object       ✅
├── null         ✅
├── undefined    ✅
└── tipe lainnya ✅

Itulah kenapa any disebut sebagai tipe yang sangat fleksibel.

2. Contoh sederhana

Misalnya:

let data: any = 10;

Saat ini:

data = 10

Kemudian:

data = "Hello";

Sekarang:

data = "Hello"

Kemudian:

data = true;

Sekarang:

data = true

TypeScript tidak akan memprotes perubahan tersebut karena dari awal kita sudah mengatakan:

: any

Artinya kita memberikan izin kepada TypeScript:

“Data ini bisa berubah menjadi tipe apa pun.”

3. Bandingkan dengan type biasa

Kita sudah belajar type annotation sebelumnya.

Misalnya:

let age: number = 20;

TypeScript tahu bahwa:

age → number

Jadi:

age = 30;

✅ boleh.

Tetapi:

age = "Hello";

❌ error.

Karena "Hello" adalah string, sedangkan age harus number.

Sekarang:

let age: any = 20;

Kemudian:

age = "Hello";

✅ boleh.

Lalu:

age = false;

✅ boleh.

Karena:

any → menerima tipe apa saja

4. any benar-benar sangat fleksibel

Misalnya:

let dynamicData: any = 100;

Kemudian:

dynamicData = "John";
dynamicData = true;
dynamicData = [1, 2, 3];
dynamicData = {
  name: "John"
};

Semua diperbolehkan.

Inilah alasan any terlihat sangat nyaman.

Tapi justru kenyamanan ini bisa menjadi masalah.

5. Kenapa any sebaiknya dihindari?

Ini bagian paling penting dari lecture.

TypeScript dibuat untuk memberikan type safety.

Misalnya kita menulis:

let age: number = 20;

TypeScript membantu memastikan kita tidak melakukan sesuatu yang tidak sesuai dengan tipe.

Tetapi kalau kita menulis:

let age: any = 20;

TypeScript kehilangan banyak kemampuan untuk membantu kita.

Kita bisa melakukan:

age = "Hello";
age = true;
age = [];
age = {};

dan TypeScript tidak akan mempermasalahkannya.

Jadi secara sederhana:

TypeScript tanpa any
        ↓
Type checking kuat
        ↓
Lebih mudah menemukan kesalahan

sedangkan:

TypeScript dengan banyak any
        ↓
Type checking melemah
        ↓
Banyak kesalahan bisa lolos

6. any hampir menghilangkan keuntungan TypeScript

Ini inti pesan lecture.

Salah satu alasan kita menggunakan TypeScript adalah supaya kita tidak menulis JavaScript dengan cara yang terlalu bebas.

JavaScript bersifat dynamic typing.

Contohnya:

let data = 10;

data = "Hello";

data = true;

JavaScript memperbolehkannya.

Sedangkan TypeScript memberikan kita kemampuan untuk mengatakan:

let data: number = 10;

sehingga:

data = "Hello";

akan ditolak.

Tetapi kalau kita menulis:

let data: any = 10;

kita pada dasarnya berkata:

“TypeScript, jangan terlalu banyak memeriksa variable ini.”

Jadi terlalu banyak menggunakan any membuat TypeScript kehilangan sebagian besar manfaat type safety-nya.

7. Analogi sederhana

Bayangkan TypeScript adalah satpam.

Kita punya sebuah gedung.

Aturannya:

Hanya orang dengan kartu identitas tertentu yang boleh masuk.

Misalnya:

let age: number;

Satpam akan memeriksa:

20       → ✅ number
30       → ✅ number
"John"   → ❌ bukan number
true     → ❌ bukan number

Tetapi kita mengatakan:

let data: any;

kepada satpam:

“Yang ini bebas masuk.”

Maka:

number    → masuk
string    → masuk
boolean   → masuk
array     → masuk
object    → masuk

Akibatnya satpam memang lebih fleksibel, tetapi fungsi pengamanannya menjadi jauh berkurang.

8. any untuk array

Lecture juga menunjukkan bahwa any bisa digunakan untuk array.

Perhatikan:

let arr: any[];

Tanda [] berarti:

Ini adalah array.

Sedangkan:

any

berarti:

Isi array boleh memiliki tipe apa saja.

Jadi:

let arr: any[];

bisa berisi:

arr = [
  "Hello",
  10,
  true,
  null,
  undefined
];

Semuanya diperbolehkan.

9. Bedakan any dan any[]

Ini penting.

any

let data: any;

Variable data sendiri bisa berisi apa saja:

data = 10;
data = "Hello";
data = true;
data = [];
data = {};

any[]

let data: any[];

Variable data harus berupa array, tetapi isi array-nya boleh tipe apa saja.

data = [10, "Hello", true];

✅

Tetapi:

data = "Hello";

❌ karena "Hello" bukan array.

Jadi:

any
→ bentuk/nilai apa saja

any[]
→ harus array, tetapi isi array apa saja

10. Contoh perbandingan array

Misalnya:

let numbers: number[];

Artinya:

numbers = [10, 20, 30];

✅

Tetapi:

numbers = [10, "Hello", true];

❌

Karena array tersebut harus berisi number.

Sedangkan:

let data: any[];

maka:

data = [10, "Hello", true];

✅

Karena setiap item boleh memiliki tipe berbeda.

11. Hati-hati: any bukan berarti “tidak ada tipe”

Ini kesalahpahaman yang sering terjadi.

any tetap merupakan type.

let data: any;

any adalah instruksi kepada TypeScript bahwa variable tersebut boleh menerima berbagai jenis nilai dan pemeriksaan tipe terhadapnya sangat longgar.

Jadi jangan mengartikan:

“any berarti variable ini tidak punya type.”

Lebih tepat:

“any berarti TypeScript memperlakukan variable ini sebagai bisa memiliki tipe apa saja.”

12. Kapan any boleh digunakan?

Lecture menyarankan:

Hindari any kecuali memang benar-benar diperlukan.

Misalnya kita sedang berinteraksi dengan data dari luar aplikasi dan kita belum tahu bentuk datanya.

Contohnya secara sederhana:

let responseData: any;

Kita belum mengetahui apakah data tersebut:

object?
array?
string?
number?

Dalam kondisi seperti ini any bisa digunakan sementara.

Tetapi idealnya, setelah kita mengetahui struktur datanya, kita memberikan type yang lebih spesifik.

Misalnya daripada:

let user: any;

lebih baik:

let user: {
  name: string;
  age: number;
};

Ini jauh lebih aman.

13. Sekarang bagian kedua: variable tanpa type

Lecture kemudian membahas sesuatu yang berbeda.

Misalnya kita menulis:

let test;

Perhatikan:

• tidak ada type annotation
• tidak ada value

Kita tidak menulis:

let test: string;

dan juga tidak:

let test = "Hello";

Hanya:

let test;

Pertanyaannya:

Apa type dari test?

14. Nilai default-nya adalah undefined

Kalau kita melakukan:

console.log(test);

hasilnya:

undefined

Kenapa?

Karena kita membuat variable:

let test;

tetapi belum memberikan nilai.

Jadi variable tersebut belum mempunyai nilai konkret.

JavaScript memberikan nilai:

undefined

15. undefined bisa menjadi type dan value

Ini bagian yang cukup penting.

Kita perlu membedakan:

undefined sebagai value

let test = undefined;

Nilai variable tersebut adalah:

undefined

undefined sebagai type

Kita juga bisa memiliki type:

let test: undefined;

Artinya variable tersebut hanya boleh memiliki nilai undefined.

Jadi kata undefined bisa kita temui dalam dua konteks:

undefined
   │
   ├── value
   │
   └── type

16. typeof digunakan untuk mengecek tipe saat runtime

Lecture menggunakan:

typeof

Contohnya:

let test;

console.log(typeof test);

Hasilnya:

undefined

typeof adalah operator JavaScript yang bisa digunakan untuk mengetahui jenis nilai ketika program berjalan.

Contoh:

typeof 10

hasil:

"number"

typeof "Hello"

hasil:

"string"

typeof true

hasil:

"boolean"

typeof undefined

hasil:

"undefined"

Jadi:

console.log(typeof test);

memberi tahu kita bahwa nilai test saat runtime adalah undefined.

17. Bedakan typeof dengan type annotation

Ini juga penting.

Ketika kita menulis:

let age: number = 20;

number adalah type annotation TypeScript.

Sedangkan:

typeof age

adalah operator JavaScript yang mengecek tipe nilai saat runtime.

Jadi keduanya berbeda:

number
→ TypeScript type

typeof age
→ JavaScript runtime operator

18. let test; jangan langsung disamakan dengan any

Ini bagian yang perlu dipahami dengan hati-hati.

Kalau kita menulis:

let test;

jangan langsung berpikir:

test = any

Tidak sesederhana itu.

Dalam konteks lecture, fokusnya adalah bahwa variable yang belum diinisialisasi mempunyai nilai:

undefined

dan ketika kita menjalankan:

typeof test

hasilnya:

"undefined"

Jadi jangan menyamakan konsep:

let test;

dengan:

let test: any;

Keduanya memiliki tujuan dan perilaku yang berbeda.

19. Bandingkan tiga kondisi

Ini akan sangat membantu.

A. Ada type dan value

let age: number = 20;

Artinya:

Type  → number
Value → 20

B. Tidak ada type, tetapi ada value

let age = 20;

TypeScript melakukan type inference.

Type-nya diketahui sebagai:

number

Jadi:

Type  → number (inferred)
Value → 20

C. Tidak ada type dan tidak ada value

let age;

Variable belum diinisialisasi, sehingga nilainya:

undefined

Ini berbeda dari dua contoh sebelumnya.

20. Hubungannya dengan type inference

Ini nyambung langsung dengan materi sebelumnya.

Sebelumnya kita belajar:

let age = 20;

TypeScript melihat:

20

kemudian menyimpulkan:

age → number

Ini disebut type inference.

Tetapi kalau kita menulis:

let age;

TypeScript tidak mendapatkan value awal yang bisa digunakan untuk menyimpulkan tipe seperti pada contoh 20.

Yang jelas pada runtime, variable tersebut memiliki nilai:

undefined

21. Kesalahan konsep yang perlu dihindari

Jangan berpikir:

“Kalau saya tidak menulis type annotation, berarti TypeScript selalu menggunakan any.”

❌ Tidak benar.

Contohnya:

let name = "John";

TypeScript bisa melakukan inference:

name → string

Bukan any.

Begitu juga:

let age = 30;

menjadi:

age → number

Jadi:

Tidak menulis type annotation ≠ otomatis any.

Ini konsep yang sangat penting.

22. Kapan menggunakan any vs inference?

Biasanya lebih baik:

let data = 10;

daripada:

let data: any = 10;

Kenapa?

Karena pada kode pertama TypeScript tahu:

data → number

Sedangkan pada kode kedua:

data → any

TypeScript kehilangan informasi tipe.

Jadi jangan menggunakan:

: any

hanya karena malas menulis type yang benar.

23. Contoh masalah nyata akibat any

Misalnya:

let user: any = {
  name: "John"
};

Kemudian kita melakukan:

console.log(user.age.toUpperCase());

TypeScript bisa saja tidak memberikan error terkait keberadaan age, karena user adalah any.

Tetapi ketika program dijalankan, kita bisa mendapatkan error karena age tidak ada atau bukan nilai yang sesuai.

Inilah bahaya any:

Kesalahan yang seharusnya bisa ditemukan saat coding bisa baru muncul ketika program dijalankan.

Itu justru yang ingin kita hindari dengan TypeScript.

24. TypeScript seharusnya membantu kita

Bayangkan kita punya:

let user: {
  name: string;
  age: number;
} = {
  name: "John",
  age: 30
};

Kalau kita menulis:

user.age.toUpperCase();

TypeScript tahu:

user.age → number

dan number tidak mempunyai method toUpperCase().

Maka TypeScript bisa memperingatkan kita lebih awal.

Tetapi kalau:

let user: any = {
  name: "John",
  age: 30
};

TypeScript kehilangan banyak informasi tersebut.

25. Jadi any bukan “fitur yang buruk”

Penting untuk tidak salah memahami lecture.

any bukan berarti:

“Jangan pernah menggunakan any.”

Pesannya lebih tepat:

Jangan menggunakan any tanpa alasan.

Ada kondisi tertentu di mana kita belum tahu bentuk data dan any bisa menjadi solusi sementara.

Masalahnya adalah kalau seluruh aplikasi dipenuhi:

const a: any = ...
const b: any = ...
const c: any = ...
const d: any = ...

maka kita kehilangan banyak manfaat TypeScript.

26. Cheat sheet

27. Cara paling mudah mengingat any

Bayangkan ada tiga level aturan:

number

let data: number;

“Hanya number.”

number | string

let data: number | string;

“Boleh number atau string.”

Ini sudah lebih fleksibel, tetapi masih memiliki batas yang jelas.

any

let data: any;

“Terserah, tipe apa saja boleh.”

Jadi secara konsep:

number
   ↓
aturan ketat

number | string
   ↓
beberapa pilihan

any
   ↓
hampir tidak ada pembatasan

Dan semakin kita menggunakan any, semakin sedikit TypeScript bisa membantu kita.

28. Kesimpulan

Ada dua pelajaran utama dari lecture ini.

Pertama: any

let data: any;

berarti variable tersebut dapat menyimpan berbagai tipe nilai:

data = 10;
data = "Hello";
data = true;
data = [];
data = {};

Tetapi jangan menjadikan any sebagai pilihan default, karena any menghilangkan banyak manfaat type safety TypeScript.

Kedua: variable yang belum diinisialisasi

Ketika kita menulis:

let test;

dan tidak memberikan nilai awal, pada runtime nilainya adalah:

undefined

dan:

typeof test

menghasilkan:

"undefined"

Yang juga perlu diingat:

Tidak menulis type annotation bukan berarti otomatis menggunakan any.

Contoh:

let age = 20;

TypeScript tetap bisa melakukan inference dan mengetahui bahwa age adalah number.

Inti besarnya

Kalau materi sebelumnya mengajarkan:

“TypeScript bisa mengetahui tipe data kita.”

maka materi ini mengajarkan:

"any memungkinkan kita mengatakan kepada TypeScript: jangan membatasi data ini."

Dan karena tujuan utama kita menggunakan TypeScript adalah mendapatkan type safety, maka any sebaiknya digunakan hanya ketika memang diperlukan, bukan sebagai jalan pintas.

Kalau kamu mau, saya juga bisa membuat gambar/diagram visual yang membandingkan any, unknown, inference, dan type annotation supaya perbedaannya lebih mudah diingat.