Soy un desarrollador senior de front-end, codificando en Babel ES6. Parte de nuestra aplicación realiza una llamada a la API y, según el modelo de datos que recibimos de la llamada a la API, es necesario completar ciertos formularios.
Esos formularios se almacenan en una lista doblemente vinculada (si el back-end dice que algunos de los datos no son válidos, podemos hacer que el usuario regrese rápidamente a la página en la que se equivocaron y luego volver al objetivo, simplemente modificando el lista.)
De todos modos, hay un montón de funciones que se utilizan para agregar páginas, y me pregunto si soy demasiado inteligente. Esta es solo una descripción básica: el algoritmo real es mucho más complejo, con toneladas de páginas y tipos de página diferentes, pero esto le dará un ejemplo.
Así es como, creo, un programador novato lo manejaría.
export const addPages = (apiData) => {
let pagesList = new PagesList();
if(apiData.pages.foo){
pagesList.add('foo', apiData.pages.foo){
}
if (apiData.pages.arrayOfBars){
let bars = apiData.pages.arrayOfBars;
bars.forEach((bar) => {
pagesList.add(bar.name, bar.data);
})
}
if (apiData.pages.customBazes) {
let bazes = apiData.pages.customBazes;
bazes.forEach((baz) => {
pagesList.add(customBazParser(baz));
})
}
return pagesList;
}
Ahora, para ser más comprobable, tomé todas esas declaraciones if y las hice separadas, funciones independientes, y luego las mapeo.
Ahora, comprobable es una cosa, pero también es legible y me pregunto si estoy haciendo las cosas menos legibles aquí.
// file: '../util/functor.js'
export const Identity = (x) => ({
value: x,
map: (f) => Identity(f(x)),
})
// file 'addPages.js'
import { Identity } from '../util/functor';
export const parseFoo = (data) => (list) => {
list.add('foo', data);
}
export const parseBar = (data) => (list) => {
data.forEach((bar) => {
list.add(bar.name, bar.data)
});
return list;
}
export const parseBaz = (data) => (list) => {
data.forEach((baz) => {
list.add(customBazParser(baz));
})
return list;
}
export const addPages = (apiData) => {
let pagesList = new PagesList();
let { foo, arrayOfBars: bars, customBazes: bazes } = apiData.pages;
let pages = Identity(pagesList);
return pages.map(foo ? parseFoo(foo) : x => x)
.map(bars ? parseBar(bars) : x => x)
.map(bazes ? parseBaz(bazes) : x => x)
.value
}
Aquí está mi preocupación. Para mí, el fondo está más organizado. El código en sí se divide en fragmentos más pequeños que se pueden probar de forma aislada. PERO estoy pensando: si tuviera que leer eso como desarrollador junior, sin estar acostumbrado a conceptos como el uso de functores de identidad, currículum o declaraciones ternarias, ¿podría incluso entender lo que está haciendo la última solución? ¿Es mejor hacer las cosas de la manera "incorrecta y más fácil" a veces?
Babel ES6