Jestem programistą front-end Sr., koduję w Babel ES6. Część naszej aplikacji wykonuje wywołanie API, a na podstawie modelu danych, który otrzymujemy z wywołania API, niektóre formularze muszą zostać wypełnione.
Te formularze są przechowywane na podwójnie połączonej liście (jeśli zaplecze mówi, że niektóre dane są nieprawidłowe, możemy szybko przywrócić użytkownika do jednej strony, którą pomieszali, a następnie przywrócić je do celu, po prostu modyfikując lista.)
W każdym razie istnieje wiele funkcji służących do dodawania stron i zastanawiam się, czy nie jestem zbyt sprytny. To tylko podstawowy przegląd - faktyczny algorytm jest znacznie bardziej złożony, z mnóstwem różnych stron i typów stron, ale to da ci przykład.
Myślę, że tak poradziłby sobie początkujący programista.
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;
}
Teraz, aby być bardziej testowalnym, wziąłem wszystkie te instrukcje if i rozdzieliłem je, samodzielne funkcje, a następnie mapuję je.
Teraz testowalność to jedna rzecz, ale tak też jest czytelna i zastanawiam się, czy nie sprawiam, że rzeczy są mniej czytelne.
// 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
}
Oto moja troska. Dla mnie dno jest bardziej zorganizowane. Sam kod jest podzielony na mniejsze części, które można testować w izolacji. ALE myślę: gdybym musiał to przeczytać jako młodszy programista, nieprzyzwyczajony do takich pojęć, jak używanie funktorów tożsamości, curry lub potrójne stwierdzenia, czy byłbym w stanie zrozumieć, co robi to drugie rozwiązanie? Czy czasem lepiej jest robić rzeczy w „zły, łatwiejszy” sposób?
Babel ES6