Quiero determinar si un elemento se debe enlazar y empujar, o empujar directamente a una matriz.
Para ello, he creado el siguiente código:
interface Item { prop1: string; prop2: string; prop3: string[]; } Para prop1 , prop2 , prop3 Necesito sus datos en una sola matriz de cadenas para cada propiedad. Entonces quiero obtener el puntero de función correspondiente:
const items = [...] as Item[]; const collectProperties = ["prop1", "prop2", "prop3"]; // Contains the function pointers for every prop in collectProperties const appendOperations = [] as ((array: string[], element: any) => void)[]; // Extract function pointers for each prop-type collectProperties.forEach((element, index) => { appendOperations.push( Array.isArray(items[0][element as keyof Item]) ? (array: string[], element: any) => element.forEach((value) => array.push(String(value))); : (array: string[], element: any) => array.push(String(element)) ); }); // Appending items based on its type items.forEach((item) => { appendOperations.forEach((fn, index) => { fn( // ... some array, // ... some value ); }); });Siento que debería haber una forma más compacta y elegante de hacer esto. Sé que esto también se puede hacer en el bucle mismo, pero esto significa que habrá una verificación de si en cada propiedad de cada elemento, lo cual no se desea cuando se procesan grandes cantidades de datos. Se agradece la ayuda.
Hay un par de cosas que puede hacer para reforzar el primer bit:
collectProperties una matriz de keyof Item en lugar de una matriz de cadenas, para que no tenga que usar una aserción de tipo más adelantemap para construir appendProperties en lugar de crear la matriz y empujarla, ya que es una operación de uno a uno; esto también le permite inferir su tipo a partir del tipo de retorno del map // *** Use the type on the array so you don't have to use a type assertion later const collectProperties: (keyof Item)[] = ["prop1", "prop2", "prop3"]; // Contains the function pointers for every prop in collectProperties // *** `map` is a bit more idiomatic and helps a bit with setting types const appendOperations = collectProperties.map(propName => { // *** Avoiding using `items` for this check since there's no need to make this function // dependent on `items` return propName === "prop3" ? (array: string[], element: any) => element.forEach((value: any) => array.push(String(value))) : (array: string[], element: any) => array.push(String(element)); }); // Appending items based on its type // *** `forEach` is fine, but you could also avoid making functions using `for-of` for (const item of items) { for (const fn of appendOperations) { fn( // ... some array, // ... some value ); } } Para el bucle al final, no pude tener una idea suficiente de lo que debería estar haciendo, pero podría considerar for-of en lugar de forEach solo para evitar crear funciones innecesarias, etc.