Ich bin ein Senior-Front-End-Entwickler und programmiere in Babel ES6. Ein Teil unserer App führt einen API-Aufruf durch und basierend auf dem Datenmodell, das wir vom API-Aufruf erhalten, müssen bestimmte Formulare ausgefüllt werden.
Diese Formulare werden in einer doppelt verknüpften Liste gespeichert (wenn das Back-End angibt, dass einige der Daten ungültig sind, können wir den Benutzer schnell zu der einen Seite zurückbringen, auf der er sie durcheinander gebracht hat, und sie dann wieder auf das Ziel bringen, indem Sie einfach die ändern Liste.)
Wie auch immer, es gibt eine Reihe von Funktionen zum Hinzufügen von Seiten, und ich frage mich, ob ich zu schlau bin. Dies ist nur eine grundlegende Übersicht - der eigentliche Algorithmus ist viel komplexer, mit Tonnen verschiedener Seiten und Seitentypen, aber dies wird Ihnen ein Beispiel geben.
Ich denke, ein Anfänger würde so damit umgehen.
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;
}Um die Testbarkeit zu verbessern, habe ich all diese if-Anweisungen aufgenommen und sie getrennt, eigenständige Funktionen erstellt und sie dann gemappt.
Nun, testbar ist eine Sache, aber auch lesbar, und ich frage mich, ob ich die Dinge hier weniger lesbar mache.
// 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
}Hier ist mein Anliegen. Für mich ist der Boden organisierter. Der Code selbst ist in kleinere Abschnitte unterteilt, die isoliert getestet werden können. ABER ich denke: Wenn ich das als Junior-Entwickler lesen müsste, der nicht mit Konzepten wie Identitätsfunktionen, Currys oder ternären Anweisungen vertraut ist, würde ich überhaupt verstehen können, was die letztere Lösung tut? Ist es manchmal besser, die Dinge "falsch, einfacher" zu machen?
Babel ES6