JavaScript
कार्यात्मक जावास्क्रिप्ट

टिप्पणियों

कार्य को तर्क के रूप में स्वीकार करना

function transform(fn, arr) {
    let result = [];
    for (let el of arr) {
        result.push(fn(el)); // We push the result of the transformed item to result
    }
    return result;
}

console.log(transform(x => x * 2, [1,2,3,4])); // [2, 4, 6, 8]

जैसा कि आप देख सकते हैं, हमारा transform फ़ंक्शन दो मापदंडों, एक फ़ंक्शन और एक संग्रह को स्वीकार करता है। यह तब संग्रह को पुनरावृत्त करेगा, और परिणाम पर मान को धक्का देगा, उनमें से प्रत्येक पर fn को कॉल करना।

जाना पहचाना? यह कैसे Array.prototype.map() काम करता है के समान है!

console.log([1, 2, 3, 4].map(x => x * 2)); // [2, 4, 6, 8]

उच्च-क्रम के कार्य

सामान्य तौर पर, ऐसे फ़ंक्शंस जो अन्य फ़ंक्शंस पर काम करते हैं, या तो उन्हें तर्क के रूप में लेते हैं या उन्हें (या दोनों) लौटाते हैं, उन्हें उच्च-क्रम फ़ंक्शन कहा जाता है।

एक उच्च-क्रम फ़ंक्शन एक फ़ंक्शन है जो किसी अन्य फ़ंक्शन को तर्क के रूप में ले सकता है। कॉलबैक पास करते समय आप उच्च-क्रम के कार्यों का उपयोग कर रहे हैं।

function iAmCallbackFunction() {
    console.log("callback has been invoked");
}

function iAmJustFunction(callbackFn) {
    // do some stuff ...

    // invoke the callback function.
    callbackFn();
}

// invoke your higher-order function with a callback function.
iAmJustFunction(iAmCallbackFunction);

एक उच्च-क्रम फ़ंक्शन भी एक फ़ंक्शन है जो किसी अन्य फ़ंक्शन को इसके परिणाम के रूप में लौटाता है।

function iAmJustFunction() {
    // do some stuff ...

    // return a function.
    return function iAmReturnedFunction() {
        console.log("returned function has been invoked");
    }
}

// invoke your higher-order function and its returned function.
iAmJustFunction()();

पहचान मोनाद

यह जावास्क्रिप्ट में पहचान मठ के कार्यान्वयन का एक उदाहरण है, और अन्य मठ बनाने के लिए एक प्रारंभिक बिंदु के रूप में काम कर सकता है।

मोनाड्स और गोनाड्स पर डगलस क्रॉकफोर्ड द्वारा सम्मेलन के आधार पर

इस क्रिया का उपयोग करके अपने कार्यों का पुन: उपयोग करना आसान हो जाएगा क्योंकि यह मोनाड लचीलापन प्रदान करता है, और रचना बुरे सपने:

f(g(h(i(j(k(value), j1), i2), h1, h2), g1, g2), f1, f2)

पठनीय, अच्छा और साफ:

identityMonad(value)
    .bind(k)
    .bind(j, j1, j2)
    .bind(i, i2)
    .bind(h, h1, h2)
    .bind(g, g1, g2)
    .bind(f, f1, f2);

function identityMonad(value) {
    var monad = Object.create(null);
    
    // func should return a monad
    monad.bind = function (func, ...args) {
        return func(value, ...args);
    };

    // whatever func does, we get our monad back
    monad.call = function (func, ...args) {
        func(value, ...args);

        return identityMonad(value);
    };
    
    // func doesn't have to know anything about monads
    monad.apply = function (func, ...args) {
        return identityMonad(func(value, ...args));
    };

    // Get the value wrapped in this monad
    monad.value = function () {
        return value;
    };
    
    return monad;
};

यह आदिम मूल्यों के साथ काम करता है

var value = 'foo',
    f = x => x + ' changed',
    g = x => x + ' again';

identityMonad(value)
    .apply(f)
    .apply(g)
    .bind(alert); // Alerts 'foo changed again'

और वस्तुओं के साथ भी

var value = { foo: 'foo' },
    f = x => identityMonad(Object.assign(x, { foo: 'bar' })),
    g = x => Object.assign(x, { bar: 'foo' }),
    h = x => console.log('foo: ' + x.foo + ', bar: ' + x.bar);

identityMonad(value)
    .bind(f)
    .apply(g)
    .bind(h); // Logs 'foo: bar, bar: foo'

चलो सब कुछ कोशिश करते हैं:

var add = (x, ...args) => x + args.reduce((r, n) => r + n, 0),
    multiply = (x, ...args) => x * args.reduce((r, n) => r * n, 1),
    divideMonad = (x, ...args) => identityMonad(x / multiply(...args)),
    log = x => console.log(x),
    substract = (x, ...args) => x - add(...args);

identityMonad(100)
    .apply(add, 10, 29, 13)
    .apply(multiply, 2)
    .bind(divideMonad, 2)
    .apply(substract, 67, 34)
    .apply(multiply, 1239)
    .bind(divideMonad, 20, 54, 2)
    .apply(Math.round)
    .call(log); // Logs 29

शुद्ध कार्य

कार्यात्मक प्रोग्रामिंग का एक मूल सिद्धांत यह है कि यह अनुप्रयोग स्थिति (स्टेटलेसनेस) को बदलने से बचता है और इसके दायरे (अपरिवर्तनीयता) के बाहर चर भी।

शुद्ध कार्य ऐसे कार्य हैं:

• दिए गए इनपुट के साथ, हमेशा समान आउटपुट लौटाएं
• वे अपने दायरे के बाहर किसी भी चर पर भरोसा नहीं करते हैं
• वे आवेदन की स्थिति को संशोधित नहीं करते हैं ( कोई दुष्प्रभाव नहीं )

आइए कुछ उदाहरण देखें:

शुद्ध कार्यों को उनके दायरे से बाहर किसी भी चर को नहीं बदलना चाहिए

प्रभाव समारोह

let obj = { a: 0 }

const impure = (input) => {
  // Modifies input.a
  input.a = input.a + 1;
  return input.a;
}

let b = impure(obj)
console.log(obj) // Logs { "a": 1 }
console.log(b) // Logs 1

फ़ंक्शन ने obj.a मान को बदल दिया है जो इसके दायरे से बाहर है।

शुद्ध कार्य

let obj = { a: 0 }

const pure = (input) => {
  // Does not modify obj
  let output = input.a + 1;
  return output;
}

let b = pure(obj)
console.log(obj) // Logs { "a": 0 }
console.log(b) // Logs 1

फ़ंक्शन ने ऑब्जेक्ट obj मानों को नहीं बदला

शुद्ध कार्यों को अपने दायरे से बाहर चर पर भरोसा नहीं करना चाहिए

प्रभाव समारोह

let a = 1;

let impure = (input) => {
  // Multiply with variable outside function scope
  let output = input * a;
  return output;
}

console.log(impure(2)) // Logs 2
a++; // a becomes equal to 2
console.log(impure(2)) // Logs 4

यह अशुद्ध कार्य चर पर निर्भर है a कि इसके दायरे से बाहर परिभाषित है। इसलिए, अगर एक संशोधित किया गया है, तो impure का फ़ंक्शन परिणाम अलग होगा।

शुद्ध कार्य

let pure = (input) => {
  let a = 1;
  // Multiply with variable inside function scope
  let output = input * a;
  return output;
}

console.log(pure(2)) // Logs 2

pure कार्य फ़ंक्शन परिणाम के दायरे के बाहर किसी भी चर पर भरोसा नहीं करता है ।