Codewars Solution - Funzioni che agiscono l'una sull'altra nidificate [chiuso]

Stavo cercando una soluzione a un puzzle su codewars e non capisco perché funzioni. Come funziona minus ()?

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

È un po 'complicato :-)

console.log(eight(minus(three()))); viene eseguito dall'interno verso l'esterno, quindi seguiamolo attraverso:

• three()- chiama makeNum(3, undefined)e restituisce ciò che restituisce. makeNum(3, undefined)restituisce 3, quindi questo è il valore restituito.
• minus(3)- chiama minus, passando 3come right. minusrestituisce una nuova funzione che si chiude right.
• eight(...)- chiama makeNum(8, fnFromMinus)dove si fnFromMinustrova la funzione che è stata restituita minus(3). makeNum(8, fnFromMinus)fa fnFromMinus, passando 8come left. fnFromMinusrestituisce il risultato di left - right(ricorda che rightè 3, fnFromMinuschiuso su di esso).

Poiché 8 - 3è 5, il risultato finale è 5, che console.logritorna.

Ecco una versione strumentata:

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;£
}

In realtà non è così complicato se lo fai passo per passo. Lavoriamo da dentro e fuori. Calling:

three()

senza un parametro significa che stai passando un valore indefinito come func. Quindi è come dire:

makeNum(3, undefined)

Quando makeNum vede che func non è definito, restituisce num, che è 3.

Quindi abbiamo ridotto questo a:

eight(minus(3))

Ora vediamo come

minus(3)

Esamina. meno vede che il parametro che hai fornito è 3, quindi restituisce una funzione che può accettare un parametro "sinistro" e sottrarre il 3 che abbiamo già fornito da esso. NON viene eseguito. Si trova lì, in attesa di essere chiamato con un parametro "left" in modo da poter sottrarre 3 da esso.

Quindi abbiamo ridotto questo a:

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

Ora vediamo come viene valutato. otto viene chiamato con il parametro func essendo questa funzione:

function(left){
    return left - 3;
}

Quindi passa 8 e questa funzione per makeNum quando dice:

makeNum(8, func)

makeNum vede quindi che func è stato fornito (e quindi non è definito) e restituisce func (num) alle otto funzioni, che è lo stesso del passaggio:

8 - 3

torna alle otto funzioni. L'ottava funzione riceve quel valore e poi lo restituisce. Quindi abbiamo ridotto questo a:

5

che viene registrato nella console.

minusrestituisce una nuova funzione per ogni chiamata con i parametri passati ad essa catturati. Quando viene chiamata la funzione restituita, può fare riferimento ai parametri passati quando viene chiamata, oltre a tutti i parametri passati ad essa. Questo è un modo per curry funzioni in JavaScript.

Questo codice è un esempio di funzioni di ordine superiore in linguaggi di programmazione funzionali come js. Le funzioni Javascript sono trattate come oggetti e possono anche essere passate e restituite.

Una funzione di ordine superiore è una funzione che riceve una funzione come argomento o restituisce la funzione come output.

minussta restituendo una funzione anonima ( una funzione senza un nome definito ) sostanzialmente come:

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

Questa funzione quando viene passata eightviene chiamata come, func(8)quindi dà il risultato come5

Un altro modo di vederlo: puoi riscrivere questa riga:

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

Come:

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