Mengoptimumkan Fungsi Kari TypeScript: Daripada Jenis Statik kepada Jenis Variadik

Kari ialah teknik pengaturcaraan berfungsi yang mengubah fungsi dengan berbilang argumen kepada urutan fungsi, masing-masing mengambil satu hujah. Pendekatan ini amat berguna untuk mencipta lebih banyak fungsi modular dan boleh digunakan semula, membenarkan penggunaan separa hujah. Dalam TypeScript, melaksanakan fungsi kari yang cekap memerlukan pengurusan jenis yang teliti, terutamanya apabila berurusan dengan bilangan argumen yang berubah-ubah.

Dalam artikel ini, kami akan meneroka dua pelaksanaan berbeza bagi fungsi kari dalam TypeScript. Yang pertama menggunakan antara muka dengan jenis statik, manakala yang kedua menggunakan pendekatan yang lebih fleksibel menggunakan antara muka tunggal dengan jenis variadic. Kami akan menganalisis perbezaan antara kedua-dua pelaksanaan ini dan membincangkan kelebihan pendekatan yang lebih dioptimumkan.

Pelaksanaan Awal: Antara Muka dengan Jenis Statik

Mentakrifkan Antara Muka

Dalam pelaksanaan pertama, saya menentukan satu siri antara muka untuk mengendalikan fungsi kari dengan bilangan argumen yang berbeza-beza. Setiap antara muka sepadan dengan fungsi dengan bilangan argumen tertentu:

interface CurryFunction1<T1, R> {
    (arg1: T1): R;
}

interface CurryFunction2<T1, T2, R> {
    (arg1: T1): CurryFunction1<T2, R>;
}

interface CurryFunction3<T1, T2, T3, R> {
    (arg1: T1): CurryFunction2<T2, T3, R>;
}

interface CurryFunction4<T1, T2, T3, T4, R> {
    (arg1: T1): CurryFunction3<T2, T3, T4, R>;
}

interface CurryFunction5<T1, T2, T3, T4, T5, R> {
    (arg1: T1): CurryFunction4<T2, T3, T4, T5, R>;
}

interface CurryFunction6<T1, T2, T3, T4, T5, T6, R> {
    (arg1: T1): CurryFunction5<T2, T3, T4, T5, T6, R>;
}

Melaksanakan Fungsi Kari

Fungsi kari ditakrifkan untuk menggunakan antara muka ini untuk kari fungsi dengan sehingga enam argumen:

function curry<T1, T2, R>(fn: (arg1: T1, arg2: T2) => R): CurryFunction2<T1, T2, R>;
function curry<T1, T2, T3, R>(fn: (arg1: T1, arg2: T2, arg3: T3) => R): CurryFunction3<T1, T2, T3, R>;
function curry<T1, T2, T3, T4, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): CurryFunction4<T1, T2, T3, T4, R>;
function curry<T1, T2, T3, T4, T5, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => R): CurryFunction5<T1, T2, T3, T4, T5, R>;
function curry<T1, T2, T3, T4, T5, T6, R>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => R): CurryFunction6<T1, T2, T3, T4, T5, T6, R>;
function curry(fn: Function) {
    return function curried(...args: any[]) {
        if (args.length >= fn.length) {
            return fn(...args);
        } else {
            return (...args2: any[]) => curried(...args, ...args2);
        }
    };
}

Menguji Fungsi Kari

Fungsi ini kemudiannya diuji untuk memastikan ia berfungsi dengan betul dengan bilangan argumen yang berbeza:

function testCurry() {
    const add = (a: number, b: number) => a + b;
    const curriedAdd = curry(add);
    assert(curriedAdd(1)(2) === 3, 'Test curry function with 2 arguments');

    const add3Args = (a: number, b: number, c: number) => a + b + c;
    const curriedAdd3Args = curry(add3Args);
    assert(curriedAdd3Args(1)(2)(3) === 6, 'Test curry function with 3 arguments');
}

Analisis Pelaksanaan

Walaupun pelaksanaan ini jelas dan tipikal bagi TypeScript, ia mempunyai beberapa had. Terutamanya, ia memerlukan takrifan berbilang antara muka untuk setiap bilangan argumen yang mungkin, menjadikan kod itu berlebihan dan lebih sukar untuk dikekalkan. Selain itu, pengendalian lebih daripada enam hujah memerlukan penambahan lebih banyak antara muka, meningkatkan kerumitan.

Pelaksanaan Dioptimumkan: Antara Muka Tunggal dengan Jenis Variadik

Pengenalan kepada Jenis Variadik

Untuk mengoptimumkan fungsi kari, saya menggunakan pendekatan yang lebih dinamik menggunakan antara muka generik tunggal dengan jenis variadic. Pendekatan ini membolehkan mengendalikan bilangan hujah yang sewenang-wenangnya tanpa perlu menentukan antara muka yang berasingan untuk setiap kes.

Melaksanakan Fungsi Kari dengan Jenis Variadik

Dalam versi yang dioptimumkan ini, fungsi kari dilaksanakan menggunakan antara muka generik tunggal yang memanfaatkan jenis variadik TypeScript untuk mengendalikan bilangan hujah yang sewenang-wenangnya:

type CurryFunction<T extends unknown[], R> = T extends [infer A, ...infer Rest]
  ? (arg: A) => CurryFunction<Rest, R>
  : R;

function curry<T extends unknown[], R>(fn: (...args: T) => R): CurryFunction<T, R> {
  return function curried(...args: unknown[]): unknown {
    if (args.length >= fn.length) {
      return fn(...args as T);
    } else {
      return (...args2: unknown[]) => curried(...([...args, ...args2] as unknown[]));
    }
  } as CurryFunction<T, R>;
}

Faedah Pelaksanaan Dioptimumkan

1. Kerumitan Dikurangkan: Dengan menggunakan antara muka generik tunggal CurryFunction, pelaksanaan ini menghapuskan keperluan untuk mencipta berbilang antara muka untuk setiap bilangan argumen yang mungkin. Ini menjadikan kod lebih ringkas dan lebih mudah diselenggara.

2. Sokongan untuk Bilangan Argumen Arbitrari: Memanfaatkan jenis variadic membolehkan fungsi ini mengakali fungsi dengan sebarang bilangan argumen tanpa mengubah suai pelaksanaan. Oleh itu, fungsi ini lebih fleksibel dan boleh disesuaikan dengan pelbagai senario.

3. Penaipan yang Dipertingkat: Penaipan dinamik membolehkan TypeScript menyimpulkan jenis hujah dengan tepat, menyediakan pemeriksaan jenis yang lebih kukuh semasa pembangunan, mengurangkan risiko ralat dan menambah baik pelengkapan kod.

Menguji Fungsi Kari Dioptimumkan

Versi fungsi kari ini juga diuji untuk memastikan ia berfungsi dengan betul:

function testCurry() {
    const add = (a: number, b: number) => a + b;
    const curriedAdd = curry(add);
    assert(curriedAdd(1)(2) === 3, 'Test curry function with 2 arguments');

    const add3Args = (a: number, b: number, c: number) => a + b + c;
    const curriedAdd3Args = curry(add3Args);
    assert(curriedAdd3Args(1)(2)(3) === 6, 'Test curry function with 3 arguments');

    const add4Args = (a: number, b: number, c: number, d: number) => a + b + c + d;
    const curriedAdd4Args = curry(add4Args);
    assert(curriedAdd4Args(1)(2)(3)(4) === 10, 'Test curry function with 4 arguments');
}

Mengoptimumkan fungsi kari dalam TypeScript menunjukkan cara pendekatan berdasarkan antara muka statik boleh dipertingkatkan dengan menggunakan jenis variadic. Pelaksanaan baharu bukan sahaja mengurangkan kerumitan kod tetapi juga menawarkan fleksibiliti yang lebih besar dan pemeriksaan jenis yang lebih kukuh. Contoh ini menyerlahkan kepentingan memanfaatkan sepenuhnya keupayaan TypeScript untuk mencipta kod yang lebih bersih, lebih modular dan boleh diselenggara.

Peralihan daripada struktur dengan berbilang antara muka kepada antara muka generik tunggal ialah contoh yang bagus tentang cara memahami dan menggunakan konsep TypeScript lanjutan boleh membawa kepada penyelesaian yang lebih elegan dan cekap.

Atas ialah kandungan terperinci Mengoptimumkan Fungsi Kari TypeScript: Daripada Jenis Statik kepada Jenis Variadik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!