¿Se puede simplificar el siguiente código para mejorar la legibilidad, la simplicidad o de alguna otra manera? Específicamente, ¿se puede escribir esto sin verificar si no está undefined en cada línea?
Estas declaraciones ok son solo algunos de los muchos filtros que se verifican, por lo que esta lista es grande e ingobernable.
const aOk = data?.a ? data.a.includes(a) : true const bOk = data?.b ? data.b <= b : true const cOk = data?.c ? data.c >= c : true const dOk = data?.d ? data.d === d : true const eOk = data?.e ? data.e === e.toString() : true if ( aOk && bOk && cOk && dOk && eOk ) { return true } return falsePodrías crear una función auxiliar como
const fn = (data) = (key, op, value) => data[key] ? op(data[key], value) : true Luego puede definir un conjunto de funciones que hacen las comparaciones que necesita. Esto podría eliminar la repetición y mejorar la capacidad de mantenimiento. Es posible que pueda usar algo como operations[key](this[key], data[key]) si sus variables en datos y el alcance coinciden.
const comp = fn(data) const aOk = comp('a', myIncludes, a)Si la forma de validación no cambia con frecuencia, no veo ningún problema con su función. Como mencionó otro cartel, en su lugar puede crear una lista de funciones. Algo como esto:
type TData = { a: number[]; b: number; c: number; d: number; e: string; }; const data = { a: [3], b: 4, c: 4, d: 1, e: "9", }; const validators: (data:TData, v: { [k in keyof TData]: number }) => { [k in keyof TData]: () => boolean; } = (v) => ({ a: () => data.a.includes(va), b: () => data.b <= vb, c: () => data.c >= vc, d: () => data.d === vd, e: () => data.e === vetoString(), }); const all = () => { for (const k of Object.values(validators(data, otherData))) { if (!k()) return false; } return true; };Esto parece claro y es legible para mí:
const allOk = Boolean( data?.a ? data.a.includes(a) : true && data?.b ? data.b <= b : true && data?.c ? data.c >= c : true && data?.d ? data.d === d : true && data?.e ? data.e === e.toString() : true );