Your code: myFunction() will return void/undefined on first call, it is not a recursive approach.

Following example is a recursive approach. A recursive function usually receive an argument to be processed and return a final value that bubbles(returned) up to the first caller.

function myfunction(b){
  b--;
  if(b<3) return b;
  else return myFunction(b);
}

When you call a recursive function, you should prepare a test for an escape. Otherwise you might end up in an infinite loop.

Example of an infinite recursive

function badFunction(){
return badFunction();
}
// DON'T call badFunction()

Recursive Example

var b = 70;
var safety = 1000;

function myfunction(local_b) {
  if(safety<0) return;
  safety--;

  // main task
  local_b--;
  
  if (local_b < 3) {
    return local_b;
  }

  return myfunction(local_b);

}
var value = myfunction(b); // when b = 70, value = 2
console.log(value);
document.getElementById('value').innerHTML = value;

<span id="value">_</span>

You have to return all the way up the stack:

func2.call(this, sWord);

should be:

return func2.call(this, sWord);

You forgot to return a result from the point, where you entering recusrion.

var users = [23, 23, 23, 23, 23, 23, 23, 23, 23, 23];
console.log(Check(users, 0, 20));

function Check(ids, counter, limit){
    ids.push(23);

    // Recursion
    if (counter+1 < limit){
        return Check(ids, counter+1, limit); // return here!
    }
    else {
        console.log(ids);
        return ids;
    }
} 

But return value seems useless, cause' your function altering initial array as well.

A return statement passes a value back to the immediate caller of the current function's call-frame. In the case of recursion, this immediate caller can be another invocation of that same function.

In most languages, if you don't use the return value of a function you called (recursively or not), either that return value gets discarded or it is a diagnosable error. There are some languages where the return value of the last function call gets automatically re-used as the return value of the current function invocation, but they don't differentiate between normal and recursive function calls.

Assuming unused return values get silently discarded, if you had written the code like this:

list *search_list(list *l, item_type x) {
  if (l == NULL) return(NULL);
  if (l->item == x)
    return(l);
  else
    search_list(l->next, x); // no return!
}

then search_list would only return a defined value for an empty list (NULL) or if the first item matches the value you are searching for. As soon as the function goes into the recursive call, you don't know what the result will be, because the result of the recursive call gets discarded.

Additionally, you promise to return a value from your function, but you have a path (the recursive one) where you don't specify what value to return. Depending on the language you use, this usually results either in a mandatory diagnostic or in undefined behaviour (which is shorthand for: anything can happen and that can change at any time without notice. Don't hold anyone but yourself liable if it screws up your most important presentation). There are some situations where the missing return value might appear to work, but that might change the next time you run the program (with or without recompilation).

What you have is a recursive function with two exit conditions, one for a found result, where the start and target value is equal, this returns the history and one where the start value is greater than the target value, which returns null for not found result.

The recursive machanis is to branch the calling of the function in two direction, one with adding fice, the other one by multiplying the value by three.

The branching takes place with a logical OR ||, which means if the first branch returns a truthy result, this result is taken and the other branch is never called. If the first branch returns null, a falsy value, the second branch is called.

What you finally get is a tree with branches and tests.

      1          level 0
    /   \
  2       5      level 1
 / \     / \
3   4   6   7    level 2

That means, with the first call, it starts with 1 and goes if necessary to 2 and 3 and so on.

To get an idea, you could add a level variable to a console.log and watch what is going in every level.

level, start, history                         action
--------------------------------------------  ----------------
0 1 1                                         check next level
    1 6 (1 + 5)                               check next level
        2 11 ((1 + 5)  + 5)                   check next level
            3 16 (((1 + 5)  + 5)  + 5)        null
            3 33 (((1 + 5)  + 5)  * 3)        null
        2 18 ((1 + 5)  * 3)                   null
    1 3 (1 * 3)                               check next level
        2 8 ((1 * 3)  + 5)                    check next level
            3 13 (((1 * 3)  + 5)  + 5)        found

(((1 * 3)  + 5)  + 5)                         result

function findSolution(target) {

    function find(start, history, level) {
        level = level || 0;
        console.log(level, start, history);
        if (start == target) return history;            // exit condition 1 (found)
        if (start > target) return null;                // exit condition 2 (not found)
        return find(start + 5, "(" + history + " + 5) ", level + 1) ||
               find(start * 3, "(" + history + " * 3) ", level + 1);
    }

    return find(1, "1");
}
console.log(findSolution(13));

.as-console-wrapper { max-height: 100% !important; top: 0; }

You're not returning your recursive call. If you hit that branch, you never hit a return statement.