JavaScript Currying

Kari ialah konsep berkuasa dalam pengaturcaraan berfungsi yang mengubah fungsi dengan berbilang argumen kepada urutan fungsi, masing-masing mengambil satu hujah. Teknik ini membolehkan kod yang lebih modular dan boleh digunakan semula. Dalam JavaScript, karipap boleh dilaksanakan dalam pelbagai cara. Blog ini akan meneroka karipap, memberikan contoh dan membincangkan kaedah yang berbeza untuk mencapai karipap n hujah.

Apa itu Kari?

Kari ialah proses menukar fungsi yang mengambil berbilang argumen kepada satu siri fungsi yang masing-masing mengambil satu argumen. Sebagai contoh, fungsi f(a, b, c) boleh diubah menjadi f(a)(b)(c).

Mengapa Menggunakan Kari?

• Aplikasi Separa: Currying membolehkan anda membetulkan beberapa hujah fungsi dan mencipta fungsi baharu.
• Fungsi Susunan Tinggi: Ia memudahkan penggunaan fungsi tertib tinggi, yang mengambil fungsi lain sebagai hujah atau mengembalikannya.
• Kebolehgunaan Semula Kod: Fungsi kari lebih boleh diguna semula dan boleh digubah.
• Komposisi Fungsian: Currying membolehkan komposisi berfungsi yang lebih baik, di mana fungsi kompleks dibina dengan menggabungkan fungsi yang lebih ringkas, membawa kepada kod yang lebih bersih dan lebih boleh diselenggara.

Contoh Karipap Mudah

Mari kita mulakan dengan contoh asas untuk memahami cara kari berfungsi.

Fungsi Tidak Berlaku

Berikut ialah fungsi mudah yang menambah tiga nombor:

function add(a, b, c) {
  return a + b + c;
}

console.log(add(1, 2, 3)); // Output: 6

Penjelasan: Fungsi tambah ini mengambil tiga argumen a, b dan c serta mengembalikan jumlahnya. Apabila kita memanggil add(1, 2, 3), ia mengembalikan 6.

Fungsi Kari

Sekarang, mari tukar fungsi ini kepada versi kari:

function curryAdd(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
    };
  };
}

console.log(curryAdd(1)(2)(3)); // Output: 6

Penjelasan: Fungsi curryAdd mengambil hujah a dan mengembalikan fungsi yang mengambil hujah b, yang seterusnya mengembalikan fungsi yang mengambil hujah c. Fungsi akhir mengembalikan jumlah a, b, dan c. Apabila kita memanggil curryAdd(1)(2)(3), ia secara berurutan menghantar hujah 1, 2, dan 3 melalui fungsi bersarang, menghasilkan 6.

Kari dengan Fungsi Anak Panah

Fungsi anak panah JavaScript menyediakan cara ringkas untuk mencipta fungsi kari.

const curryAddArrow = a => b => c => a + b + c;

console.log(curryAddArrow(1)(2)(3)); // Output: 6

Penjelasan: Fungsi curryAddArrow ialah fungsi anak panah yang mengambil hujah a dan mengembalikan satu lagi fungsi anak panah yang mengambil b, yang mengembalikan satu lagi fungsi anak panah yang mengambil c. Fungsi anak panah akhir mengembalikan jumlah a, b, dan c. Apabila kita memanggil curryAddArrow(1)(2)(3), ia secara berurutan menghantar argumen 1, 2 dan 3 melalui fungsi anak panah bersarang, menghasilkan 6.

Use Case

1.Fungsi Konfigurasi

Kes penggunaan biasa untuk kari ialah fungsi konfigurasi. Sebagai contoh, bayangkan anda sedang mencipta utiliti pengelogan di mana anda ingin mengkonfigurasi tahap pengelogan dan format mesej secara berasingan.

function logger(level) {
  return function (message) {
    console.log(`[${level}] ${message}`);
  };
}

const infoLogger = logger('INFO');
const errorLogger = logger('ERROR');

infoLogger('This is an info message');
errorLogger('This is an error message');

2. Pemformat Rentetan

Mari kita pertimbangkan contoh praktikal di mana kari boleh digunakan untuk mencipta pemformat rentetan. Pemformat ini akan membolehkan anda mengkonfigurasi awalan dan akhiran secara berasingan.

function formatter(prefix) {
  return function (suffix) {
    return function (str) {
      return `${prefix}${str}${suffix}`;
    };
  };
}

const htmlFormatter = formatter('<b>')('</b>');
console.log(htmlFormatter('Hello')); // <b>Hello</b>

const parensFormatter = formatter('(')(')');
console.log(parensFormatter('123')); // (123)

Kari dalam Perpustakaan JavaScript Moden

Kari biasanya digunakan dalam perpustakaan JavaScript moden seperti Lodash dan Ramda. Contohnya, dalam Lodash, anda boleh menggunakan kaedah _.kari untuk mencipta fungsi kari dengan mudah.

const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4)); // 24
console.log(curriedMultiply(2, 3)(4)); // 24

Kari dengan N Hujah

Lepaskan contoh karipap di bawah dengan fungsi rekursif yang menambah n argumen. Kami akan menggunakan kari untuk mencipta fungsi yang boleh menerima sebarang bilangan hujah, satu demi satu dan menambahkannya bersama-sama.

function curryAddition(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

// This function sums an array of numbers
function add(...nums) {
  return nums.reduce((acc, num) => acc + num, 0);
}

// Creating a curried version of the addition function
const curriedAdd = curryAddition(add);

// Function to handle n arguments
function curriedAddN(...initialArgs) {
  function adder(...args) {
    if (args.length === 0) {
      return curriedAdd(...initialArgs);
    }
    initialArgs.push(...args);
    return adder;
  }
  return adder;
}

// Examples
const addFiveNumbers = curriedAddN();
console.log(addFiveNumbers(1)(2)(3)(4)(5)()); // 15

const addThreeNumbers = curriedAddN(1)(2)(3);
console.log(addThreeNumbers()); // 6

const addNumbersInSteps = curriedAddN(1, 2)(3)(4, 5);
console.log(addNumbersInSteps()); // 15

Kesimpulan

Kari ialah teknik yang berkuasa dalam pengaturcaraan berfungsi yang meningkatkan modulariti dan kebolehgunaan semula kod. Dengan menukar fungsi kepada rangkaian fungsi hujah tunggal, kari membenarkan aplikasi separa dan komposisi fungsi yang fleksibel. Sama ada untuk konfigurasi, pemformatan rentetan atau pengiraan yang rumit, kari boleh menjadikan kod anda lebih ekspresif dan boleh disesuaikan.

Atas ialah kandungan terperinci JavaScript Currying. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!