உயர் வரிசை செயல்பாடு என்றால் என்ன?

Question

Accepted Answer

**உயர் வரிசை செயல்பாடு** என்பது குறைந்தபட்சம் ஒன்றைச் செய்யும் செயல்பாடு: **ஒரு செயல்பாட்டை வாதமாக எடுத்துக்கொள்ளுதல்**, அல்லது **ஒரு செயல்பாட்டை திருப்பி அனுப்புதல்**. JS இல் செயல்பாடுகள் *first-class values* ஆக இருப்பதால் இவை சாத்தியமாகும் (நீங்கள் அவற்றை எந்த மதிப்பையும் போல சுற்றிலும் அனுப்பலாம்).

## செயல்பாட்டை எடுத்துக்கொள்ளுதல்

```js
[1, 2, 3].map(n => n * 2);        // map takes a function
button.addEventListener("click", handler); // so does addEventListener
setTimeout(() => doThing(), 1000);
```

## செயல்பாட்டை திருப்பி அனுப்புதல் (பெரும்பாலும் closure ஐப் பயன்படுத்தி)

```js
function multiplier(factor) {
  return n => n * factor;  // returns a function that remembers `factor`
}
const double = multiplier(2);
const triple = multiplier(3);
double(5); // 10
triple(5); // 15
```

இங்கே `multiplier` ஒரு பொதுவான செயல்பாட்டிலிருந்து சிறப்பு செயல்பாடுகளை உருவாக்குகிறது — closure `factor` ஐ கைப்பற்றுகிறது.

## ஒரு நடைமுறை உதாரணம்: logging wrapper

```js
function withLogging(fn) {
  return (...args) => {
    console.log(`calling with`, args);
    const result = fn(...args);
    console.log(`result`, result);
    return result;
  };
}
const loggedAdd = withLogging((a, b) => a + b);
```

## இது ஏன் முக்கியமாக உள்ளது

உயர் வரிசை செயல்பாடுகள் குறியீட்டை **பிரகடனமாகவும் மீண்டும் பயன்படுத்தக்கூடிய** வகையில் ஆக்குகின்றன.

அவை array முறைகள் (`map`/`filter`/`reduce`), event handling, middleware, decorators, currying, மற்றும் React patterns (HOCs, custom hooks) ஆகியவற்றை அடிப்படையாகக் கொண்டுள்ளன.

ஒரே லூப் தர்க்கத்தை மீண்டும் மீண்டும் எழுதுவதற்குப் பதிலாக, நீங்கள் *நடத்தை* ஐ ஒரு செயல்பாடாக அனுப்புகிறீர்கள்.