Mirando el libro SICP y la programación funcional JS, creé dos funciones recursivas. Mi expectativa era que ambos generaran un error de desbordamiento de pila. Pero es solo la función sumAll() la que generó el error. Vea a continuación el código para ambas funciones sumAll() y factorial():
Como era de esperar, la función sumAll() generó un error de desbordamiento de pila
function sumAll(n, i = 0, result = 0) { return (i > n) ? result : sumAll(n, i + 1, i + result); } console.log(sumAll(10000));La función factorial() a continuación no generó un error de desbordamiento de pila:
function factorial(n){ return (n == 1) ? 1 : n* factorial((n-1)) } console.log(factorial(10000))Mi pregunta es por qué la función factorial () no genera un desbordamiento de pila y funciona perfectamente en nodeJS, mientras que sumAll () también lo generó en nodeJS
El número de variables locales (es decir, la memoria de variables locales) también se considera en el tamaño de la pila de llamadas.
function computeMaxCallStackFrames(a, b, c, d) { try { return 1 + computeMaxCallStackFrames(a + 1, b + 1, c + 2, d + 3); } catch (e) { // Call stack overflow // console.log(e); return 1; } } var stackFrames = computeMaxCallStackFrames(1, 4, 6, 2); console.log(stackFrames);intente aumentar el no. de parámetros, verá la disminución en el número de llamadas de recursividad / marcos de pila de llamadas.
function computeMaxCallStackFrames(a, b, c, d, e) { try { return 1 + computeMaxCallStackFrames(a + 1, b + 1, c + 2, d + 3, e-2); } catch (e) { // Call stack overflow // console.log(e); return 1; } } var stackFrames = computeMaxCallStackFrames(1, 4, 6, 2, 9); console.log(stackFrames);con cero variables locales.
function computeMaxCallStackFrames() { try { return 1 + computeMaxCallStackFrames(); } catch (e) { // Call stack overflow // console.log(e); return 1; } } var stackFrames = computeMaxCallStackFrames(); console.log(stackFrames);Entonces, podemos ver claramente que el número de variables locales (es decir, la memoria de las variables locales) también se considera en el tamaño de la pila de llamadas. Si hay muchas variables locales entonces el no. de llamadas recursivas será menor.
Editar: Y todos sabemos que el tamaño de la pila variará de un navegador a otro. Por lo tanto, el resultado no será el mismo en diferentes navegadores, pero debería ser consistente en el mismo navegador incluso si lo ejecutamos varias veces.
Espero que todo tenga sentido ahora.
Di la siguiente respuesta por error, me confundí sobre qué función estaba lanzando la excepción. Por favor, no hagas caso.
Su primera función es capaz de aprovechar la optimización de llamada final, mientras que su segunda función no lo es (o lo es, pero quizás no de una manera implementada en el lenguaje node.js).
Considere esto: la condición habitual de su primera función es que termina en return sumAll(n, i + 1, i + result) , lo que significa que una vez que obtiene algo para devolver, puede devolverlo.
Sin embargo, su segunda función termina en return n* factorial((n-1)) , lo que significa que una vez que obtiene algo para devolver, tiene que hacer OTRA operación en él (multiplicarlo por n) antes de poder devolver el resultado.
Creo que el intérprete de node.js no puede optimizar la segunda función porque requiere que se realice otra operación antes de la devolución.
Tenga en cuenta: no estoy seguro de que esta sea la respuesta, y sospecho que es posible que node.js no admita optimizaciones de llamadas de cola de ningún tipo. Sin embargo, esta es mi teoría sobre por qué una función puede fallar de esa manera y la otra no.