function countup(n) { if (n < 1) { return []; } else { const countArray = countup(n - 1); countArray.push(n); return countArray; } } console.log(countup(5)); Después de ejecutar el código anterior, devuelve una matriz: [1, 2, 3, 4, 5] , pero push() agrega nuevos valores al final de una matriz, por lo que cuando el valor de n era 5 , debería empujar 5 al final de la matriz y cuando el valor de n obtuvo 4 , debería empujar 4 al final de la matriz como [5,4] .
Entonces, ¿por qué no está regresando [5,4,3,2,1] ? Es difícil entender lo que está sucediendo en este código, probablemente debido a esta recursividad. unshift() (que agrega nuevos valores al comienzo de la matriz) no debería devolver [1,2,3,4,5] y push() [5,4,3,2,1] ¿por qué sucede lo contrario?
Como dijo @Joseph en un comentario, la penúltima llamada de función se enviaría primero a la matriz, luego devolvería esa matriz, donde inmediatamente agrega el siguiente número a la pila de llamadas.
Aquí están los pasos que se están tomando.
La llamada inicial ingresa a sí misma recursivamente n veces, donde la llamada inferior devuelve [] y luego [1] , [1, 2] ... [1, 2, ..., n] hasta el final de la pila de llamadas donde en el La primera llamada a la función finaliza y el programa hace otra cosa.
Para obtener [n, ..., 2, 1] necesita usar el método Array.prototype.unshift() , que toma cualquier tipo primitivo de javascript, es decir, String , Number , Boolean y Symbols , en un formato separado por comas, como countArray.unshift(4, 5) o countArray.unshift(...anotherArray) , y los agrega al comienzo de la matriz.
es decir
let someArr = [3, 2, 1]; someArr.unshift(5, 4); console.log(JSON.stringify(someArr)); // outputs [5, 4, 3, 2, 1]o
let someArr = [1, 2, 3]; let anotherArr = [5, 4] someArr.unshift(...anotherArr); console.log(someArr); // outputs [5, 4, 1, 2, 3]donde la salida de
function countup(n) { if (n < 1) { return []; } else { const countArray = countup(n - 1); countArray.unshift(n); return countArray; } } console.log(countup(5)); será [5, 4, 3, 2, 1] probado con el nodo en Vscode.
Una forma útil de pensar en esto es comenzar imaginando que ya tiene una función que hace lo que quiere para valores más bajos y luego ver cómo escribiría una que funcione para valores más altos. Esa función imaginaria debería ser una caja negra. Todo lo que debemos saber es que hace lo que queremos en el caso de valores más bajos. No nos importan los detalles de su implementación.
Entonces, digamos que teníamos una función imaginaryBlackBox y sabíamos que devolvía los valores countUp correctos que queríamos. Entonces, por ejemplo, sabemos que imaginaryBlackBox (4) devuelve [1, 2, 3, 4] .
Ahora, sabiendo eso, ¿cómo podríamos escribir una función que también funcione para una entrada de 5 ? Qué tal algo como esto:
function countup(n) { if (n < 1) { return []; } else { const countArray = imaginaryBlackBox(n - 1); countArray.push(n); return countArray; } } Nuevamente, no sabemos cómo funciona imaginaryBlackBox . Solo sabemos que devuelve el resultado correcto para valores más bajos de n . Nuestro caso base sigue siendo obvio. Para otro caso, algún n mayor que 0 , llamamos imaginaryBlackBox(n - 1) , y por nuestra suposición básica, sabemos que devolverá [1, 2, 3, ..., (n - 1)] , que almacenar en countArray . Luego empujamos n en esa matriz, para terminar con [1, 2, 3, ..., (n - 1), n] . Devolvemos ese valor y listo.
Ahora aquí está el truco. Conocemos una implementación de imaginaryBlackBox : ¡es la función que estamos escribiendo! Así que simplemente podemos reemplazarlo con countUp y saber que funcionará.
function countup(n) { if (n < 1) { return []; } else { const countArray = countUp(n - 1); countArray.push(n); return countArray; } }Esto requirió algunas suposiciones, y son importantes para todas las funciones recursivas:
Hay al menos un caso base cuyo valor podemos calcular sin ninguna llamada recursiva. Aquí, cuando n es < 1 , simplemente devolvemos [] .
Para otros casos, podemos desglosar nuestro problema en uno o más casos recursivos, donde la entrada está de alguna manera clara y medible más cerca de un caso base, de modo que los pasos subsiguientes lleguen a un caso base en un número finito de llamadas. Aquí reducimos n en 1 en cada paso, por lo que eventualmente estará por debajo 1 .
Nuestra función es efectivamente pura : sus salidas dependen sólo de sus entradas. Eso significa que no podemos contar con cambiar una variable global o leer de una que podría cambiarse en otro lugar. Tenga en cuenta que aquí uso el calificador "efectivamente"; no importa si esta función tiene efectos secundarios observables, como iniciar sesión en la consola, siempre que su salida dependa solo de su entrada.
Cada vez que tiene esas condiciones, tiene las características de una buena función recursiva.