计算一个函数在JS中递归调用的次数

Question

I have got a homework where i am supposed to write a pseudo random number generator in JavaScript. This is the code bit i wrote

var k = 0;

var slump = function(n, k) {
  if (k < 10) {
  console.log("stop");
  }
  else {
    k++;
    console.log((5*n + 1) % 8);
    return slump((5*n + 1) % 8, k);
  }
};

slump(0);

k is supposed to hold the amount of times the function has been called. But instead of just running the function ten times, it just keeps running. Is there any way to get around this?

Answer 1

You have two subtly different options here, depending on how idiomatic and clever you'd like to get.

The classic implementation, with a slight tweak as JS doesn't support default parameters, would be to use something like:

var finalDepth = 0;
function slump(n, k) {
    k = k || 0; // Set to 0 if falsy (null, undef, or 0)
    if (logic) {
        finalDepth = k; // Record the depth on the last call
    } else {
        return slump((5*n + 1) % 8, k + 1);
    }
}

This will very simply record the deepest the stack has been, and hang onto the value until the next call.

If you want to be slightly more JS-like, you can use closure to keep track of the calls:

function createGenerator() {
  var counter = 0;
  return {
    slump: function (n) {
      ++counter; // Closure captures counter, counter persists between slump calls but is unique for each createGenerator
      if (logic) {
        // stop
      } else {
        return slump((5*n + 1) % 8, k + 1);
      }
    },
    getCounter: function () { return counter; }
  }
}

You may be able to use some of the features from ES6 iterators (or generators) to make this more clever.

Answer 2

Whenever you write a recursive function, you need to make sure that:

1. There's a base case (in your case, when the console.log statement runs)
2. The function proceeds towards the base case, and
3. The function works, assuming the success of the recursive call.

You're running into a problem with the second part; you increment k, but that doesn't bring you any closer to the part where k < 10 . In short, you probably want to switch that test around and make sure you're initially calling the function with the right number of arguments. (Aadit M Shah pointed out that you're calling it with one, and it expects two, meaning that it ends up undefined when you call it.)

Either way, iteration would definitely work better here:

var n = 0;
for(var i = 0; i < 10; i++) {
    n = (5 * n + 1) % 8;
    console.log(n);
}

Answer 3

The function parameter k is uninitialized, therefore not a number. this means in particular that the termination test k < 10 fails as well as the k++ statement doesn't change k ' s value. so slump gets always called with the same value for parameter k and the recursion never stops.