Solução Codewars - Funções agindo entre si aninhadas [fechado]

Eu estava procurando uma solução para um quebra-cabeça sobre códigos de guerra e não entendo por que isso funciona. Como o minus () está funcionando?

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

É um pouco complicado. :-)

console.log(eight(minus(three()))); é executado de dentro para fora, então vamos segui-lo:

• three()- chama makeNum(3, undefined)e retorna o que retorna. makeNum(3, undefined)retorna 3, então esse é o valor de retorno.
• minus(3)- chama minus, passando 3como right. minusretorna uma nova função que fecha right.
• eight(...)- chama makeNum(8, fnFromMinus)onde fnFromMinusestá a função retornada por minus(3). makeNum(8, fnFromMinus)faz fnFromMinus, passando 8como left. fnFromMinusretorna o resultado de left - right(lembre- rightse 3, fnFromMinusfechado).

Desde que 8 - 3é 5, o resultado final é 5, que console.logretorna.

Aqui está uma versão instrumentada:

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

Na verdade, não é tão complicado se você trabalhar com isso passo a passo. Vamos trabalhar de dentro para fora. A ligar:

three()

sem um parâmetro significa que você está passando um valor indefinido como func. Portanto, é o mesmo que dizer:

makeNum(3, undefined)

Quando o makeNum vê que func é indefinida, ele retorna num, que é 3.

Então, reduzimos isso para:

eight(minus(3))

Agora vamos ver como

minus(3)

avalia. menos vê que o parâmetro que você forneceu é 3, então ele retorna uma função que pode aceitar um parâmetro "esquerdo" e subtrair os 3 que já fornecemos a ele. NÃO é executado. Ele fica lá, esperando para ser chamado com um parâmetro "left" para que ele possa subtrair 3 dele.

Então, reduzimos isso para:

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

Agora vamos ver como isso avalia. oito é chamado com o parâmetro func sendo esta função:

function(left){
    return left - 3;
}

Em seguida, passa 8 e essa função para makeNum quando diz:

makeNum(8, func)

makeNum vê que func foi fornecida (e, portanto, não é indefinida) e retorna func (num) de volta à função oito, que é o mesmo que passar:

8 - 3

de volta à função oito. A função oito recebe esse valor e depois o retorna. Então, reduzimos isso para:

5

que é registrado no console.

minusretorna uma nova função para cada chamada com os parâmetros passados ​​para ela sendo capturados. Quando a função retornada é chamada, ela pode fazer referência aos parâmetros passados ​​quando chamados, além de quaisquer parâmetros passados ​​para ela. Esta é uma maneira de curry funções em JavaScript.

Este código é um exemplo de funções de ordem superior em linguagens de programação funcional como js. As funções Javascript são tratadas como objetos e também podem ser passadas e retornadas.

Uma função de ordem superior é uma função que recebe uma função como argumento ou retorna a função como saída.

minusestá retornando uma função anônima ( uma função sem nome definido ) basicamente como:

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

Essa função, quando passada para, eighté chamada como a func(8)qual, então, dá resultado como5

Outra maneira de ver isso - você pode reescrever esta linha:

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

Como:

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