Programmieren in TypeScript (eBook)

Skalierbare JavaScript-Applikationen entwickeln

Boris Cherny (Autor)

eBook Download: EPUB

2019 | 1. Auflage
328 Seiten
O'Reilly Verlag
978-3-96010-360-8 (ISBN)

Infos

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.

Boris Cherny ist Engineering- und Produkt-Leader bei Facebook. Zuvor arbeitete er im Risikokapital- und Ad Tech-Bereich sowie für verschiedene Start-ups. Er interessiert sich für diverse Programmiersprachen und statische Analyse und setzt sichfür Produkte und Services mit einer Benutzererfahrung ein, die die Anwender einfach lieben.In seiner Freizeit betreibt er das San Francisco TypeScript Meetup und schreibt in seinem persönlichen Blog performancejs.com. Auf GitHub ist er zu finden unter 'github.com/bcherny'.

Textauszug

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. Der Text wird von einem speziellen Programm namens Compiler untersucht, interpretiert (»geparst«) und in einen abstrakten Syntaxbaum (»abstract syntax tree«, AST) umgewandelt. Das ist eine Datenstruktur, die z.B. Leerzeichen, Kommentare und Ihre Meinung zur »Leerzeichen oder Tabs«-Debatte ignoriert. Danach konvertiert der Compiler den AST in eine niedriger angesiedelte (lower level) Form namens Bytecode. Diesen Bytecode können Sie dann einem Programm namens Runtime (oder Laufzeitumgebung) übergeben, das den Bytecode auswertet und das Ergebnis zurückgibt. Wenn Sie ein Programm ausführen, weisen Sie also tatsächlich die Laufzeitumgebung an, den Bytecode auszuführen, den der Compiler aus dem AST erzeugt hat, nachdem er diesen aus Ihrem Quellcode geparst hat. Die Details können sich unterscheiden, sind aber für die meisten Hochsprachen gleich oder zumindest ähnlich.

Noch einmal, die Schritte sind:

1. Programm (Quellcode) wird in einen AST geparst.
2. AST wird in Bytecode kompiliert.
3. Bytecode wird von der Laufzeitumgebung ausgeführt.

Eine Besonderheit von TypeScript ist, dass es nicht direkt in Bytecode kompiliert wird, sondern nach ... JavaScript-Code! Diesen können Sie dann wie üblich in Ihrem Browser, mit NodeJS oder manuell auf dem Papier ausführen (Letzteres nur für den Fall, dass Sie dies erst nach dem Aufstand der Maschinen lesen).

Sehr wahrscheinlich fragen Sie sich jetzt: »Moment mal! Im vorigen Kapitel haben Sie gesagt, dass TypeScript meinen Code sicherer macht. An welcher Stelle passiert das denn jetzt?«

Gute Frage: Den wichtigen Schritt habe ich übersprungen: Nachdem der TypeScript-Compiler den AST für Ihr Programm erzeugt, aber bevor es den Code ausgibt, führt er einen Typecheck (bitte merken Sie sich dieses Wort!) für Ihren Code aus.

Typechecker

Ein spezielles Programm, das sicherstellt, dass Ihr Code typsicher ist.

Das Typechecking ist die wahre Magie hinter TypeScript. So stellt TypeScript sicher, dass Ihr Programm wie erwartet funktioniert und es keine offensichtlichen Fehler gibt und dass der/die hübsche Barista von gegenüber Sie auch wirklich zurückruft. (Haben Sie etwas Geduld. Er/sie ist vermutlich bloß gerade sehr beschäftigt.)

Wenn wir das Typechecking und die Ausgabe von JavaScript mit einbeziehen, sieht die Kompilierung von TypeScript ungefähr so aus wie in Abbildung 2-1:

Abbildung 2-1: TypeScript kompilieren und ausführen

Die Schritte 1–3 werden von TSC übernommen, die Schritte 4–6 werden von der JavaScript-Runtime ausgeführt, die in Ihrem Browser, NodeJS oder einer anderen von Ihnen verwendeten JavaScript-Engine lebt.

JavaScript-Compiler und -Runtimes werden oft zu einem gemeinsamen Programm namens Engine kombiniert. Das ist das Ding, mit dem Sie als Programmierer normalerweise interagieren. So funktionieren beispielsweise V8 (die Engine hinter NodeJS, Chrome und Opera), SpiderMonkey (Firefox), JSCore (Safari) und Chakra (Edge). Sie geben JavaScript das Aussehen einer interpretierten Sprache.

In den Schritten 1 und 2 werden dabei die Typen Ihres Programms benutzt, in Schritt 3 jedoch nicht. Das darf man ruhig noch mal wiederholen: Wenn TSC Ihren Code von TypeScript nach JavaScript kompiliert, erfolgt dies ohne Prüfung der Typen.

Die Typen in Ihrem Programm haben also keinen Einfluss auf die von Ihrem Programm erzeugten Ausgaben und werden nur für das Typechecking verwendet. Dadurch ist es quasi narrensicher, mit den Typen Ihres Programms herumzuspielen, sie zu aktualisieren und zu verbessern, ohne dass Ihre Applikation dabei versehentlich Schaden nehmen könnte.

Das Typsystem

Alle modernen Sprachen besitzen das eine oder andere Typsystem.

Typsystem

Ein Satz von Regeln, die der Typechecker verwendet, um Typen in Ihrem Programm zuzuweisen.

Allgemein gibt es zwei Arten von Typsystemen: solche, in denen Sie dem Compiler in expliziter Syntax mitteilen müssen, welche Typen die Dinge haben, und Typsysteme, die Typen automatisch ableiten. Beide Ansätze haben ihre Vor- und Nachteile.1

TypeScript ist von beiden Arten der Typsysteme inspiriert: Sie können Ihre Typen explizit annotieren oder Sie können die meisten Typen automatisch ableiten lassen.

Um TypeScript Ihre Typen explizit mitzuteilen, verwenden Sie Annotationen. Diese haben die Form Wert: Typ und sagen dem Typechecker: »Der Typ dieses Werts lautet Typ. Am besten sehen wir uns hierzu ein paar Beispiele an (in den Kommentaren zu jeder Zeile sehen Sie die tatsächlich von TypeScript abgeleiteten Typen):

let a: number = 1 // a ist eine Zahl

let b: string = 'hello' // b ist ein String

let c: boolean[] = [true, false] // c ist ein Array mit booleschen Werten

Wollen Sie, dass TypeScript die Typen für Sie ableitet, können Sie die Annotationen weglassen und TypeScript die Arbeit erledigen lassen:

let a = 1 // a ist eine Zahl

let b = 'hello' // b ist ein String

let c = [true, false] // c ist ein Array mit booleschen Werten

Man erkennt schnell, wie gut TypeScript Typen für Sie ableiten kann. Auch wenn Sie die Annotationen weglassen, bleiben die Typen gleich! In diesem Buch werden wir Annotationen nur bei Bedarf verwenden. Ansonsten überlassen wir es nach Möglichkeit TypeScript, die Ableitungen für uns vorzunehmen.

Allgemein gilt es als guter Programmierstil, TypeScript so viele Typen wie möglich automatisch ableiten zu lassen und so wenig explizit typisierten Code wie möglich zu verwenden.

TypeScript im Vergleich mit JavaScript

Als Nächstes werfen wir einen genaueren Blick auf das Typsystem von TypeScript und sehen, welche Unterschiede und Gemeinsamkeiten im Vergleich zum Typsystem von JavaScript bestehen. Einen Überblick sehen Sie in Tabelle 2-1. Ein gutes Verständnis dieser Unterschiede ist der Schlüssel zum Verständnis der Funktionsweise von TypeScript.

Tabelle 2-1: Ein Vergleich der Typsysteme von JavaScript und TypeScript

Typsystem-Merkmal

JavaScript

TypeScript

Wie werden Typen begrenzt (bounding)?

Dynamisch

Statisch

Werden Typen automatisch konvertiert?

Ja

Nein (meistens)

Wann werden Typen überprüft?

Zur Laufzeit

Bei der Kompilierung

Zu welchem Zeitpunkt werden Fehler ausgelöst?

Zur Laufzeit (meistens)

Bei der Kompilierung (meistens)

Wie werden Typen begrenzt (bounding)

JavaScripts dynamische Typbindung bedeutet, dass es Ihr Programm ausführen muss, um die darin verwendeten Typen zu ermitteln. JavaScript kennt Ihre Typen vor der Ausführung des Programms nicht.

TypeScript ist eine graduell typisierte Sprache. Dadurch funktioniert TypeScript am besten, wenn es die Typen aller Dinge in Ihrem Programm bereits bei der Kompilierung kennt. Damit das Programm kompiliert werden kann, muss aber nicht zwingend alles bekannt sein. Selbst in einem nicht typisierten Programm kann TypeScript einige Typen für Sie ableiten und Fehler abfangen. Ohne dass alle Typen bekannt sind, ist es aber fast unvermeidlich, dass einige Fehler es bis zu...

Produkt-Details

• Erscheint lt. Verlag: 20.11.2019
• Reihe/Serie: Programmieren mit JavaScript
• Reihe/Serie: Programmieren mit JavaScript
• Übersetzer: Jørgen W. Lang
• Verlagsort: Heidelberg
• Sprache: deutsch
• Themenwelt: Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge
• Schlagworte: Angular • Fehlerbehandlung • Funktionen • JavaScript • Modulsystem • NPM • Operatoren • react • TSC • Typdeklaration • Typen • Typsicherheit • Typsystem
• ISBN-10: 3-96010-360-3 / 3960103603
• ISBN-13: 978-3-96010-360-8 / 9783960103608