Solution Codewars - Fonctions agissant les unes sur les autres imbriquées [fermé]

Je cherchais une solution à un puzzle sur les guerres de codes et je ne comprends pas pourquoi cela fonctionne. Comment fonctionne moins ()?

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

C'est un peu compliqué. :-)

console.log(eight(minus(three()))); est exécuté de l'intérieur vers l'extérieur, nous allons donc le suivre à travers:

• three()- appelle makeNum(3, undefined)et retourne ce qu'il retourne. makeNum(3, undefined)renvoie 3, c'est donc la valeur de retour.
• minus(3)- appels minus, passant 3comme right. minusrenvoie une nouvelle fonction qui se ferme right.
• eight(...)- appelle makeNum(8, fnFromMinus)où fnFromMinusest la fonction qui a été retournée par minus(3). makeNum(8, fnFromMinus)fait fnFromMinus, passant 8comme left. fnFromMinusrenvoie le résultat de left - right(rappelez - vous que rightest 3, fnFromMinusfermé au - dessus).

Depuis 8 - 3est 5, le résultat final est 5, qui console.logretours.

Voici une version instrumentée:

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

En fait, ce n'est pas si compliqué si vous travaillez pas à pas. Travaillons de l'intérieur. Appel:

three()

sans paramètre signifie que vous passez une valeur indéfinie comme func. C'est donc la même chose que de dire:

makeNum(3, undefined)

Lorsque makeNum voit que func n'est pas défini, il renvoie num, qui est 3.

Nous avons donc réduit cela à:

eight(minus(3))

Voyons maintenant comment

minus(3)

évalue. moins voit que le paramètre que vous avez fourni est 3, donc il retourne une fonction qui peut accepter un paramètre "gauche" et soustraire le 3 que nous avons déjà fourni. Il ne s'exécute PAS. Il se trouve juste là, attendant d'être appelé avec un paramètre "gauche" pour pouvoir en soustraire 3.

Nous avons donc réduit cela à:

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

Voyons maintenant comment cela évalue. huit est appelé avec le paramètre func étant cette fonction:

function(left){
    return left - 3;
}

Il passe ensuite 8 et cette fonction à makeNum quand il dit:

makeNum(8, func)

makeNum voit alors que func a été fourni (et n'est donc pas indéfini) et renvoie func (num) à la fonction huit, ce qui revient à passer:

8 - 3

retour à la fonction huit. La fonction huit reçoit cette valeur, puis la renvoie. Nous avons donc réduit cela à:

5

qui est enregistré dans la console.

minusrenvoie une nouvelle fonction pour chaque appel avec les paramètres qui lui sont transmis en cours de capture. Lorsque la fonction retournée est appelée, elle peut référencer les paramètres passés lors de l'appel, en plus de tous les paramètres qui lui sont passés. C'est une façon de curryer des fonctions en JavaScript.

Ce code est un exemple de fonctions d'ordre supérieur dans les langages de programmation fonctionnels comme js. Les fonctions Javascript sont traitées comme des objets et peuvent également être transmises et renvoyées.

Une fonction d'ordre supérieur est une fonction qui reçoit une fonction en argument ou renvoie la fonction en sortie.

minusrenvoie une fonction anonyme ( une fonction sans nom défini ) essentiellement comme:

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

Cette fonction, lorsqu'elle est passée à, eightest appelée as, func(8)qui donne ensuite le résultat5

Une autre façon de voir les choses - vous pouvez réécrire cette ligne:

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

Comme:

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