Soy un desarrollador principal Sr., que codifica en Babel ES6. Parte de nuestra aplicación hace una llamada a la API y, según el modelo de datos que recibimos de la llamada a la API, se deben completar ciertos formularios.
Esos formularios se almacenan en una lista con doble enlace (si el back-end dice que algunos de los datos no son válidos, podemos hacer que el usuario vuelva rápidamente a la única página en la que se equivocó y luego volver a ponerlo en el objetivo, simplemente modificando la 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áginas diferentes, pero esto le dará un ejemplo.
Así es como creo que lo manejaría un programador novato.
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 verificable, tomé todas esas declaraciones if y las hice funciones independientes, independientes, y luego las mapeo sobre ellas.
Ahora, verificable 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 yo el fondo está más organizado. El código en sí se divide en partes más pequeñas que se pueden probar de forma aislada. PERO estoy pensando: si tuviera que leer eso como un desarrollador junior, no acostumbrado a conceptos como el uso de los funtores de Identidad, el curry o las declaraciones ternarias, ¿sería capaz de entender qué hace esta última solución? ¿Es mejor hacer las cosas de la manera "incorrecta, más fácil" a veces?