TypeScript Academy · Pelajaran

Memahami unknown vs any

Pahami alasan unknown menjadi alternatif any yang aman secara jenis.

Memahami unknown vs any adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Dua Tipe Teratas

TypeScript memiliki dua tipe yang dapat menampung nilai apa pun: any dan unknown. Keduanya tampak serupa, tetapi perilakunya sangat berbeda. Memilih yang tepat adalah keterampilan inti untuk menulis kode dengan tipe yang aman.

let a: any = 5;
let u: unknown = 5;
console.log(a, u);

any Menonaktifkan Pemeriksaan Tipe

any adalah jalan keluar darurat yang menonaktifkan pemeriksa tipe untuk nilai tersebut. Anda dapat mengakses properti apa pun atau memanggilnya sebagai fungsi — kompilator tetap diam, bahkan ketika tindakan itu dapat menyebabkan program gagal saat dijalankan.

const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtime

unknown Memaksa Anda Memeriksa

unknown juga menerima nilai apa pun, tetapi Anda tidak dapat menggunakannya sampai membuktikan jenisnya. Kompilator memblokir akses properti dan pemanggilan sampai Anda mempersempit tipe tersebut.

const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);

Mempersempit unknown dengan typeof

Pemeriksaan typeof mempersempit unknown menjadi tipe konkret di dalam blok. Setelah dipersempit, semua metode tipe tersebut dapat digunakan dengan aman.

function shout(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase(); // safe here
  }
  return 'not a string';
}
console.log(shout('hi'), shout(42));

Mengapa unknown Lebih Aman

unknown menyatakan ketidakpastian yang sebenarnya: 'Saya belum tahu ini apa.' Ini mendorong Anda untuk memvalidasi sebelum menggunakan nilai tersebut, sehingga bug dapat ditemukan saat kompilasi. any hanya menyembunyikan ketidakpastian dan bug itu.

function len(value: unknown): number {
  if (typeof value === 'string') return value.length;
  if (Array.isArray(value)) return value.length;
  return 0;
}
console.log(len('abc'), len([1, 2]), len(99));

Menetapkan ke dan dari unknown

Nilai apa pun dapat ditetapkan ke unknown. Namun, unknown hanya dapat ditetapkan ke unknown atau any — bukan ke tipe tertentu tanpa penyempitan. Ketidaksimetrian inilah yang membuatnya aman.

let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Error

any Menyebar di Seluruh Kode Anda

Sifat any yang berbahaya adalah kemampuannya untuk menyebar. Setelah suatu nilai menjadi any, apa pun yang diturunkan darinya juga menjadi any, sehingga keamanan tipe terkikis secara diam-diam di seluruh program Anda.

const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);

unknown Membatasi Risiko

Dengan unknown, ketidakpastian tetap berada di tempatnya. Anda harus mempersempit tipe secara eksplisit pada setiap batas, sehingga operasi yang tidak aman tidak dapat menyebar ke tempat lain. Risiko tetap terkendali di tempat yang semestinya.

const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
  console.log('Has count property');
}

Mengetik Batas API dan JSON

Data eksternal — JSON, respons jaringan, masukan pengguna — tidak memiliki jaminan. Mengetiknya sebagai unknown, bukan any, memaksa validasi sebelum Anda mempercayainya, sehingga menjadi pilihan awal yang aman.

function parse(text: string): unknown {
  return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
  console.log('Got an object');
}

Kapan any Dapat Diterima

any terkadang merupakan pilihan pragmatis — untuk prototipe cepat, migrasi bertahap dari JavaScript, atau interoperabilitas dengan pustaka tanpa tipe. Namun, perlakukan any sebagai penanda sementara, bukan kebiasaan. Sebisa mungkin, pilih unknown.

// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);

Perbandingan Praktis

Jika dibandingkan berdampingan: versi any berhasil dikompilasi tetapi dapat gagal saat dijalankan; versi unknown menolak mengompilasi akses yang tidak aman. Kompilator sedang menjalankan tugasnya — melindungi Anda.

const a: any = 42;
console.log(a.toFixed(2)); // OK by luck

const u: unknown = 42;
if (typeof u === 'number') {
  console.log(u.toFixed(2)); // checked, safe
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang unknown dan any.

Ringkasan: unknown dan any

Poin penting:

any menonaktifkan pemeriksaan tipe dan menyebar melalui nilai-nilai turunannya.
unknown menerima nilai apa pun, tetapi memblokir penggunaannya sampai Anda mempersempit tipe tersebut.
Gunakan unknown untuk data eksternal (JSON, API, masukan pengguna) agar validasi selalu dilakukan.
Simpan any untuk migrasi atau interoperabilitas tanpa tipe sebagai penanda sementara.

Selanjutnya, kita menjelajahi tipe kosong: never.

function safeLen(v: unknown): number {
  return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memahami unknown vs any” gratis?

Ya — teks lengkap “Memahami unknown vs any” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Memahami unknown vs any”?

Pahami alasan unknown menjadi alternatif any yang aman secara jenis. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Memahami unknown vs any” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Memahami unknown vs any
Jenis never dan Status yang Mustahil
Jenis void dalam Fungsi
Penanganan unknown yang Aman Secara Jenis

← Kembali ke TypeScript Academy