Codewars-Lösung - Aufeinanderwirkende Funktionen verschachtelt [geschlossen]

Ich habe nach einer Lösung für ein Rätsel mit Codewars gesucht und verstehe nicht, warum es funktioniert. Wie funktioniert 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

Es ist ein bisschen kompliziert. :-)

console.log(eight(minus(three()))); wird von innen nach außen ausgeführt, also folgen wir ihm durch:

• three()- ruft auf makeNum(3, undefined)und gibt zurück, was es zurückgibt. makeNum(3, undefined)gibt zurück 3, das ist also der Rückgabewert.
• minus(3)- Anrufe minus, Weitergabe 3als right. minusGibt eine neue Funktion zurück, die geschlossen wird right.
• eight(...)- ruft auf, makeNum(8, fnFromMinus)wo fnFromMinussich die Funktion befindet, die von zurückgegeben wurde minus(3). makeNum(8, fnFromMinus)tut fnFromMinus, 8als übergeben left. fnFromMinusgibt das Ergebnis left - right(das erinnern rightist 3, fnFromMinusüber sie geschlossen).

Da 8 - 3ist 5, ist das Endergebnis 5, das console.logzurückkehrt.

Hier ist eine instrumentierte Version:

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

Es ist eigentlich nicht so kompliziert, wenn man es Schritt für Schritt durcharbeitet. Lassen Sie uns von innen heraus arbeiten. Berufung:

three()

Ohne Parameter bedeutet dies, dass Sie einen undefinierten Wert als Funktion übergeben. Es ist also dasselbe wie zu sagen:

makeNum(3, undefined)

Wenn makeNum erkennt, dass func undefiniert ist, gibt es num zurück, was 3 ist.

Also haben wir dies auf Folgendes reduziert:

eight(minus(3))

Nun wollen wir sehen wie

minus(3)

bewertet. minus sieht, dass der von Ihnen angegebene Parameter 3 ist, gibt also eine Funktion zurück, die einen "linken" Parameter akzeptieren und die 3, die wir bereits bereitgestellt haben, von diesem subtrahieren kann. Es wird NICHT ausgeführt. Es sitzt einfach da und wartet darauf, mit einem "linken" Parameter aufgerufen zu werden, damit es 3 davon subtrahieren kann.

Also haben wir dies auf Folgendes reduziert:

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

Nun wollen wir sehen, wie dies ausgewertet wird. acht wird aufgerufen, wobei der func-Parameter diese Funktion ist:

function(left){
    return left - 3;
}

Es übergibt dann 8 und diese Funktion an makeNum, wenn es heißt:

makeNum(8, func)

makeNum erkennt dann, dass func bereitgestellt wurde (und daher nicht undefiniert ist) und gibt func (num) an die Acht-Funktion zurück, was dem Übergeben entspricht:

8 - 3

zurück zur Achtfunktion. Die Acht-Funktion empfängt diesen Wert und gibt ihn dann zurück. Also haben wir dies auf Folgendes reduziert:

5

welches in der Konsole angemeldet wird.

minusGibt für jeden Aufruf eine neue Funktion zurück, wobei die an ihn übergebenen Parameter erfasst werden. Wenn die zurückgegebene Funktion aufgerufen wird, kann sie zusätzlich zu den an sie übergebenen Parametern auf die beim Aufruf übergebenen Parameter verweisen. Dies ist eine Möglichkeit, Funktionen in JavaScript zu curry.

Dieser Code ist ein Beispiel für Funktionen höherer Ordnung in funktionalen Programmiersprachen wie js. Javascript-Funktionen werden als Objekte behandelt und können auch übergeben und zurückgegeben werden.

Eine Funktion höherer Ordnung ist eine Funktion, die eine Funktion als Argument empfängt oder die Funktion als Ausgabe zurückgibt.

minusgibt eine anonyme Funktion ( eine Funktion ohne definierten Namen ) im Grunde zurück als:

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

Wenn diese Funktion an übergeben wird, eightwird sie als aufgerufen, func(8)was dann das Ergebnis als ergibt5

Eine andere Sichtweise - Sie können diese Zeile neu schreiben:

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

Wie:

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