कोडवर्ड समाधान - एक दूसरे पर काम करने वाले कार्य [बंद]

Question

मैं कोडवर्ड पर एक पहेली का हल देख रहा था और मुझे समझ नहीं आ रहा है कि यह क्यों काम करता है। माइनस () कैसे काम कर रहा है?

function makeNum(num, func) {
    if (func === undefined) {
        return num;
    } else {
        return func(num);
    }
}

function three(func) {
    return makeNum(3, func);
}

function eight(func) {
    return makeNum(8, func);
}

function minus(right) {
    return function(left) {
        return left - right;
    };
}

console.log(eight(minus(three()))); // will log out 5

Comments

यहाँ कुछ अलग दृष्टिकोण के साथ एक ऐसा ही सवाल है जो इस काम में कुछ प्रकाश डालने में मदद कर सकता है

— निक पार्सन्स

मैंने इसे समीक्षा ऑडिट के रूप में विफल करने के बाद इसे बंद करने के लिए मतदान किया है: यह मेरे लिए स्पष्ट नहीं था कि आप इसके बारे में क्या नहीं समझते। यह बेहतर होगा कि अगर आपको समझा जाए कि माइनस काम नहीं करना चाहिए, तो यह समझा जाए।

— जीएस -

Answer 1

यह थोड़ा जटिल है। :-)

console.log(eight(minus(three()))); अंदर से बाहर चलाया जाता है, तो चलो इसके माध्यम से पालन करें:

• three()- कॉल करता है makeNum(3, undefined)और जो रिटर्न देता है उसे वापस करता है। makeNum(3, undefined)रिटर्न 3, इसलिए वह रिटर्न वैल्यू है।
• minus(3)- कॉल minus, के 3रूप में गुजर रहा है right। minusएक नया फ़ंक्शन देता है जो बंद हो जाता है right।
• eight(...)- कॉल करता है makeNum(8, fnFromMinus)जहां fnFromMinusफ़ंक्शन है कि द्वारा वापस आ गया था minus(3)। makeNum(8, fnFromMinus)करता है fnFromMinus, के 8रूप में गुजर रहा है left। fnFromMinusका परिणाम देता है left - right(याद रखें कि rightहै 3, fnFromMinusइस पर बंद)।

के बाद से 8 - 3है 5, अंतिम परिणाम है 5, जो console.logरिटर्न।

यहाँ एक यंत्रीकृत संस्करण है:

let indent = 0;
function show(label) {
    console.log(" ".repeat(indent * 4) + label);
}
function fname(fn) {
    return fn ? fn.name : "undefined";
}

function makeNum(num, func) {
    const descr = `makeNum(${num}, ${fname(func)})`;
    show(descr);
    ++indent;
    if (func === undefined) {
        --indent;
        show(`${descr} returns ${num}`);
        return num;
    } else {
        const rv = func(num);
        --indent;
        show(`${descr} returns ${num}`);
        return rv;
    }
}

function three(func) {
    const descr = `three(${fname(func)})`;
    console.log(descr);
    ++indent;
    const rv = makeNum(3, func);
    --indent;
    show(descr + ` returns ${rv}`);
    return rv;
}

function eight(func) {
    const descr = `eight(${fname(func)})`;
    console.log(descr);
    ++indent;
    const rv = makeNum(8, func);
    --indent;
    show(descr + ` returns ${rv}`);
    return rv;
}

function minus(right) {
    const fn = function fnFromMinus(left) {
        show(`${fname(fn)} returns ${left} - ${right} = ${left - right}`);
        return left - right;
    };
    try {
        // For browsers that don't do `name` properly
        fn.name = "fnFromMinus";
    } catch (e) { }
    show(`minus(${right}) returns ${fname(fn)}`);
    return fn;
}

console.log(eight(minus(three()))); // will log out 5

.as-console-wrapper {
    max-height: 100% !important;£
}

Answer 2

यह वास्तव में जटिल नहीं है यदि आप इसके माध्यम से काम करते हैं। चलो अंदर से बाहर काम करते हैं। कॉलिंग:

three()

बिना पैरामीटर का मतलब है कि आप एक अपरिभाषित मूल्य को फंक के रूप में पारित कर रहे हैं। तो यह कहने के रूप में ही है:

makeNum(3, undefined)

जब MakeNum देखता है कि फन अपरिभाषित है, तो वह संख्या में लौटता है, जो कि 3 है।

इसलिए हमने इसे नीचे कर दिया है:

eight(minus(3))

अब देखते हैं कैसे

minus(3)

मूल्यांकन करता है। माइनस देखता है कि आपके द्वारा प्रदान किया गया पैरामीटर 3 है, इसलिए यह एक ऐसा फ़ंक्शन देता है जो "बाएं" पैरामीटर को स्वीकार कर सकता है और 3 को घटा सकता है जो हमने पहले से ही प्रदान किया है। यह निष्पादित नहीं करता है। यह बस वहां बैठता है, "बाएं" पैरामीटर के साथ बुलाया जाने की प्रतीक्षा करता है ताकि यह इसमें से 3 को घटा सके।

इसलिए हमने इसे नीचे कर दिया है:

eight(function(left){
    return left - 3;
})

अब देखते हैं कि यह कैसे मूल्यांकन करता है। आठ को फंक पैरामीटर इस फ़ंक्शन के साथ कहा जाता है:

function(left){
    return left - 3;
}

यह तब 8 और इस समारोह में आता है जब यह कहता है:

makeNum(8, func)

मेकम तब देखता है कि फंक प्रदान किया गया है (और इसलिए अपरिभाषित नहीं है) और फंक (संख्या) को आठ फ़ंक्शन पर वापस लौटाता है, जो गुजरने के समान है:

8 - 3

आठ समारोह में वापस। आठ फ़ंक्शन उस मान को प्राप्त करता है और फिर उसे वापस करता है। इसलिए हमने इसे नीचे कर दिया है:

5

जो कंसोल में लॉग इन हो जाता है।

Answer 3

minusकैप्चर किए जा रहे मापदंडों के साथ प्रत्येक आह्वान के लिए एक नया फ़ंक्शन देता है। जब लौटाया गया फंक्शन कहा जाता है, तो इसे पास किए गए किसी भी पैरामीटर के अलावा, पास किए गए मापदंडों को संदर्भित किया जा सकता है। यह जावास्क्रिप्ट में फ़ंक्शन को करीने का एक तरीका है।

Answer 4

यह कोड js जैसी कार्यात्मक प्रोग्रामिंग भाषाओं में हायर ऑर्डर फ़ंक्शंस का एक उदाहरण है। जावास्क्रिप्ट कार्यों को वस्तुओं के रूप में माना जाता है और उन्हें पारित किया जा सकता है और वापस भी किया जा सकता है।

हायर-ऑर्डर फ़ंक्शन एक फ़ंक्शन है जो एक फ़ंक्शन को एक तर्क के रूप में प्राप्त करता है या फ़ंक्शन को आउटपुट के रूप में लौटाता है।

minusमूल रूप से एक अनाम ( बिना परिभाषित नाम वाला एक फ़ंक्शन ) फ़ंक्शन लौटा रहा है :

function(left) {
        return left - 3; //right = 3
    };

इस फ़ंक्शन को जब पास किया eightजाता है func(8), तब इसे बुलाया जाता है, जिसके बाद परिणाम दिया जाता है5

Answer 5

इसे देखने का दूसरा तरीका - आप इस लाइन को फिर से लिख सकते हैं:

console.log(eight(minus(three())));

जैसा:

const threeResult = three(); // = 3
const minusResult = minus(threeResult); // = a function that subtracts 3
const eightResult = eights(minusResult); // = 5