Bertolozi / Buchholz / Haeuptle Clean SAPUI5

Lesbarer und wartbarer SAPUI5-Code
1. Auflage 2024
ISBN: 978-3-367-10052-1
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Deutsch, 596 Seiten

Reihe: SAP Press

Optimieren Sie Ihren SAPUI5-Code für bessere Lesbarkeit und Wartbarkeit! Entdecken Sie in diesem Buch bewährte Methoden von Experten , um JavaScript-Funktionen effektiv zu nutzen und Ihren SAPUI5-Code zu verbessern. Tauchen Sie ein in detaillierte Beispiele und Erklärungen zu Modulen, Klassen, Funktionen, Namen, Variablen, Literalen, Kommentaren, Code-Metriken und mehr . Übernehmen Sie die Best Practices von den Profis für Formatierung, Testen, Implementierung und vieles mehr!

Aus dem Inhalt:

• JavaScript
• Module und Klassen
• Funktionen
• Namensgebung
• Variablen und Literale
• Kontrollstruktur
• Fehlerbehandlung
• Formatierung
• Statische Code-Prüfung
• Testen
• Implementierung

Autoren/Hrsg.

Bertolozi, Daniel

Buchholz, Arnaud

Haeuptle, Klaus

Jordão, Rodrigo

Lehmann, Christian

Vaithianathan, Narendran Natarajan

Inhaltsverzeichnis

  Einleitung ... 17

  1.  Einführung ... 25

       1.1 ... Was ist Clean SAPUI5? ... 26

       1.2 ... Erste Schritte mit Clean SAPUI5 ... 28

       1.3 ... Umgang mit Legacy-Code ... 30

       1.4 ... Code automatisch prüfen ... 32

       1.5 ... Wie hängt Clean SAPUI5 mit anderen Leitfäden zusammen? ... 32

       1.6 ... Zusammenfassung ... 34

  2.  JavaScript und SAPUI5 ... 35

       2.1 ... Funktionen von JavaScript ES6+ ... 36

       2.2 ... TypeScript ... 119

       2.3 ... Zusammenfassung ... 131

  3.  Projektstruktur ... 133

       3.1 ... Komponenten in SAPUI5 ... 133

       3.2 ... Wichtige Artefakte ... 136

       3.3 ... Freestyle-Anwendungen ... 145

       3.4 ... SAP Fiori Elements ... 147

       3.5 ... Bibliotheksprojekte ... 155

       3.6 ... Model-View-Controller-Assets ... 158

       3.7 ... Zusammenfassung ... 161

  4.  Module und Klassen ... 163

       4.1 ... Controller-Inflation ... 164

       4.2 ... Modullebenszyklus ... 199

       4.3 ... Wiederverwendbarkeit und Testbarkeit ... 208

       4.4 ... Servicemodule vs. Klassenmodule ... 219

       4.5 ... Zusammenfassung ... 226

  5.  Funktionen ... 229

       5.1 ... Funktionsdefinition ... 229

       5.2 ... Funktionsobjekt ... 231

       5.3 ... Instanzmethoden ... 233

       5.4 ... Event-Handler und Callbacks ... 236

       5.5 ... Ausführungskontext der Callback-Funktion ... 236

       5.6 ... Getter und Setter ... 238

       5.7 ... Anonyme Funktionen ... 241

       5.8 ... Funktionsparameter ... 243

       5.9 ... Promises ... 258

       5.10 ... Generatoren ... 265

       5.11 ... Funktionskörper ... 266

       5.12 ... Funktionen aufrufen ... 274

       5.13 ... Closures ... 277

       5.14 ... Zusammenfassung ... 278

  6.  Namensgebung ... 281

       6.1 ... Beschreibende Namen ... 282

       6.2 ... Domänenbegriffe ... 283

       6.3 ... Entwurfsmuster ... 285

       6.4 ... Konsistenz ... 285

       6.5 ... Namen kürzen ... 287

       6.6 ... Füllwörter ... 288

       6.7 ... Casing ... 289

       6.8 ... Klassen und Enums ... 291

       6.9 ... Funktionen und Methoden ... 292

       6.10 ... Variablen und Parameter ... 294

       6.11 ... Private Elemente ... 300

       6.12 ... Namensräume ... 302

       6.13 ... Control-IDs ... 304

       6.14 ... Ungarische Notation ... 305

       6.15 ... Alternative Regeln ... 307

       6.16 ... Zusammenfassung ... 309

  7.  Variablen und Literale ... 311

       7.1 ... Variablen ... 311

       7.2 ... Literale ... 316

       7.3 ... Zusammenfassung ... 335

  8.  Kontrollfluss ... 337

       8.1 ... Bedingungen ... 338

       8.2 ... Schleifen ... 342

       8.3 ... Bedingte Komplexität ... 345

       8.4 ... Zusammenfassung ... 353

  9.  Fehlerbehandlung ... 355

       9.1 ... »throw«- und »try/catch«-Anweisungen ... 355

       9.2 ... Fehlerobjekte verwenden ... 357

       9.3 ... Fehlerbehandlung über Meldungen ... 359

       9.4 ... Fehlerbehandlung mit Controls ... 361

       9.5 ... Best Practices für die Fehlerbehandlung ... 365

       9.6 ... Zusammenfassung ... 369

10.  Formatierung ... 371

       10.1 ... Motivation ... 371

       10.2 ... Vertikale und horizontale Formatierung ... 372

       10.3 ... Textbereich ein- oder ausrücken ... 382

       10.4 ... XML-Views ... 385

       10.5 ... Weitere Hinweise ... 391

       10.6 ... Formatierung für TypeScript in SAPUI5 ... 395

       10.7 ... Erstellen und Pflegen eines Codestil-Leitfadens ... 407

       10.8 ... Formatierungswerkzeuge ... 409

       10.9 ... Zusammenfassung ... 415

11.  Kommentare ... 417

       11.1 ... Drücken Sie Ihre Absicht im Code aus ... 418

       11.2 ... Das Gute: Kommentarplatzierung und -nutzung ... 419

       11.3 ... Das Schlechte: Zu vermeidende oder umzustrukturierende Kommentare ... 431

       11.4 ... Das Hässliche: Sonderkommentare ... 442

       11.5 ... Zusammenfassung ... 445

12.  Statische Codeprüfungen und Codemetriken ... 447

       12.1 ... Linting ... 449

       12.2 ... Codemetriken ... 469

       12.3 ... Zusammenfassung ... 491

13.  Testen ... 493

       13.1 ... Prinzipien ... 494

       13.2 ... Zu testender Code ... 508

       13.3 ... Injektion ... 510

       13.4 ... Testmethoden und Journeys ... 516

       13.5 ... Testdaten ... 519

       13.6 ... Assertions ... 523

       13.7 ... Zusammenfassung ... 529

14.  TypeScript und verwandte Technologien ... 531

       14.1 ... TypeScript ... 531

       14.2 ... UI5 Web Components ... 547

       14.3 ... Fundamental Library ... 556

       14.4 ... Zusammenfassung ... 560

15.  Wie Sie Clean SAPUI5 umsetzen ... 561

       15.1 ... Gemeinsames Verständnis der Teammitglieder ... 562

       15.2 ... Kollektive Code Ownership ... 562

       15.3 ... Clean Code Developer Initiative ... 564

       15.4 ... Den Broken-Window-Effekt angehen ... 566

       15.5 ... Code-Reviews und Lernen ... 570

       15.6 ... Clean Code Advisor ... 574

       15.7 ... Lerntechniken ... 574

       15.8 ... Continuous Learning in funktionsübergreifenden Teams ... 579

       15.9 ... Zusammenfassung ... 582

  Die Autoren ... 583

  Index ... 585

Leseproben

Einleitung

JavaScript ist eine sehr mächtige Sprache, aber diese Mächtigkeit bringt auch Probleme mit sich. Daher ist es für eine nachhaltige Entwicklung unerlässlich, eine Codebasis zu haben, die lesbar, wartbar und vor allem testbar ist. Das Buch »Clean Code: A Handbook of Agile Software Craftsmanship« von Robert C. Martin und mehrere andere Bücher enthalten viele Best Practices, die helfen, dieses Ziel in Java zu erreichen, aber viele der beschriebenen Konzepte sind unabhängig von der Programmiersprache. Sauberer Code ist ein Kernbestandteil der agilen Softwareentwicklung und stellt sicher, dass Sie langfristig agil bleiben und Ihre Projekte problemlos an sich ständig ändernde Anforderungen anpassen können.

Da die Zeit, die mit dem Lesen von Code verbracht wird, viel höher ist als die Zeit, die für das Schreiben desselben Codes benötigt wird, ist ein wichtiges Ziel, dass Ihr Code leicht zu lesen ist und klar vermittelt, was er zu erreichen versucht. Mit einem unermüdlichen Fokus auf Lesbarkeit wirkt sich sauberer Code letztlich auf die Wartbarkeit der Codebasis aus.

In diesem Buch beschreiben wir Regeln, Praktiken, Prinzipien, Muster, Richtlinien und Empfehlungen, die Ihren SAPUI5-/JavaScript-Code bereinigen – d. h. lesbar, verständlich, wartbar und testbar machen. In diesem Buch erläutern wir Codemuster und Idiome und behandeln übergeordnete Designüberlegungen. Wir werden auch Gewohnheiten, Prozesse und organisatorische Aspekte untersuchen, die beeinflussen, wie Sie als einzelne Entwicklerinnen und Entwickler und im Team Clean Code implementieren.

Hinweis

Viele Entwicklerinnen und Entwickler wechseln zwischen Sprachen und Frameworks. Dieses Buch verwendet dort, wo es sinnvoll ist, die gleiche Sprache und Terminologie wie das Buch »Clean ABAP: Lesbarer und wartbarer ABAP-Code« (SAP PRESS, 2022, sap-press.de/5403). Leserinnen und Leser von »Clean ABAP: Lesbarer und wartbarer ABAP-Code« profitieren daher von einem einfacheren Lernprozess, der sich auf bekannte Konzepte konzentriert und dann die Unterschiede untersucht. Wenn Sie mit diesem Buch beginnen, können Sie die gemeinsame Struktur der beiden Bücher nutzen, um sich mit »Clean ABAP« vertraut zu machen. Viele der Konzepte in »Clean ABAP« sollten Ihnen bekannt sein, sodass Sie sich auf die Anwendung dieser Prinzipien auf ABAP konzentrieren können. Beachten Sie jedoch, dass es große Unterschiede zwischen ABAP und JavaScript gibt und dass es keine konzeptionelle Überschneidung zwischen den beiden Büchern gibt.

Zielgruppe des Buchs

Dieses Buch ist eher technischer Natur und richtet sich hauptsächlich an SAPUI5-/JavaScript-Entwicklerinnen und -Entwickler. Wir haben viele Codebeispiele aufgenommen, um es Ihnen zu erleichtern, die Prinzipien und Praktiken zu übernehmen. Wir bieten ausreichend Erklärungen für Leserinnen und Leser, die noch auf dem Anfänger-Level sind, haben aber auch viele interessante Inhalte für Entwicklerinnen und -Entwickler auf Senior- bis Expert-Level aufgenommen. Abhängig von Ihrem Kenntnisstand können Sie von verschiedenen Themen profitieren oder sich auf bestimmte Schwerpunktbereiche konzentrieren. Die allgemeinen Ideen in diesem Buch richten sich jedoch an alle Entwicklerinnen und Entwickler, unabhängig von ihrer Erfahrung.

Wir empfehlen auch Softwarearchitektinnen und -architekten, dieses Buch zu lesen, um Clean SAPUI5 zu verstehen. Einige Themen in diesem Buch überschneiden sich mit der Softwarearchitektur (z. B. Modularisierung). Auch wenn Sie gar nicht programmieren, können Sie von den Konzepten in diesem Buch profitieren, einige dieser Praktiken lernen und anwenden. Insbesondere das letzte Kapitel ist nicht nur für Ingenieurinnen und Ingenieure relevant, sondern auch für Scrum Master und Manager, die sich mit der Team- und Organisationsentwicklung beschäftigen müssen.

In dieses Buch haben wir Themen aufgenommen, die Ihnen helfen sollen, jederzeit mit sauberem SAPUI5 in jeder Art von Projekt mit jeder Art von Team zu starten.

Aufbau des Buchs

Dieses Buch beginnt mit einer Einführung in Clean SAPUI5 und einer allgemeinen Diskussion der JavaScript-Sprache und des SAPUI5-Frameworks in Kapitel 1 und Kapitel 2. Anschließend gehen wir in Kapitel 3 und Kapitel 4 sowie in Kapitel 5 auf die übergreifenden Themen Klassen, Module und Funktionen ein und diskutieren Clean-SAPUI5-Praktiken für diese übergeordneten Konstrukte. Das zentrale Thema der Namensgebung behandeln wir in Kapitel 6. Anschließend stellen wir in Kapitel 7 bis Kapitel 11 weitere Details zu spezifischen Clean-SAPUI5-Themen vor, von Variablen und Literalen bis hin zu Fehlerbehandlung und Kommentaren. In Kapitel 12 erfahren Sie mehr über statische Codeprüfungen und Codemetriken. Modultests und Integrationstests werden in Kapitel 13 erörtert, gefolgt von TypeScript und Technologien in Zusammenhang mit SAPUI5 in Kapitel 14. Schließlich erfahren Sie in Kapitel 15, wie Sie Clean SAPUI5 auf individueller, Team- oder Organisationsebene erlernen und implementieren können.

Kapitel 1 und Kapitel 2 sind wichtig, da sie den Kontext für das gesamte Buch liefern. Kapitel 4 und Kapitel 5 werden am besten zusammen gelesen, da der Themenbereich Klassen und Module natürlich in das Thema Funktionen übergeht. Die anderen Kapitel sind in sich abgeschlossen und können in beliebiger Reihenfolge gelesen oder als Referenz verwendet werden. Achten Sie jedoch darauf, Abschnitt 1.2, »Erste Schritte mit Clean SAPUI5«, zu lesen, um zu erfahren, welche Themen zu welchem Zeitpunkt behandelt werden sollten. Kapitel 15 ist wichtig für alle, die bereit sind, Clean SAPUI5 auf allen Ebenen im Unternehmen zu lernen und zu implementieren.

Sehen wir uns kurz an, was in den einzelnen Kapiteln behandelt wird:

Kapitel 1, »Einführung«, stellt das Clean-SAPUI5-Konzept vor, beschreibt, warum es wichtig ist, Clean Code zu schreiben, und zeigt Ihnen, wie Sie damit beginnen können. Außerdem erfahren Sie mehr über andere Stilleitfäden und Lernressourcen, mit denen Sie Ihr Verständnis über dieses Buch hinaus erweitern können.

Kapitel 2, »JavaScript und SAPUI5«, stellt einige aktuelle Ergänzungen zu JavaScript vor und zeigt anhand konkreter Beispiele, wie diese neue Syntax Entwicklerinnen und Entwicklern dabei hilft, Clean-SAPUI5-Code zu schreiben.

In Kapitel 3, »Projektstruktur«, erfahren Sie, wie Sie ein Projekt für verschiedene Projektarten strukturieren.

Eine saubere und wartbare Architektur erfordert eine umfassende Trennung der Aspekte (Separation of Concerns) in Module und Klassen. In Kapitel 4, »Module und Klassen«, untersuchen wir zunächst, warum Controller-Module in SAPUI5-Anwendungen schnell wachsen. Anschließend schlagen wir Strategien für eine angemessene Entkopplung vor.

Kapitel 5, »Funktionen«, befasst sich mit JavaScript-Funktionen. Wir werden verschiedene Schlüsselkonzepte durchgehen, z. B. verschiedene Arten von Funktionen und Funktionsparametern und wie der Funktionskörper strukturiert wird. Außerdem besprechen wir Funktionsaufrufe, Promises und Closures.

Kapitel 6, »Namensgebung«, enthält Richtlinien und Empfehlungen zur Namensvergabe, einschließlich der Auswahl guter und konsistenter Namen, der Behandlung von Domänenbegriffen und der Verwendung von Präfixen und Suffixen.

In Kapitel 7, »Variablen und Literale«, erläutern wir, wie Sie Variablen und Literale deklarieren und verwenden, wie Scoping-Regeln funktionieren und wie Sie die Destrukturierung und die Spread-Syntax nutzen.

Kapitel 8, »Kontrollfluss«, erklärt den Kontrollfluss und gibt einige Clean-SAPUI5-Empfehlungen für die Verwendung verschiedener Arten von Kontrollflussanweisungen.

Kapitel 9, »Fehlerbehandlung«, erläutert die Fehlerbehandlung, warum sie notwendig ist und wie Fehler auf die Clean-SAPUI5-Art behandelt werden.

Viele Aspekte der Codeformatierung zielen darauf ab, dass Code, der von einem Team geschrieben wird, in seinem Design konsistent ist. In Kapitel 10, »Formatierung«, stellen wir diese Aspekte vor, wobei wir die Bedeutung von guter Codeformatierung und Richtlinien für den Codestil hervorheben. Außerdem beschreiben wir, wie Sie die Formatierung durch moderne Werkzeuge erzwingen und automatisieren können.

Kapitel 11, »Kommentare«, befasst sich mit der Frage, ob, warum und wie Kommentare effektiv in Ihrem Code verwendet werden sollten. Gut platzierte Kommentare sollten das Verständnis des Codes verbessern und ihn...

Über Autor(innen)

Jordão, Rodrigo
Rodrigo Jordão arbeitet als Development Architect bei SAP. Aktuell ist er im Bereich Integrated Business Planning (IBP) mit Schwerpunkt auf dem SAP Supply Chain Control Tower tätig. Im Rahmen seiner Karriere bei SAP war er an der Entwicklung verschiedener SAP-Produkte beteiligt – von branchenspezifischen Lösungen wie SAP Intellectual Property Management bis hin zu grundlegenden Komponenten wie SD. Zuvor arbeitete als Webentwickler mit Perl and Java sowie als Berater mit Microsoft.

Vaithianathan, Narendran Natarajan
Narendran NV ist leitender Entwickler, Trainer und Sicherheitsexperte bei SAP. Derzeit ist er Teil eines Teams, das sich auf die Entwicklung von Advanced Available-to-Promise (ATP) konzentriert. Zuvor war er Teil des FXperience-Teams (Bangalore), das die Einführung von SAP Fiori in SAP S/4HANA beschleunigt. Narendran coacht Teams zu Themen wie agiler Softwareentwicklung, SAPUI5 und SAP Fiori Elements und seit kurzem auch zum ABAP RESTful Application Programming Model. Bevor er zu SAP kam, arbeitete er als Berater bei IBM und trug zur kundenspezifischen Entwicklung in den Bereichen Reise- und Spesenabrechnung sowie Finanzen bei.

Haeuptle, Klaus
Klaus Häuptle ist Entwickler, Trainer und Product Owner im Bereich Anwendungsentwicklung. Für SAP hat er an der Entstehung verschiedener Produkte mitgewirkt, die auf unterschiedlichen Technologien basierten. Er unterstützt die SAP-Community dabei, Wissen zu teilen und Methoden und Arbeitsmittel zu verbessern. Unter anderem beeinflusste er die Verbesserung der Testmöglichkeiten für ABAP, SAP HANA und SAPUI5. Zusammen mit Florian Hoffmann entwickelte er einen zunächst internen Clean-ABAP-Leitfaden, der später als Open-Source-Projekt veröffentlicht wurde und als Grundlage dieses Buches dient.

Buchholz, Arnaud
Arnaud Buchholz ist Entwicklungsexperte bei SAP mit dem Schwerpunkt auf Design, Entwicklung und Verbesserung von SAPUI5-Anwendungen. Er verfügt über mehr als 20 Jahre Erfahrung in der Softwareentwicklung.

Lehmann, Christian
Christian Lehmann ist Entwicklungsarchitekt und arbeitet im Qualitätsbereich von SAP S/4HANA. In seinen 18 Jahren bei SAP hat er an der Konzeption, Implementierung und Testautomatisierung von SAP-basierten Produkten gearbeitet, darunter auch Anwendungen, die auf SAPUI5 basieren. Er trägt zur SAP-ASE-Community für ABAP- und SAPUI5-basierte Themen bei und hat Spaß daran, neue Ansätze für automatisierte Softwaretests kennenzulernen.

Bertolozi, Daniel
Daniel Bertolozi ist Softwareentwickler bei SAP mit mehr als fünf Jahren Erfahrung in der SAP-Fiori-Entwicklung. Er hat an mehreren Projekten gearbeitet, bei denen SAPUI5-Anwendungen (in JavaScript und TypeScript) mithilfe von Best Practices für die Code-Qualität implementiert wurden. Zudem engagiert er sich aktiv für die Verbreitung agiler Softwareentwicklungspraktiken im SAP-Umfeld. Daniels Ansatz zur Softwareentwicklung folgt dem Leitspruch von Robert C. Martin: „Der einzige Weg, schnell voranzukommen, ist, es gut zu machen.“ Qualität ist für ihn entscheidend, denn er weiß: Wenn die Qualität nachlässt, leidet letztendlich auch die Geschwindigkeit, und das gilt es, zu vermeiden.