Membuat dan Menggunakan Fungsi Generik

Fungsi generik dalam TypeScript memungkinkan Anda menulis kode yang dapat bekerja dengan berbagai tipe data tanpa kehilangan keamanan tipe. Sintaks dasarnya menggunakan parameter tipe dalam tanda kurung siku (<T>) yang dideklarasikan sebelum parameter fungsi.

function identity<T>(arg: T): T {
    return arg;
}
// Penggunaan
let output1 = identity<string>("Hello"); // Tipe: string
let output2 = identity<number>(42); // Tipe: number

Dengan ini, fungsi identity dapat menerima dan mengembalikan tipe apa pun yang ditentukan saat pemanggilan, menjaga fleksibilitas dan ketepatan tipe.

Constraints membatasi parameter tipe generik untuk memastikan mereka memenuhi syarat tertentu, seperti memiliki properti tertentu. Ini berguna saat Anda perlu mengakses metode atau atribut spesifik dalam fungsi.

interface Lengthwise {
    length: number;
}
function logLength<T extends Lengthwise>(arg: T): void {
    console.log(arg.length);
}
// Hanya tipe dengan properti length yang diperbolehkan
logLength("hello"); // Valid, string memiliki length
logLength([1, 2, 3]); // Valid, array memiliki length
// logLength(42); // Error: number tidak memiliki length

Dengan constraints, Anda dapat menulis fungsi yang lebih aman dan ekspresif, mencegah penggunaan tipe yang tidak kompatibel.

Dalam pengembangan aplikasi, fungsi utility generik dapat menyederhanakan tugas umum seperti filtering atau sorting data. Misalnya, buat fungsi untuk memfilter array berdasarkan kriteria tertentu.

function filterArray<T>(arr: T[], predicate: (item: T) => boolean): T[] {
    return arr.filter(predicate);
}
// Contoh: filter angka genap
const numbers = [1, 2, 3, 4, 5];
const evens = filterArray<number>(numbers, (n) => n % 2 === 0);
// evens: [2, 4] dengan tipe number[]

Fungsi ini dapat digunakan kembali untuk berbagai tipe data, meningkatkan efisiensi kode dan mempertahankan keamanan tipe TypeScript dalam skenario nyata.

Fungsi generik dapat memiliki lebih dari satu parameter tipe untuk menangani kasus yang lebih kompleks, seperti menggabungkan dua nilai dengan tipe berbeda. Ini berguna dalam skenario seperti pemetaan atau transformasi data.

function merge<T, U>(obj1: T, obj2: U): T & U {
    return { ...obj1, ...obj2 };
}
// Contoh penggunaan
const result = merge<{ name: string }, { age: number }>(
    { name: "Alice" },
    { age: 30 }
);
// result memiliki tipe { name: string; age: number }

Teknik ini memastikan bahwa tipe hasil menggabungkan properti dari kedua objek dengan aman, menghindari error pada waktu kompilasi.

Generik sangat efektif untuk bekerja dengan array dan struktur data lainnya, memungkinkan fungsi untuk beroperasi pada elemen dengan tipe seragam. Contoh umum adalah fungsi untuk mengembalikan elemen pertama dari sebuah array.

function firstElement<T>(arr: T[]): T | undefined {
    return arr[0];
}
// Penggunaan dengan berbagai tipe array
let num = firstElement<number>([1, 2, 3]); // Tipe: number | undefined
let str = firstElement<string>(["a", "b", "c"]); // Tipe: string | undefined

Pendekatan ini meningkatkan reusability kode dan memastikan bahwa operasi pada array tetap type-safe, mengurangi risiko bug.