Estoy tratando de codificar una función recursiva pero estoy luchando y esperaba que alguien pudiera ayudarme a empujarme en la dirección correcta. Creo que esto se consideraría "Recursión de árbol".
Este es un ejemplo trivial para ilustrar los datos y lo que estoy tratando de hacer. Obviamente, los datos reales son más complejos...
Básicamente, empiezo con una matriz que contiene una sola matriz de objetos como la siguiente, donde prop2 en cualquiera de los objetos puede ser una cadena válida o una cadena vacía...
[ [ { prop1: "abc", prop2: "" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ] ]Mi algoritmo necesita mirar la matriz de arriba e iterar sobre los objetos. Tan pronto como encuentra un objeto con una cadena vacía en prop2, necesita clonar la matriz tres veces y reemplazar la cadena vacía en ese objeto (y solo ese objeto) con tres valores diferentes (uno/dos/tres) como este. ..
[ [ { prop1: "abc", prop2: "one" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ], [ { prop1: "abc", prop2: "two" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ], [ { prop1: "abc", prop2: "three" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ] ]Luego, el algoritmo comienza de nuevo, excepto que la entrada es esta nueva matriz que contiene tres matrices.
Entonces, en la segunda iteración, cada una de las tres matrices se clonará tres veces y la cadena vacía se reemplazará de la misma manera.
El resultado final de este ejemplo simple sería una matriz de nueve matrices.
Si la matriz tuviera más objetos con valores prop2 vacíos, habría más iteraciones.
Básicamente, estoy tomando una matriz de objetos donde algunos de los accesorios son cadenas vacías y "expandiendo" ese valor de accesorio particular a cada permutación de "uno"/"dos"/"tres"
Sé que este es un problema ideal para la recursividad, pero tengo problemas para descifrar el código.
Creo que el "caso base" probablemente sería donde tengo una matriz de objetos y ninguno de los objetos tiene propiedades con cadenas vacías. Ese caso devolvería esa matriz.
No sé cómo se vería el otro caso aparte de llamar a la misma función tres veces con las tres variantes recién creadas. Tampoco sé qué debería devolver este caso.
Tengo problemas para encontrar ejemplos de referencia en línea que sean similares a lo que estoy tratando de hacer.
EDITAR : Mirando las respuestas recursivas, aunque todas funcionan, es obvio que una solución recursiva no fue tan sencilla como pensé que sería. La respuesta no recursiva es en realidad la mejor respuesta.
Sugiero esta solución no reclusiva que cumple con sus requisitos de resultados finales:
const myTree = [ [ { prop1: "abc", prop2: "" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ] ]; let nodesWithEmptyStrings = myTree.filter(n=> !!n.find(l=> l.prop2==="")); while(nodesWithEmptyStrings.length > 0) { nodesWithEmptyStrings.forEach(n => { const firstEmptyStringLeaveIndex = n.findIndex(l=> l.prop2===""); n[firstEmptyStringLeaveIndex].prop2 = "one"; const copy1 = JSON.parse(JSON.stringify(n)); copy1[firstEmptyStringLeaveIndex].prop2 = "two"; myTree.push(copy1); const copy2 = JSON.parse(JSON.stringify(n)); copy2[firstEmptyStringLeaveIndex].prop2 = "three"; myTree.push(copy2); }); nodesWithEmptyStrings = myTree.filter(n=> !!n.find(l=> l.prop2==="")); } document.getElementById('result').innerText = JSON.stringify(myTree, null, 2); <pre id="result"></pre>Sí, puedes hacer esto usando recursividad. El principio básico es modificar la matriz y luego verificar si necesita modificarse un poco más, si ese es el caso, devolver el resultado de llamar a la función con la nueva matriz.
Aquí hay un ejemplo:
const fillers = ['one', 'two', 'three']; const propToCheck = 'prop2'; function recursion(arr) { const mod = arr.reduce((a, c) => { const found = c.find(v => !v[propToCheck]); if (found) { const tmp = c.filter(v => v !== found); return [...a, ...fillers.map(filler => [...tmp, { ...found, [propToCheck]: filler }])]; } return [...a, c]; }, []); const notDone = mod.some(v => v.some(o => !o[propToCheck])) if (notDone) { return recursion(mod); } return mod; } const result = recursion([ [ { prop1: "abc", prop2: "" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ] ]); console.log(result);No sé si este es un problema que intuitivamente me gustaría resolver con recursividad, pero esta función general que toma tanto sustituciones como qué clave verificar la cadena vacía como argumentos funcionaría (usando la sintaxis y la funcionalidad es6+ con mucho de desestructuración):
const substitute = (data, index, keyToCheck, substitutes) => { const indexOfObjectWithEmptyKeyToCheck = data[index].findIndex(obj => obj[keyToCheck] === "") if(indexOfObjectWithEmptyKeyToCheck === -1) { if(index === data.length - 1) return data else return substitute(data, index + 1, keyToCheck, substitutes) } else { return substitute( [ ...data.slice(0, index), ...(substitutes.map( substitute => [ ...data[index].slice(0, indexOfObjectWithEmptyKeyToCheck), { ...data[index][indexOfObjectWithEmptyKeyToCheck], [keyToCheck]: substitute }, ...data[index].slice(indexOfObjectWithEmptyKeyToCheck + 1) ] )), ...data.slice(index + 1) ], index, keyToCheck, substitutes ) } } const SUBSTITUTES = ["one", "two", "three"]; const result = substitute( [ [ { prop1: "abc", prop2: "" }, { prop1: "def", prop2: "one" }, { prop1: "ghi", prop2: "" } ] ], 0, "prop2", SUBSTITUTES ) console.log(result) console.log("Size of result: " + result.length)Básicamente, iteramos a través de la matriz, solo incrementamos el índice si la matriz actual no tiene ningún objeto donde la clave para verificar es la cadena vacía; de lo contrario, hacemos reemplazos según sea necesario y recursimos en el mismo índice. El caso base es cuando la clave para verificar no es la cadena vacía y el índice es el último índice de la matriz de entrada.
La parte de Typescript se la dejé como ejercicio, ya que no creo que escribir los datos de entrada sea el gran problema aquí.