Belajar TypeScript - Fungsi dengan Tipe, Parameter Opsional, dan Default

#Pendahuluan

Fungsi adalah unit kerja utama dalam aplikasi TypeScript. Di episode sebelumnya fungsi hanya muncul sebagai contoh singkat. Episode 7 fokus penuh pada pengetikan fungsi: bagaimana menandai parameter, mengatur nilai balik, dan menyatakan kontrak yang memaksa pemanggil memberi argumen yang benar.

Tanpa pengetikan yang baik, fungsi hanyalah mesin yang menerima apa saja dan mengembalikan apa saja. Dengan tipe, sebuah fungsi menjadi komponen yang terdokumentasi: nama fungsi menceritakan apa yang ia lakukan, dan tanda tangannya menceritakan bagaimana memakainya dengan aman.

Kalian akan belajar parameter opsional dengan tanda tanya, nilai default, rest parameter untuk argumen tak terbatas, dan function overload untuk fungsi yang melayani beberapa bentuk pemanggilan sekaligus.

#Menulis Fungsi Bertipe

#Annotation Parameter dan Return Type

Cara paling eksplisit menulis fungsi:

function tambah(a: number, b: number): number {
    return a + b;
}
 
const kali = (a: number, b: number): number => a * b;

Deklarasi function tambah(a: number, b: number): number memaksa setiap pemanggilan memberi dua argumen number, dan menjamin hasilnya juga number. TypeScript akan memunculkan error bila argumen kurang, berlebih, atau bertipe salah. Notation ini bekerja sama baiknya untuk function declaration dan arrow function.

#Return Type Inference

Sering kali return type bisa disimpulkan sendiri:

function gabung(nama: string, tahun: number) {
    return `${nama} tahun ${tahun}`;
}
 
const hasil = gabung("Bumi", 2026);

TypeScript menyimpulkan nilai balik gabung sebagai string dari ekspresi template. Membiarkan inference bekerja membuat kode lebih ringkas. Return type eksplisit tetap berguna untuk fungsi rekursif atau saat kalian ingin mencegah perubahan tak sengaja pada bentuk hasil.

#Parameter Opsional dan Default

#Parameter Opsional dengan Tanda Tanya

Argumen yang boleh dilewati ditandai dengan tanda tanya:

function sapa(nama: string, sapaan?: string): string {
    return sapaan ? `${sapaan}, ${nama}` : `Halo, ${nama}`;
}
 
sapa("Budi");
sapa("Budi", "Selamat pagi");

Parameter sapaan? boleh tidak diberikan. Di dalam fungsi, nilainya bertipe string | undefined, sehingga perlu pemeriksaan sebelum dipakai. Parameter opsional harus diletakkan setelah parameter wajib agar pemanggilan tetap masuk akal.

#Nilai Default

Nilai default menggantikan kebutuhan akan parameter opsional dalam banyak kasus:

function diskon(harga: number, persen: number = 10): number {
    return harga - (harga * persen) / 100;
}
 
console.log(diskon(100_000));
console.log(diskon(100_000, 25));

Parameter persen mendapat nilai 10 bila pemanggil tidak memberikannya. Berbeda dengan parameter opsional, parameter dengan default tidak perlu pemeriksaan tambahan karena nilainya selalu ada.

#Rest Parameter

Rest parameter menampung argumen sisa dalam jumlah bebas:

function total(...angka: number[]): number {
    return angka.reduce((acc, n) => acc + n, 0);
}
 
console.log(total(1, 2, 3, 4));

Parameter ...angka mengumpulkan semua argumen tambahan menjadi array number. Pemanggilan bisa menerima satu, dua, atau sepuluh angka tanpa mengubah deklarasi. Rest parameter selalu bertipe array dan harus menjadi parameter terakhir.

#Function Overloads

Satu fungsi kadang melayani beberapa kombinasi argumen yang berbeda. Overload mendeklarasikan setiap kombinasi secara terpisah:

function format(tanggal: Date): string;
function format(epoch: number): string;
 
function format(sumber: Date | number): string {
    return sumber instanceof Date
        ? sumber.toISOString()
        : new Date(sumber).toISOString();
}

Dua baris pertama adalah signature overload yang dilihat pemanggil, sedangkan baris ketiga adalah implementasi yang menjembatani semuanya. Pemanggil mendapat kejelasan bentuk argumen yang valid, sementara implementasi menangani kedua kasus dengan union. Overload paling berguna saat fungsi menerima input yang sangat berbeda bentuknya.

#Penutup

Episode 7 membuat fungsi kalian aman dari pemanggilan yang salah. Dengan annotation parameter, return type, parameter opsional, default, rest parameter, dan overload, kalian bisa menyatakan secara tepat apa yang fungsi butuhkan dan apa yang akan ia kembalikan.

Inti yang harus dibawa pulang:

• Annotation parameter dan return type menegakkan kontrak pemanggilan.
• Return type bisa dibiarkan disimpulkan untuk menjaga kode ringkas.
• Parameter opsional bertipe string | undefined di dalam fungsi.
• Nilai default membuat argumen selalu tersedia tanpa pemeriksaan.
• Rest parameter menampung argumen bebas menjadi array.
• Overload menyatakan beberapa kombinasi argumen untuk satu fungsi.

Di episode 8 selanjutnya kita akan membahas generik dan tipe parametrik, alat untuk menulis fungsi dan struktur yang bekerja untuk banyak tipe tanpa kehilangan jaminan tipe.