Sono uno sviluppatore di front-end Sr., che codifica in Babel ES6. Parte della nostra app effettua una chiamata API e, in base al modello di dati che riusciamo a recuperare dalla chiamata API, alcuni moduli devono essere compilati.
Questi moduli sono memorizzati in una lista doppiamente collegata (se il back-end dice che alcuni dati non sono validi, possiamo riportare rapidamente l'utente alla pagina che hanno incasinato e poi riportarli sul target, semplicemente modificando la lista.)
Ad ogni modo, ci sono un sacco di funzioni usate per aggiungere pagine, e mi chiedo se sono troppo intelligente. Questa è solo una panoramica di base: l'algoritmo attuale è molto più complesso, con tonnellate di pagine e tipi di pagine diversi, ma questo ti fornirà un esempio.
Questo è il modo in cui, penso, un programmatore principiante potrebbe gestirlo.
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;
}
Ora, per essere più testabile, ho preso tutte quelle dichiarazioni if e le ho rese separate, funzioni autonome, e quindi ho mappato su di esse.
Ora, testabile è una cosa, ma lo è anche leggibile e mi chiedo se sto rendendo le cose meno leggibili qui.
// 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
}
Ecco la mia preoccupazione. Per me il fondo è più organizzato. Il codice stesso è suddiviso in blocchi più piccoli che sono testabili separatamente. Ma sto pensando: se dovessi leggerlo come uno sviluppatore junior, non abituato a concetti come l'utilizzo di funtori Identity, curry o dichiarazioni ternarie, sarei in grado di capire anche cosa sta facendo la seconda soluzione? È meglio fare cose "sbagliate, più facili" a volte?