Sou desenvolvedor sênior de front-end, codificando em Babel ES6. Parte de nosso aplicativo faz uma chamada de API e, com base no modelo de dados que recebemos da chamada de API, é necessário preencher determinados formulários.
Esses formulários são armazenados em uma lista duplamente vinculada (se o back-end indicar que alguns dos dados são inválidos, podemos retornar rapidamente ao usuário a página que eles estragaram e depois recuperá-los no destino, simplesmente modificando o Lista.)
De qualquer forma, há várias funções usadas para adicionar páginas, e estou me perguntando se estou sendo muito inteligente. Esta é apenas uma visão geral básica - o algoritmo real é muito mais complexo, com toneladas de diferentes páginas e tipos de página, mas isso lhe dará um exemplo.
Acho que é assim que um programador iniciante pode lidar com isso.
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;
}Agora, para ser mais testável, eu peguei todas essas instruções if e as fiz separadas, funções independentes e depois mapeei sobre elas.
Agora, testável é uma coisa, mas também é legível, e me pergunto se estou tornando as coisas menos legíveis aqui.
// 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
}Aqui está a minha preocupação. Para mim, o fundo é mais organizado. O código em si é dividido em partes menores que podem ser testadas isoladamente. MAS, estou pensando: se tivesse que ler isso como desenvolvedor júnior, não acostumado a conceitos como o uso de functores de identidade, currying ou declarações ternárias, seria capaz de entender o que a última solução está fazendo? É melhor fazer as coisas da maneira "errada, mais fácil" às vezes?
Babel ES6