Programmieren in TypeScript

Skalierbare JavaScript-Applikationen entwickeln

Boris Cherny, Jørgen W. Lang

• Verlag: O'Reilly
• Jahr: 2019
• eBook-ISBN: 9783960103608
• Auflage: 1
• Thema: Informatik
• Thema: Webprogrammierung

Herausragendes Fachbuch zu TypeScript und seinem Ökosystem

• TypeScripts ausgeklügeltes Typsystem verstehen
• Tiefgehende Einsichten in die Sprache gewinnen (Minko Gechev, Angular-Team bei Google)
• Von den Grundlagen bis zu Applikationen im Produktionsbetrieb

Programmierer, die mit dynamisch typisierten Sprachen arbeiten, wissen nur zu genau, wie schlecht ihre Projekte skalieren: wie schwierig es ist, mit einer umfangreichen Codebasis zu arbeiten und viele Entwickler einzubinden. Facebook, Google und Microsoft haben deshalb statisch typisierte Schichten für ihren JavaScript-und Python-Code entwickelt. TypeScript ist hier besonders interessant: Die Sprache bietet ein mächtiges statisches Typsystem, sodass Projekte besser skalieren und das Programmieren wieder Spaß macht.
Boris Cherny zeigt Programmierern mit JavaScript-Grundkenntnissen, wie die Konzepte hinter TypeScript gedacht sind und wie man die Sprache sicher beherrscht. Sie erfahren, wie TypeScript Sie dabei unterstützt, Bugs zu vermeiden und Ihren Code für deutlich mehr Entwickler zu skalieren.
Was Sie in diesem Buch erwartet:

• Mit den Grundlagen beginnen: Sie lernen verschiedene Typen und Typ-Operatoren von TypeScript kennen und erfahren, wofür und wie sie benutzt werden.
• Fortgeschrittene Themen erarbeiten: Sie verstehen TypeScripts ausgeklügeltes Typsystem, wie Sie Fehler sicher behandeln und asynchrone Programme entwickeln.
• In die Praxis eintauchen: Sie verwenden TypeScript mit den Frontend- und Backend-Frameworks Ihrer Wahl, migrieren JavaScript-Projekte zu TypeScript und führen TypeScript-Anwendungen im Produktivbetrieb aus.

KAPITEL 1

Einführung

Sie haben sich also entschieden, ein Buch über TypeScript zu kaufen. Warum?

Vielleicht haben Sie einfach die Nase voll von seltsamen JavaScript-Fehlern wie cannot read property blah of undefined. Oder Sie haben gehört, dass Applikationen mit TypeScript besser skalierbar sind und wollten einfach mal wissen, ob das wirklich stimmt. Oder Sie programmieren funktional und wollten den nächsten logischen Schritt tun. Oder Ihrem Chef hat es so sehr gestunken, dass Ihr Code in der Produktion immer wieder für Fehler sorgte, dass er Ihnen dieses Buch zu Weihnachten geschenkt hat (sagen Sie Bescheid, wenn es zu sehr wehtut ...).

Egal, was Ihre Gründe sind: Was Sie gehört haben, ist wahr. TypeScript wird die nächste Generation von Web-Applikationen, mobiler Apps, NodeJS-Projekten und »Internet of Things (IoT)«-Geräten antreiben. TypeScript macht Ihre Programme sicherer, indem es auf häufige Fehler überprüft, als Dokumentation für Sie und Ihre Wartungsprogrammierer dient, Refaktorierungen schmerzlos macht und mindestens die Hälfte Ihrer Unit Tests (»Was für Unit Tests?«) unnötig macht. TypeScript wird Ihre Produktivität als Programmierer verdoppeln und garantiert Ihnen eine Verabredung mit dem (oder der) Barista von gegenüber.

Bevor Sie gleich blindlings über die Straße rennen, wollen wir die Dinge zunächst etwas genauer betrachten. Wir beginnen mit der Frage: »Was meine ich eigentlich mit ›sicherer‹?« Ich meine natürlich Typsicherheit.

Typsicherheit

Die Verwendung von Typen, um zu verhindern, dass Programme ungültige Aktionen ausführen.¹

Hier ein paar Beispiele für ungültige Operationen:

• Die Multiplikation einer Zahl mit einer Liste
• Der Aufruf einer Funktion mit einer Liste aus Strings, wenn eigentlich eine Liste mit Objekten gebraucht wird
• Der Aufruf einer nicht vorhandenen Methode an einem Objekt
• Der Import eines Moduls, das kürzlich an einem anderen Ort abgelegt wurde

Manche Sprachen versuchen, solche Fehler, so gut es geht, abzufangen und zu umgehen. Sie versuchen herauszufinden, was Sie beim Auftreten des Fehlers tatsächlich tun wollten. Schließlich tun auch Sie Ihr Bestes, oder? Nehmen Sie beispielsweise dieses JavaScript-Beispiel:

3 + [] // Ergibt den String "3"

let obj = {}

obj.foo // Ergibt undefined

function a(b) {

return b/2

}

a("z") // Ergibt NaN

Wenn Sie etwas offensichtlich Ungültiges tun, löst JavaScript keine Ausnahme aus. Stattdessen versucht es, das Beste aus der Situation zu machen, und vermeidet Ausnahmen, soweit wie möglich. Ist JavaScript hilfreich? Sicherlich! Hilft es Ihnen, die Fehler schneller zu finden? Wahrscheinlich nicht.

Jetzt stellen Sie sich vor, JavaScript würde mehr Ausnahmen auslösen, anstatt stillschweigend zu versuchen, das Beste aus den Dingen zu machen, die es zur Verfügung hat. Dann würden wir möglicherweise Rückmeldungen wie diese bekommen:

3 + [] // Fehler: Wollten Sie wirklich eine Zahl und ein Array addieren?

let obj = {}

obj.foo // Fehler: Sie haben vergessen, die Eigenschaft "foo" an obj zu

// definieren.

function a(b) {

return b/2

}

a("z") // Fehler: Die Funktion "a" erwartet eine Zahl,

// Sie haben aber einen String übergeben.

Verstehen Sie mich nicht falsch: Der Versuch, Ihre Fehler auszubügeln, ist für eine Programmiersprache eine tolle Eigenschaft (es wäre schön, wenn es das nicht nur für Programme gäbe). Für JavaScript trennt dieses Vorgehen jedoch die Verbindung zwischen dem Moment, wenn der Fehler auftritt, und dem, wenn Sie herausfinden, dass Ihr Code einen Fehler enthält. Das heißt, oftmals hören Sie erst von jemand anderem, dass Sie einen Fehler gemacht haben.

Die Frage ist also: Wann genau teilt Ihnen JavaScript mit, dass Sie einen Fehler gemacht haben?

Richtig. Erst wenn Sie das Programm tatsächlich ausführen. Das kann beispielsweise sein, wenn Sie das Programm in einem Browser testen, ein Benutzer Ihre Website besucht oder Sie einen Unit-Test durchführen. Wenn Sie diszipliniert sind und viele Unit- und End-to-end-Tests schreiben, Ihren Code vor der Veröffentlichung einer strengen Überprüfung und internen Tests unterziehen, finden Sie den Fehler hoffentlich, bevor es die Benutzer tun. Was aber, wenn nicht?

Da kommt TypeScript ins Spiel. Noch cooler als die Tatsache, dass TypeScript Ihnen hilfreiche Fehlermeldungen anzeigt, ist, wann es das tut: TypeScript zeigt Ihnen die Fehlermeldungen in Ihrem Codeeditor. Während Sie schreiben. Sie müssen sich also nicht mehr auf Unit Tests, Smoke Tests oder Ihre Mitarbeiter verlassen, um diese Fehler zu finden: TypeScript findet sie für Sie und warnt Sie bereits beim Schreiben des Programms. Sehen wir mal, was TypeScript zu unseren vorigen Beispielen zu sagen hat:

3 + [] // Error TS2365: Operator '+' cannot be applied to types '3'

// and 'never[]'.

let obj = {}

obj.foo // Error TS2339: Property 'foo' does not exist on type '{}'.

function a(b: number) {

return b / 2

}

a("z") // Error TS2345: Argument of type '"z"' is not assignable to

// parameter of type 'number'.

TypeScript hilft aber nicht nur, ganze Klassen von Typ-bezogenen Fehlern zu vermeiden. Es verändert die Art, wie Sie Code schreiben. Sie werden Programme zunächst auf Typebene skizzieren, um sie dann auf Werteebene mit Inhalt zu füllen.² Sie werden bereits beim Schreiben des Programms an mögliche Sonderfälle denken, und nicht erst wenn das Programm schon fertig ist. Sie werden lernen, Programme zu entwickeln, die einfacher, schneller, verständlicher und wartbarer sind.

Sind Sie für Ihre Reise bereit? Dann los!

KAPITEL 2

TypeScript aus der Vogelperspektive

In den folgenden Kapiteln stelle ich Ihnen TypeScript vor, gebe Ihnen einen Überblick über die Funktionsweise des TypeScript-Compilers (TSC) und zeige Ihnen, welche Fähigkeiten TypeScript besitzt und welche Muster Sie damit entwickeln können. Wir beginnen mit dem Compiler.

Der Compiler

Je nachdem, welche Programmiersprache(n) Sie bereits benutzt haben (d.h., bevor Sie dieses Buch gekauft und sich für ein Leben in Sicherheit entschieden haben), haben Sie vermutlich ein anderes Verständnis davon, wie Programme funktionieren. Im Vergleich zu anderen beliebten Sprachen wie JavaScript oder Java funktioniert TypeScript eher ungewöhnlich. Daher ist es sinnvoll, erst einmal auf dem gleichen Stand zu sein, bevor wir weitermachen.

Beginnen wir ganz allgemein: Programme sind Dateien, die von Ihnen – den Programmierern – geschriebenen Text enthalten. De...

Inhaltsverzeichnis

• Cover
• Titel
• Impressum
• Widmung
• Inhalt
• Vorwort
• 1 Einführung
• 2 TypeScript aus der Vogelperspektive
• 3 Alles über Typen
• 4 Funktionen
• 5 Klassen und Interfaces
• 6 Fortgeschrittene Typen
• 7 Fehlerbehandlung
• 8 Asynchrone Programmierung, Nebenläufigkeit und Parallelismus
• 9 Frontend- und Backend-Frameworks
• 10 Namensräume.Module
• 11 Zusammenarbeit mit JavaScript
• 12 TypeScript-Projekte erstellen und ausführen
• 13 Abschluss
• A Typoperatoren
• B Hilfsfunktionen für Typen
• C Geltungsbereiche für Deklarationen
• D Rezepte für das Schreiben von Deklarationsdateien für JavaScript-Module von Drittanbietern
• E Triple-Slash-Direktiven
• F TSC-Compiler-Flags für mehr Sicherheit
• G TSX
• Fußnoten
• Index
• Über den Autor