Estoy tratando de escribir una función donde la función devuelve una sub-matriz de los pares clave/valor de nombre y edad en los objetos en una matriz. Debo usar la recursividad para lograrlo, sin embargo, no puedo encontrar una solución que no implique mantener las variables num y arr2 fuera de la función (ya que cuando están dentro, por defecto vuelven a cero/vacío con cada bucle).
Tengo esta prueba bien en la consola, sin embargo, con diferentes matrices estoy devolviendo indefinido
Tampoco estoy seguro de si mi llamada de función recursiva está en el lugar correcto. ¡Cualquier consejo o sugerencia será muy apreciada!
var arr =[ {name:'mike', age:22}, {name:'robert', age:12}, {name:'roger', age:44}, {name:'peter', age:28}, {name:'Ralph', age:67} ] var arr2 = [] var num = 0; function recursive (arr) { if (num < arr.length ) { debugger arr2.push([arr[num].name, arr[num].age]) num++; recursive(arr) } else if (num === arr.length) { return arr2; } }Esta es mi salida deseada:
[[ mike, 22], [ robert, 12], [ roger, 44], [ peter, 28], [ ralph, 67]]Para evitar las variables globales, deberá asegurarse de que su función siempre devuelva el resultado. En el bloque if esto no sucede. Se realiza la llamada recursiva, pero incluso si devolviera algo, ese valor de retorno se ignora y no se devuelve nada después de eso.
También puede evitar la variable num , dando a la llamada recursiva una matriz clasificadora (una porción de ella, excluyendo el valor que se ha procesado).
Así es como puede hacer que funcione con una función recursiva:
function createPairs([first, ...rest]) { if (first === undefined) return []; // base case return [[first.name, first.age], ...createPairs(rest)]; } var arr =[{name:'mike', age:22},{name:'robert', age:12},{name:'roger', age:44},{name:'peter', age:28},{name:'Ralph', age:67}]; console.log(createPairs(arr)); Alternativamente, puede pasar un índice num como segundo argumento y darle un valor predeterminado de 0, de modo que la llamada inicial no tenga que saberlo (lo llamaré i aquí):
function createPairs(arr, i=0) { if (i >= arr.length) return []; // base case return [[arr[i].name, arr[i].age], ...createPairs(arr, i+1)]; } var arr =[{name:'mike', age:22},{name:'robert', age:12},{name:'roger', age:44},{name:'peter', age:28},{name:'Ralph', age:67}]; console.log(createPairs(arr));Otra versión aún, evita la creación de una nueva matriz cada vez que regresa la llamada recursiva. Podemos cambiar el valor actual a la matriz devuelta. O incluso mejor, haga que el índice vaya hacia atrás, de modo que la matriz se construya de izquierda a derecha:
function createPairs(arr, i=arr.length-1) { if (i < 0) return []; // base case const result = createPairs(arr, i-1); result.push([arr[i].name, arr[i].age]); return result; } var arr =[{name:'mike', age:22},{name:'robert', age:12},{name:'roger', age:44},{name:'peter', age:28},{name:'Ralph', age:67}]; console.log(createPairs(arr));Tenga en cuenta que aquí no se recomienda realmente la recursividad. Una solución iterativa es mucho más adecuada para este problema.
function createPairs(arr) { return arr.map(({name, age}) => [name, age]); } var arr =[{name:'mike', age:22},{name:'robert', age:12},{name:'roger', age:44},{name:'peter', age:28},{name:'Ralph', age:67}]; console.log(createPairs(arr));