JavaScript Karēšanas Tehnikas: Funkcionālā Programmēšana pret Daļēju Piemērošanu

JavaScript izstrādes pasaulē tādu progresīvu tehniku kā karēšana apgūšana var ievērojami uzlabot jūsu koda lasāmību, atkārtotu izmantojamību un vispārējo uzturēšanu. Karēšana (currying), spēcīgs jēdziens, kas aizgūts no funkcionālās programmēšanas, ļauj pārveidot funkciju, kas pieņem vairākus argumentus, par funkciju secību, kur katra pieņem vienu argumentu. Šis emuāra ieraksts iedziļinās karēšanas sarežģītībā, salīdzinot to ar daļēju piemērošanu un sniedzot praktiskus piemērus, lai ilustrētu tās priekšrocības.

Kas ir Karēšana (Currying)?

Karēšana ir funkcijas transformācija, kas pārveido funkciju no izsaucama formā f(a, b, c) uz izsaucamu formā f(a)(b)(c). Vienkāršāk sakot, karēta funkcija nepieņem visus argumentus uzreiz. Tā vietā tā pieņem pirmo argumentu un atgriež jaunu funkciju, kas sagaida otro argumentu, un tā tālāk, līdz visi argumenti ir piegādāti un tiek atgriezts galīgais rezultāts.

Koncepcijas Izpratne

Iedomājieties funkciju, kas paredzēta reizināšanas veikšanai:

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

              
                Copy
              
            
          

Šīs funkcijas karētā versija izskatītos šādi:

            function curriedMultiply(a) {
  return function(b) {
    return a * b;
  }
}
            

              
                Copy
              
            
          

Tagad to var izmantot šādi:

            const multiplyByTwo = curriedMultiply(2);
console.log(multiplyByTwo(5)); // Output: 10

            

              
                Copy
              
            
          

Šeit curriedMultiply(2) atgriež jaunu funkciju, kas atceras a vērtību (kas ir 2) un gaida otro argumentu b. Kad jūs izsaucat multiplyByTwo(5), tā izpilda iekšējo funkciju ar a = 2 un b = 5, rezultātā iegūstot 10.

Karēšana pret Daļēju Piemērošanu

Lai gan bieži tiek lietoti aizvietojami, karēšana un daļēja piemērošana ir atšķirīgi, bet saistīti jēdzieni. Galvenā atšķirība ir tajā, kā tiek piemēroti argumenti:

• Karēšana: Pārveido funkciju ar vairākiem argumentiem par virkni ligzdotu unāru (viena argumenta) funkciju. Katra funkcija pieņem tieši vienu argumentu.
• Daļēja piemērošana: Pārveido funkciju, iepriekš aizpildot dažus no tās argumentiem. Tā var pieņemt vienu vai vairākus argumentus vienlaicīgi, un atgrieztajai funkcijai joprojām jāpieņem atlikušie argumenti.

Daļējas Piemērošanas Piemērs

            function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

function partialGreet(greeting) {
  return function(name) {
    return greet(greeting, name);
  }
}

const sayHello = partialGreet("Hello");
console.log(sayHello("Alice")); // Output: Hello, Alice!

            

              
                Copy
              
            
          

Šajā piemērā partialGreet pieņem argumentu greeting un atgriež jaunu funkciju, kas sagaida name. Tā ir daļēja piemērošana, jo tā ne vienmēr pārveido sākotnējo funkciju par unāru funkciju virkni.

Karēšanas Piemērs

            function curryGreet(greeting) {
  return function(name) {
    return `${greeting}, ${name}!`;
  }
}

const currySayHello = curryGreet("Hello");
console.log(currySayHello("Bob")); // Output: Hello, Bob!

            

              
                Copy
              
            
          

Šajā gadījumā `curryGreet` pieņem vienu argumentu un atgriež jaunu funkciju, kas pieņem otro argumentu. Galvenā atšķirība no iepriekšējā piemēra ir smalka, bet svarīga: karēšana fundamentāli pārveido funkcijas struktūru par viena argumenta funkciju virkni, kamēr daļēja piemērošana tikai iepriekš aizpilda argumentus.

Karēšanas un Daļējas Piemērošanas Priekšrocības

Gan karēšana, gan daļēja piemērošana piedāvā vairākas priekšrocības JavaScript izstrādē:

• Koda atkārtota izmantojamība: Izveidojiet specializētas funkcijas no vispārīgākām, iepriekš aizpildot argumentus.
• Uzlabota lasāmība: Sadaliet sarežģītas funkcijas mazākos, vieglāk pārvaldāmos gabalos.
• Palielināta elastība: Viegli pielāgojiet funkcijas dažādiem kontekstiem un scenārijiem.
• Argumentu atkārtošanas novēršana: Samaziniet standarta kodu, atkārtoti izmantojot iepriekš aizpildītus argumentus.
• Funkcionālā kompozīcija: Atvieglojiet sarežģītāku funkciju izveidi, apvienojot vienkāršākas.

Karēšanas un Daļējas Piemērošanas Praktiskie Piemēri

Apskatīsim dažus praktiskus scenārijus, kuros karēšana un daļēja piemērošana var būt noderīga.

1. Žurnalēšana ar Iepriekš Definētiem Līmeņiem

Iedomājieties, ka jums ir nepieciešams žurnalēt ziņojumus ar dažādiem svarīguma līmeņiem (piem., INFO, WARN, ERROR). Jūs varat izmantot daļēju piemērošanu, lai izveidotu specializētas žurnalēšanas funkcijas:

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

function createLogger(level) {
  return function(message) {
    log(level, message);
  };
}

const logInfo = createLogger("INFO");
const logWarn = createLogger("WARN");
const logError = createLogger("ERROR");

logInfo("Application started successfully.");
logWarn("Low disk space detected.");
logError("Failed to connect to the database.");

            

              
                Copy
              
            
          

Šī pieeja ļauj jums izveidot atkārtoti lietojamas žurnalēšanas funkcijas ar iepriekš definētiem svarīguma līmeņiem, padarot jūsu kodu tīrāku un organizētāku.

2. Skaitļu Formatēšana ar Lokalizācijas Specifiskiem Iestatījumiem

Strādājot ar skaitļiem, bieži vien ir nepieciešams tos formatēt atbilstoši konkrētām lokalizācijām (piemēram, izmantojot dažādus decimālos atdalītājus vai valūtas simbolus). Jūs varat izmantot karēšanu, lai izveidotu funkcijas, kas formatē skaitļus, pamatojoties uz lietotāja lokalizāciju:

            function formatNumber(locale) {
  return function(number) {
    return number.toLocaleString(locale);
  };
}

const formatGermanNumber = formatNumber("de-DE");
const formatUSNumber = formatNumber("en-US");

console.log(formatGermanNumber(1234.56)); // Output: 1.234,56
console.log(formatUSNumber(1234.56));   // Output: 1,234.56

            

              
                Copy
              
            
          

Šis piemērs demonstrē, kā karēšanu var izmantot, lai izveidotu funkcijas, kas pielāgojas dažādiem kultūras iestatījumiem, padarot jūsu lietojumprogrammu lietotājam draudzīgāku globālai auditorijai.

3. Dinamisku Vaicājumu Virkņu Veidošana

Dinamisku vaicājumu virkņu izveide ir bieži sastopams uzdevums, strādājot ar API. Karēšana var palīdzēt jums veidot šīs virknes elegantākā un uzturējamākā veidā:

            function buildQueryString(baseUrl) {
  return function(params) {
    const queryString = Object.entries(params)
      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
      .join('&');
    return `${baseUrl}?${queryString}`;
  };
}

const createApiUrl = buildQueryString("https://api.example.com/data");

const apiUrl = createApiUrl({
  page: 1,
  limit: 20,
  sort: "name"
});

console.log(apiUrl); // Output: https://api.example.com/data?page=1&limit=20&sort=name

            

              
                Copy
              
            
          

Šis piemērs parāda, kā karēšanu var izmantot, lai izveidotu funkciju, kas ģenerē API URL ar dinamiskiem vaicājumu parametriem.

4. Notikumu Apstrāde Tīmekļa Lietojumprogrammās

Karēšana var būt neticami noderīga, veidojot notikumu apstrādātājus tīmekļa lietojumprogrammās. Iepriekš konfigurējot notikumu apstrādātāju ar konkrētiem datiem, jūs varat samazināt standarta koda daudzumu un padarīt savu notikumu apstrādes loģiku kodolīgāku.

            function handleClick(elementId, message) {
  return function(event) {
    const element = document.getElementById(elementId);
    if (element) {
      element.textContent = message;
    }
  };
}

const button = document.getElementById('myButton');
if (button) {
  button.addEventListener('click', handleClick('myButton', 'Button Clicked!'));
}

            

              
                Copy
              
            
          

Šajā piemērā `handleClick` ir karēta, lai iepriekš pieņemtu elementa ID un ziņojumu, atgriežot funkciju, kas pēc tam tiek pievienota kā notikuma klausītājs. Šis modelis padara kodu lasāmāku un atkārtoti lietojamu, īpaši sarežģītās tīmekļa lietojumprogrammās.

Karēšanas Ieviešana JavaScript

Ir vairāki veidi, kā ieviest karēšanu JavaScript. Jūs varat manuāli izveidot karētas funkcijas, kā parādīts iepriekšējos piemēros, vai arī varat izmantot palīgfunkcijas, lai automatizētu šo procesu.

Manuālā Karēšana

Kā parādīts iepriekšējos piemēros, manuālā karēšana ietver ligzdotu funkciju izveidi, kur katra pieņem vienu argumentu. Šī pieeja nodrošina precīzu kontroli pār karēšanas procesu, bet var būt pļāpīga funkcijām ar daudziem argumentiem.

Karēšanas Palīgfunkcijas Izmantošana

Lai vienkāršotu karēšanas procesu, varat izveidot palīgfunkciju, kas automātiski pārveido funkciju tās karētajā ekvivalentā. Šeit ir piemērs karēšanas palīgfunkcijai:

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

            

              
                Copy
              
            
          

Šī curry funkcija kā ievadi pieņem funkciju fn un atgriež šīs funkcijas karētu versiju. Tā darbojas, rekursīvi apkopojot argumentus, līdz tiek piegādāti visi sākotnējai funkcijai nepieciešamie argumenti. Kad visi argumenti ir pieejami, tā izpilda sākotnējo funkciju ar šiem argumentiem.

Lūk, kā varat izmantot curry palīgfunkciju:

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

const curriedAdd = curry(add);

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

            

              
                Copy
              
            
          

Bibliotēku, piemēram, Lodash, Izmantošana

Bibliotēkas, piemēram, Lodash, nodrošina iebūvētas funkcijas karēšanai, padarot šīs tehnikas pielietošanu jūsu projektos vēl vienkāršāku. Lodash _.curry funkcija darbojas līdzīgi iepriekš aprakstītajai palīgfunkcijai, bet tā piedāvā arī papildu opcijas un funkcijas.

            const _ = require('lodash');

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

const curriedMultiply = _.curry(multiply);

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

            

              
                Copy
              
            
          

Progresīvas Karēšanas Tehnikas

Papildus pamata karēšanas ieviešanai ir vairākas progresīvas tehnikas, kas var vēl vairāk uzlabot jūsu koda elastību un izteiksmīgumu.

Aizstājējargumenti (Placeholders)

Aizstājējargumenti ļauj jums norādīt secību, kādā argumenti tiek piemēroti karētai funkcijai. Tas var būt noderīgi, ja vēlaties iepriekš aizpildīt dažus argumentus, bet citus atstāt vēlākam laikam.

            const _ = require('lodash');

function divide(a, b) {
  return a / b;
}

const curriedDivide = _.curry(divide);

const divideBy = curriedDivide(_.placeholder, 2); // Placeholder for the first argument

console.log(divideBy(10)); // Output: 5

            

              
                Copy
              
            
          

Šajā piemērā _.placeholder tiek izmantots, lai norādītu, ka pirmais arguments tiks aizpildīts vēlāk. Tas ļauj izveidot funkciju divideBy, kas dala skaitli ar 2, neatkarīgi no tā, kādā secībā argumenti tiek sniegti.

Automātiskā Karēšana

Automātiskā karēšana ir tehnika, kurā funkcija automātiski sevi karē, pamatojoties uz sniegto argumentu skaitu. Ja funkcija saņem visus nepieciešamos argumentus, tā tiek izpildīta nekavējoties. Pretējā gadījumā tā atgriež jaunu funkciju, kas sagaida atlikušos argumentus.

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

function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

const autoCurriedGreet = autoCurry(greet);

console.log(autoCurriedGreet("Hello", "World")); // Output: Hello, World!
console.log(autoCurriedGreet("Hello")("World")); // Output: Hello, World!

            

              
                Copy
              
            
          

Šī autoCurry funkcija automātiski pārvalda karēšanas procesu, ļaujot jums izsaukt funkciju ar visiem argumentiem uzreiz vai vairākos zvanos.

Biežākās Kļūdas un Labākās Prakses

Lai gan karēšana var būt spēcīga tehnika, ir svarīgi apzināties iespējamās nepilnības un ievērot labākās prakses, lai nodrošinātu, ka jūsu kods paliek lasāms un uzturams.

• Pārmērīga karēšana: Izvairieties no nevajadzīgas funkciju karēšanas. Karējiet funkcijas tikai tad, ja tas sniedz skaidru labumu atkārtotas izmantojamības vai lasāmības ziņā.
• Sarežģītība: Karēšana var pievienot sarežģītību jūsu kodam, īpaši, ja to nelieto apdomīgi. Pārliecinieties, ka karēšanas priekšrocības atsver pievienoto sarežģītību.
• Atkļūdošana: Karētu funkciju atkļūdošana var būt sarežģīta, jo izpildes plūsma var būt mazāk tieša. Izmantojiet atkļūdošanas rīkus un tehnikas, lai saprastu, kā tiek piemēroti argumenti un kā funkcija tiek izpildīta.
• Nosaukumu piešķiršanas konvencijas: Izmantojiet skaidrus un aprakstošus nosaukumus karētām funkcijām un to starprezultātiem. Tas palīdzēs citiem izstrādātājiem (un jums nākotnē) saprast katras funkcijas mērķi un to, kā tā tiek izmantota.
• Dokumentācija: Rūpīgi dokumentējiet savas karētās funkcijas, paskaidrojot katra argumenta mērķi un funkcijas sagaidāmo uzvedību.

Noslēgums

Karēšana un daļēja piemērošana ir vērtīgas tehnikas JavaScript, kas var uzlabot jūsu koda lasāmību, atkārtotu izmantojamību un elastību. Izprotot atšķirības starp šiem jēdzieniem un tos pareizi pielietojot, jūs varat rakstīt tīrāku, uzturamāku kodu, ko ir vieglāk testēt un atkļūdot. Neatkarīgi no tā, vai jūs veidojat sarežģītas tīmekļa lietojumprogrammas vai vienkāršas utilītas funkcijas, karēšanas un daļējas piemērošanas apgūšana neapšaubāmi paaugstinās jūsu JavaScript prasmes un padarīs jūs par efektīvāku izstrādātāju. Atcerieties ņemt vērā sava projekta kontekstu, izsvērt ieguvumus pret iespējamiem trūkumiem un ievērot labākās prakses, lai nodrošinātu, ka karēšana uzlabo, nevis kavē jūsu koda kvalitāti.

Pieņemot funkcionālās programmēšanas principus un izmantojot tādas tehnikas kā karēšana, jūs varat atklāt jaunus izteiksmīguma un elegances līmeņus savā JavaScript kodā. Turpinot pētīt JavaScript izstrādes pasauli, apsveriet iespēju eksperimentēt ar karēšanu un daļēju piemērošanu savos projektos un atklājiet, kā šīs tehnikas var palīdzēt jums rakstīt labāku, uzturamāku kodu.