Sono uno sviluppatore di front-end Sr., codifica in Babel ES6. Parte della nostra app effettua una chiamata API e in base al modello di dati che riceviamo dalla chiamata API, alcuni moduli devono essere compilati.
Tali moduli sono memorizzati in un elenco doppiamente collegato (se il back-end dice che alcuni dei dati non sono validi, possiamo rapidamente riportare l'utente sull'unica pagina in cui hanno incasinato e poi riportarli sulla destinazione, semplicemente modificando il elenco.)
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 pagina diversi, ma questo ti darà un esempio.
È così che, a mio avviso, un programmatore principiante lo gestirà.
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ù verificabile, ho preso tutte quelle istruzioni if e le ho separate, le funzioni autonome e poi le mappa su di esse.
Ora, testabile è una cosa, ma così è 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 possono essere testati in isolamento. MA sto pensando: se dovessi leggerlo come sviluppatore junior, inutilizzato a concetti come l'utilizzo di funzioni Identity, curry o dichiarazioni ternarie, sarei anche in grado di capire cosa sta facendo quest'ultima soluzione? È meglio fare le cose nel modo "sbagliato, più facile" a volte?
Babel ES6