fachmedien.de - spezialisierte Fachinformationen für Studium und Beruf
fachmedien.de - spezialisierte Fachinformationen für Studium und Beruf
fachmedien.de - spezialisierte Fachinformationen für Studium und Beruf
fachmedien.de - spezialisierte Fachinformationen für Studium und Beruf
fachmedien.de - spezialisierte Fachinformationen für Studium und Beruf

Site Breadcrumb

Verkauf durch Sack Fachmedien

Clausen

Five Lines of Code

Das Praxisbuch für Refactoring und Clean Code: Beispiele in TypScript und Lösungen aus realen Projekten, für alle OOP-Sprachen und Codebasen

Medium: Buch
ISBN: 978-3-8362-9224-5
Verlag: Rheinwerk Verlag GmbH
Erscheinungstermin: 08.12.2022
In den Warenkorb
sofort versandfertig, Lieferfrist: 1-3 Werktage
Auf die Merkliste Drucken
Überschrift

Beschreibung

Kostenloser Versand

nach Deutschland, Österreich und in die Schweiz

Bequem zahlen

Rechnung, Kreditkarte, PayPal oder Bankeinzug

Wir sind gerne für Sie da

0800 000-1378 (Inland)
service@fachmedien.de
<<Kontaktformular>>

Fragen

Fragen Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua
Anwtorten

Anwtorten At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet

Refactoring ist die Kunst, bestehenden Code so zu verbessern, dass der Wert von Software langfristig erhalten bleibt. Das Ergebnis des Vorgangs ist als Clean Code bekannt – aber wie kommen Sie dahin? Christian Clausen legt hier eine ganz neuartige Schule des Refactorings vor, die Sie Schritt für Schritt anleitet. Das Vorgehen eignet sich für alle OOP-Sprachen. Die gut lesbaren Beispiele in TypeScript sind in einem Stil gehalten, der insbesondere Java- und C#- Entwickler*innen vertraut sein dürfte. Ein zweispaltiges Vorher-Nachher-Layout mit zeilengenauen Codekommentaren macht jeden Arbeitsschritt hervorragend nachvollziehbar. So gelingt Ihr Refactoring sicher!

Aus dem Inhalt:

- Anzeichen für Verbesserungsbedarf im Code

- Code in sicheren Schritten verbessern – auch, wenn Sie ihn nicht verstehen

- Optimierungen und Wiederverwendbarkeit sinnvoll abwägen

- Gute Compiler-Praxis

- Viele Patterns und Methoden für das konkrete Vorgehen

- Wie man Code schreibt, der ohne Kommentare auskommt

- Best Practices aus realen Projekten

Produkteigenschaften

  • Artikelnummer: 9783836292245
  • Medium: Buch
  • ISBN: 978-3-8362-9224-5
  • Verlag: Rheinwerk Verlag GmbH
  • Erscheinungstermin: 08.12.2022
  • Sprache(n): Deutsch
  • Auflage: 1. Auflage 2022
  • Serie: Rheinwerk Computing
  • Produktform: Kartoniert
  • Gewicht: 838 g
  • Seiten: 400
  • Format (B x H x T): 189 x 237 x 26 mm
  • Ausgabetyp: Kein, Unbekannt

Themen

Autoren/Hrsg.

Autoren


  Materialien zum Buch ... 16
  Vorwort ... 17
  Einführung ... 19
  Danksagungen ... 23
  Der Autor ... 25
  Der Übersetzer ... 25
  1.  Refactorings für Refactoring ... 27

       1.1 ... Was ist Refactoring? ... 28
       1.2 ... Fähigkeiten: Was sollte ich refactorn? ... 29
       1.3 ... Kultur: Wann sollte ich refactorn? ... 31
       1.4 ... Werkzeuge: Wie sollte ich (sicher) refactorn? ... 33
       1.5 ... Werkzeuge für den Anfang ... 34
       1.6 ... Das durchgehende Beispiel: ein 2D-Rätselspiel ... 36
       1.7 ... Ein Wort zu Software aus der echten Welt ... 38
       1.8 ... Zusammenfassung ... 39

  2.  Ein Blick unter die Haube ... 41

       2.1 ... Lesbarkeit und Wartbarkeit verbessern ... 41
       2.2 ... Geschwindigkeit, Flexibilität und Stabilität gewinnen ... 45
       2.3 ... Refactoring und die tägliche Arbeit ... 47
       2.4 ... Die Domäne einer Software definieren ... 48
       2.5 ... Zusammenfassung ... 49

TEIL I.  Das Refactoring eines Computerspiels als Lernbeispiel ... 51
  3.  Lange Funktionen zerschlagen ... 53

       3.1 ... Unsere erste Regel: Warum fünf Zeilen? ... 54
       3.2 ... Ein Refactoring, um Funktionen aufzubrechen ... 57
       3.3 ... Funktionen teilen, um Abstraktionsebenen zu trennen ... 66
       3.4 ... Eigenschaften eines guten Funktionsnamens ... 69
       3.5 ... Funktionen aufbrechen, die zu viel tun ... 72
       3.6 ... Zusammenfassung ... 76

  4.  Typen richtig nutzen ... 77

       4.1 ... Refactoring einer einfachen if-Anweisung ... 77
       4.2 ... Refactoring einer großen »if«-Anweisung ... 98
       4.3 ... Mit doppeltem Code umgehen ... 114
       4.4 ... Refactoring von zwei komplexen »if«-Anweisungen ... 118
       4.5 ... Toten Code entfernen ... 122
       4.6 ... Zusammenfassung ... 124

  5.  Ähnlichen Code zusammenführen ... 127

       5.1 ... Ähnliche Klassen zusammenführen ... 128
       5.2 ... Einfache Bedingungen zusammenführen ... 145
       5.3 ... Komplexe Bedingungen zusammenführen ... 150
       5.4 ... Code in verschiedenen Klassen zusammenführen ... 156
       5.5 ... Ähnliche Funktionen zusammenführen ... 178
       5.6 ... Ähnlichen Code zusammenführen ... 182
       5.7 ... Zusammenfassung ... 187

  6.  Die Daten verteidigen ... 189

       6.1 ... Kapselung ohne Getter ... 189
       6.2 ... Einfache Daten kapseln ... 201
       6.3 ... Komplexe Daten kapseln ... 214
       6.4 ... Invariante Reihenfolgen entfernen ... 222
       6.5 ... Ein anderes Vorgehen, um Enums zu löschen ... 226
       6.6 ... Zusammenfassung ... 232

TEIL II.  Das Gelernte in die Praxis übertragen ... 233
  7.  Mit dem Compiler zusammenarbeiten ... 235

       7.1 ... Den Compiler kennenlernen ... 236
       7.2 ... Den Compiler benutzen ... 245
       7.3 ... Vertraue dem Compiler ... 255
       7.4 ... Vertraue nur dem Compiler ... 258
       7.5 ... Zusammenfassung ... 259

  8.  Finger weg von Kommentaren ... 261

       8.1 ... Veraltete Kommentare löschen ... 263
       8.2 ... Auskommentierten Code löschen ... 263
       8.3 ... Überflüssige Kommentare löschen ... 264
       8.4 ... Kommentare in Methodennamen umsetzen ... 265
       8.5 ... Kommentare behalten, die Invarianten dokumentieren ... 266
       8.6 ... Zusammenfassung ... 267

  9.  Lerne, das Löschen zu lieben ... 269

       9.1 ... Code löschen: das nächste Abenteuer ... 270
       9.2 ... Code löschen, um anfallende Komplexitätzu reduzieren ... 271
       9.3 ... Code nach Vertrautheit kategorisieren ... 274
       9.4 ... Code in einem Legacy-System löschen ... 275
       9.5 ... Code aus einem eingefrorenen Projekt löschen ... 278
       9.6 ... Branches aus der Versionskontrolle löschen ... 280
       9.7 ... Codedokumentation löschen ... 282
       9.8 ... Testcode löschen ... 284
       9.9 ... Konfigurationscode löschen ... 286
       9.10 ... Code löschen, um Bibliotheken loszuwerden ... 288
       9.11 ... Code aus funktionierenden Features entfernen ... 291
       9.12 ... Zusammenfassung ... 292

10.  Keine Angst vor neuem Code ... 293

       10.1 ... Unsicherheit akzeptieren: In die Gefahr eintreten ... 294
       10.2 ... Prototypen: gegen die Angst, das Falsche zu entwickeln ... 294
       10.3 ... Verhältnismäßige Arbeit: gegen die Angst vor Verschwendung und Risiko ... 296
       10.4 ... Schrittweise Verbesserung: gegen die Angst vor Imperfektion ... 297
       10.5 ... Wie Copy & Paste unsere Geschwindigkeit beeinflusst ... 298
       10.6 ... Verändern durch Hinzufügen: geplante Erweiterbarkeit ... 299
       10.7 ... Verändern durch Hinzufügen erlaubt Abwärtskompatibilität ... 300
       10.8 ... Verändern durch Hinzufügen mit Featureschaltern ... 302
       10.9 ... Verändern durch Hinzufügen mit Verzweigung durch Abstraktion ... 306
       10.10 ... Zusammenfassung ... 309

11.  Folge der Struktur im Code ... 311

       11.1 ... Strukturen einteilen nach Wirkungsbereich und Herkunft ... 311
       11.2 ... Drei Arten, wie Code Verhalten spiegelt ... 313
       11.3 ... Code hinzufügen, um Struktur zu betonen ... 321
       11.4 ... Beobachten statt vorhersagen -- empirische Techniken einsetzen ... 322
       11.5 ... Sicherheit gewinnen, ohne den Code zu verstehen ... 323
       11.6 ... Ungenutzte Strukturen finden ... 324
       11.7 ... Zusammenfassung ... 333

12.  Vermeide Optimierung und Generalität ... 335

       12.1 ... Nach Einfachheit streben ... 336
       12.2 ... Verallgemeinern -- wann und wie ... 338
       12.3 ... Optimieren -- wann und wie ... 340
       12.4 ... Zusammenfassung ... 352

13.  Schlechter Code soll schlecht aussehen ... 353

       13.1 ... Auf Prozessprobleme mit schlechtem Code aufmerksam machen ... 353
       13.2 ... Trennung in sauberen und problematischen Code ... 355
       13.3 ... Ansätze, schlechten Code zu definieren ... 356
       13.4 ... Regeln für sicheren Vandalismus ... 359
       13.5 ... Methoden für sicheren Vandalismus ... 359
       13.6 ... Zusammenfassung ... 369

14.  Zum Abschluss ... 371

       14.1 ... Ein Rückblick auf die Reise in diesem Buch ... 371
       14.2 ... Die Philosophie dahinter ... 372
       14.3 ... Wie mache ich weiter? ... 377
       14.4 ... Zusammenfassung ... 378

  A.  Die Werkzeuge für Teil I installieren ... 381

       A.1 ... Node.js ... 381
       A.2 ... TypeScript ... 381
       A.3 ... Visual Studio Code ... 381
       A.4 ... Git ... 382
       A.5 ... Das TypeScript-Projekt einrichten ... 382
       A.6 ... Das TypeScript-Projekt bauen ... 382
       A.7 ... Wie du den Level änderst ... 383

  Index ... 385