Die Entwicklung von Komponenten und Anwendungen mit React ist nicht schwierig, da das API von React sehr schmal und deswegen schnell erlernbar ist. Für große Enterprise-Anwendungen kommen aber eine ganze Reihe von Fragen ins Spiel, für die React keine fertige Antwort mitbringt.
Enterprise-Anwendungen zeichnen sich in der Regel dadurch aus, dass sie eine große Codebasis haben, die von einer Vielzahl von Entwicklern und Teams über einen langen Zeitraum entwickelt und gewartet wird.
Dadurch ergeben sich auch im Bereich der Frontend-Entwicklung eine ganze Reihe von Fragestellungen. Wie kann der Code so strukturiert werden, dass möglichst mehrere Teams unabhängig voneinander damit arbeiten können? Wie kann sichergestellt werden, dass der Code auch nach mehreren Monaten oder gar Jahren noch verstanden und verändert werden kann? Und: Wie kann der Code überhaupt getestet werden? Im Folgenden wollen wir uns einige dieser Probleme ansehen und schauen, welche Möglichkeiten es gibt, sie mit React zu lösen.
Codestruktur
Um die Orientierung im Sourcecode einer großen Anwendung nicht zu verlieren, ist es wichtig, eine vernünftige Struktur dafür zu wählen. Im Gegensatz zu Java-Projekten – wo es mit Maven einen De-facto-Standard für Projektlayouts und mit der Java-Sprachspezifikation genaue Vorgaben gibt, wie Dateien für Klassen heißen und wo sie liegen müssen – können diese Entscheidungen in JavaScript- und React-Anwendungen nahezu nach Belieben getroffen werden.
Das ist einerseits sehr praktisch, da Strukturen je nach Vorlieben des Teams geschaffen werden können. Auf der anderen Seite ist das Team aber auf diese Weise auch verpflichtet, sich damit auseinanderzusetzen. Ähnlich wie beim Thema Tabs oder Spaces oder der Suche nach der „richtigen“ Codeformatierung kann auch das Thema Codestruktur intensiv diskutiert werden. In der Dokumentation von React findet sich diesbezüglich lediglich der Hinweis, dass Code, der in der Regel gemeinsam verändert wird, auch „nahe beieinander“ sein sollte (Colocation).
Dan Abramov, einer der React-Core-Entwickler, hat seine Meinung zum Thema so zusammengefasst: „Move files around until it feels right“ [1], und weiter: „Start by putting everything in one file; when it feels like it’s annoying, start splitting them up; when that gets annoying, maybe add some folders“ [2]. Aus meiner Sicht ist das eine sehr gute und vor allem pragmatische Herangehensweise, insbesondere da je nach Projektgröße und -entwicklung andere Strukturen sinnvoll sein können. Zu Beginn eines Projekts, wenn vielleicht noch nicht hundertprozentig klar ist, wie genau die Anwendung aussehen und funktionieren soll, kann es sehr praktisch sein, möglichst viel Code in einer Datei zu haben. So lassen sich Änderungen schnell durchführen, ohne viel in der IDE oder dem Editor hin- und hernavigieren zu müssen. Wenn die Anforderungen im Lauf der Zeit klarer, die Anwendung entsprechend stabiler oder das Entwicklerteam größer wird, kann es sinnvoll sein, große Komponenten in kleinere aufzuteilen und auch auf mehrere Dateien zu verteilen. Diese lassen sich einfacher testen und außerdem können mehrere Entwickler parallel im Code arbeiten, ohne sich in die Quere zu kommen.
Sehen wir uns also an, welche Möglichkeiten es gibt, den Code für eine Komponente zu strukturieren, und wie eine solche Evolution aussehen kann. Als Beispiel soll dazu die Komponente Greeting dienen, die einen fiktiven Gruß ausgibt.
Listing 1
export default class Greeting extends React.Component {
render() {
const { greeting, name } = this.props;
return (<>
<h1>Greeting for {name}</h1>
<div>{greeting}</div>
</>);
}
}In Listing 1 sehen wir den Ausgangspunkt unserer Komponente, die zunächst aus einer render-Methode besteht, in der direkt zwei Elemente, ein h1 für die Überschrift und ein div für einen Gruß gerendert werden. Wir müssen nicht zwischen verschiedenen Stellen im Editor hin und her navigieren, um zu verstehen, wie die Komponente funktioniert und was sie ausgibt.
Während der weiteren Entwicklung der Komponente wird die Logik zum Rendern der Überschrift oder des Grußes jedoch komplexer, beispielsweise müssen möglicherweise Event Listener oder Styling hinzugefügt werden. Vielleicht soll auch abhängig von einem der beiden Properties unterschiedlich gerendert werden. Jedenfalls: Die render-Methode wird langsam unübersichtlich. Die nächste Stufe im Evolutionsprozess könnte so aussehen, wie in Listing 2 dargestellt: Das konkrete Rendern der beiden Teile (Überschrift, Gruß) wird in eigene Methoden ausgelagert, die aber innerhalb der Komponentenklasse verbleiben. Vorteil dieses Ansatzes: Die render-Methode wird wieder übersichtlich, da sie nur noch als eine Art Wrapper dient. Die „wirkliche“ Funktionalität ist aber weiterhin sehr nahe beieinander. Außerdem müssen wir bei diesem Refactoring noch nicht anfangen, Properties und/oder State an die extrahierten Methoden zu übergeben, da diese genau wie die render-Methode auf Properties und State zugreifen können.
Listing 2
export default class Greeting extends React.Component {
renderName() { return <h1 style={...} onClick={...}>{this.props.name}</h1> }
renderPhrase() { ... }
render() {
return (<>
{ this.renderName() }
{ this.renderPhrase() }
</>);
}
}
}Irgendwann reicht aber auch diese Aufteilung möglicherweise nicht mehr aus. Es fällt zum Beispiel schwer, die beiden extrahierten render-Methoden einzeln zu testen. Aus diesem Grund können nun für Titel und Gruß eigene Komponenten extrahiert werden, die allerdings zunächst privat sind. Sie verbleiben also innerhalb derselben Datei wie die Greeting-Komponente und werden nicht oder nur für den Test exportiert (Listing 3).
Listing 3
// GreetingName und GreetingPhrase sind nicht außerhalb dieser Datei sichtbar
class GreetingName extends React.Component {...}
class GreetingPhrase extends React.Component {...}
export default class Greeting extends React.Component {
render() {
return <>
<GreetingName name="..." />
<GreetingTitle phrase="..." />
</>
}
}Werden die beiden extrahierten Komponenten zu groß, sodass die ganze Datei unübersichtlich wird, oder sollen die Komponenten zum Beispiel auch an anderen Stellen der Anwendung wiederverwendet werden, werden sie schließlich in jeweils eigene Dateien verschoben. Je nach Fachlichkeit können sie im selben Ordner wie die Greeting-Komponente verbleiben (Listing 4).
Listing 4
// GreetingName.js
export default class GreetingName extends React.Component {...}
// GreetingPhrase.js
export default class GreetingPhrase extends React.Component {...}
// Greeting.js
import GreetingName from "./GreetingName";
import GreetingPhrase from "./GreetingPhrase";
export default class Greeting extends React.Component {
...
}Besteht die Anwendung aus mehr als nur einem fachlichen Modul, können die Komponenten, die jeweils modulspezifisch sind und zu einer Fachlichkeit gehören, in eigenen Ordnern zusammengefasst werden. Hierbei empfiehlt es sich, nach Fachlichkeit und nicht nach Technik zu gruppieren. Innerhalb eines solchen Featureverzeichnisses kann die zentrale Komponente, die von anderen Teilen der Anwendung genutzt werden soll, über die index.js-Datei exportiert werden. Auf diese Weise können die Verwender der Komponente beim Import einfach den Namen des Verzeichnisses...

