Je suis un développeur Sr front-end, codant dans Babel ES6. Une partie de notre application effectue un appel API et, en fonction du modèle de données que nous avons renvoyé, certains formulaires doivent être remplis.
Ces formulaires sont stockés dans une liste à double lien (si le back-end indique que certaines données sont invalides, nous pouvons rapidement ramener l'utilisateur à la page qu'il a foirée, puis le ramener sur la cible, simplement en modifiant le liste.)
Quoi qu'il en soit, de nombreuses fonctions sont utilisées pour ajouter des pages, et je me demande si je ne suis pas trop intelligent. Ceci est juste une vue d'ensemble - l'algorithme lui-même est beaucoup plus complexe, avec des tonnes de pages et de types de page différents, mais ceci vous donnera un exemple.
C'est comment, je pense, un programmeur novice le gérerait.
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;
}
Maintenant, afin d’être plus testable, j’ai pris toutes ces déclarations if et les ai séparées, en fonctions autonomes, puis mappées sur elles.
Maintenant, le testable est une chose, mais il en est de même pour la lecture et je me demande si je le fais moins ici.
// 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
}
Voici ma préoccupation. Pour moi, le fond est plus organisé. Le code lui-même est divisé en petits morceaux qui peuvent être testés séparément. MAIS je pense: si je devais lire cela en tant que développeur junior, peu habitué aux concepts tels que l’utilisation de foncteurs d’identité, le currying ou les déclarations ternaires, serais-je même en mesure de comprendre ce que cette dernière solution fait? Est-il préférable de faire les choses de la manière "fausse, facile" parfois?
Babel ES6