Doubt about incrementing a variable from a conditional before calling a function - Javascript

Well, I'm going to explain the execution sequence of your functions, I hope this helps you (the manual debug can be found in the code comments at the end, please read them):

let contar = 0;

persistence = (param) => {
    contar = 0;

    if (param !== undefined && param > 0) {
        let num = param;

        let numString = num.toString();

        let arreglo = numString.split("");
        let arregloNum = arreglo.map(Number);

        if (arregloNum.length >= 2) {
            let calc = arregloNum.reduce((p, c) => p * c);
            persistence(calc);
            contar++;
            console.log(calc);
            return contar;
        } else {
            return 0;
        }
    } else {
        return false;
    }
};

console.log(persistence(39));
// Ejecución manual.
// entramos a persistence 39 ->
// contar = 0, num = 39, numString = '39', arreglo = ['3','9'], arregloNum = [3,9], calc = 27, llamamos a persistence(27) (vamos a movernos a esta función)

// entramos a persistence 27 ->
// contar = 0, num = 27, numString = '27', arreglo = ['2','7'], arregloNum = [2,7], calc = 14, llamamos a persistence(14) (vamos a movernos a esta función)

// entramos a persistence 14 ->
// contar = 0, num = 14, numString = '14', arreglo = ['1','4'], arregloNum = [1,4], calc = 4, llamamos a persistence(4) (vamos a movernos a esta función)

// entramos a persistence 4 ->
// contar = 0 (OJO EN ESTA PARTE acá devuelves contar a 0 ANTES de haberla incrementado) retornamos 0 ya que no cumple las condiciones, nos regresamos a la función persistence(14) que nos invoco

// regresamos persistence 14 ->
// contar = 1, console.log(4) retornamos  contar (contar = 1 ult incremento), y volvemos a la función que nos invoco persistence 27.

// regresamos persistence 27 ->
// contar = 2, console.log(14) retornamos contar (contar = 2 ult incremento), y volvemos a la función que nos invoco persistence 39.

// regresamos persistence 39 ->
// contar = 3, console.log(27) retornamos contar (contar = 3 ult incremento), y volvemos a la linea de código console.log(persistence(39));.

// como persistence(39) retorno 3 entonces en consola muestra 3

We will now run your second algorithm manually as follows.

let contar = 0;

persistence = (param) => {
    contar = 0;

    if (param !== undefined && param > 0) {
        let num = param;

        let numString = num.toString();

        let arreglo = numString.split("");
        let arregloNum = arreglo.map(Number);

        if (arregloNum.length >= 2) {
            let calc = arregloNum.reduce((p, c) => p * c);
            contar++;
            persistence(calc);
            console.log(calc);
            return contar;
        } else {
            return 0;
        }
    } else {
        return false;
    }
};

console.log(persistence(39));
// Ejecución manual.
// entramos a persistence 39 ->
// contar = 0, num = 39, numString = '39', arreglo = ['3','9'], arregloNum = [3,9], calc = 27, contar = 1, llamamos a persistence(27) (vamos a movernos a esta función)

// entramos a persistence 27 ->
// contar = 0, num = 27, numString = '27', arreglo = ['2','7'], arregloNum = [2,7], calc = 14, contar = 1, llamamos a persistence(14) (vamos a movernos a esta función)

// entramos a persistence 14 ->
// contar = 0, num = 14, numString = '14', arreglo = ['1','4'], arregloNum = [1,4], calc = 4, contar = 1, llamamos a persistence(4) (vamos a movernos a esta función)

// entramos a persistence 4 ->
// contar = 0 (OJO EN ESTA PARTE acá devuelves contar a 0 DESPUÉS de haberla incrementado anteriormente) retornamos 0 ya que no cumple las condiciones, nos regresamos a la función persistence(14) que nos invoco

// regresamos persistence 14 ->
// console.log(4) retornamos contar (= 0) (que persistence(4) lo dejo en 0), y volvemos a la función que nos invoco persistence 27.

// regresamos persistence 27 ->
// console.log(14) retornamos contar (= 0) que persistence(4) lo dejo en 0), y volvemos a la función que nos invoco persistence 39.

// regresamos persistence 39 ->
// console.log(27) retornamos contar (= 0) que persistence(4) lo dejo en 0), y volvemos a la linea de código console.log(persistence(39));.

// como persistence(39) retorno 0 entonces en consola muestra 0

So what happened? well the only thing you are doing wrong is handling the global variable contar.
Now so that you declare it contaras a global variable if you are going to use it as a local variable (since you always initialize it when entering the function pesistence) now if you want to keep the appropriate value of the counter, it is best to send it as a parameter of the function.
You have to be careful when using global variables , you are expecting a certain value of that variablebut that has already been modified by another function after the main function has already made its changes so you already have a "garbage" value in that variable, I think this can enter into the issue of semaphores when accessing the same shared resource, in In this case, your shared resource is the variable contar , mmmmm, well, maybe the topic is something else, but I hope I have helped you clarify your doubt, good luck.

Then your function could look like this if you decide to pass the counter as part of a parameter, where by default we set the counter to 0 when we don't send the parameter, so we continue calling persistence(39)will give you a counter initialized to 0 ( contar) by default as the second parameter, which we will then be sent to subsequent function callspersistence

persistence = (param, contar = 0) => {
    if (param !== undefined && param > 0) {
        let num = param;

        let numString = num.toString();

        let arreglo = numString.split("");
        let arregloNum = arreglo.map(Number);
        if (arregloNum.length >= 2) {
            let calc = arregloNum.reduce((p, c) => p * c);
            contar = persistence(calc, contar + 1);
            console.log(calc);
        }
        return contar;
    } else {
        return contar;
    }
};
console.log(39) // imprime 3 finalmente