Pro TypeScript Application-Scale JavaScript Development — Second Edition — Steve Fenton Pro TypeScript Application-Scale JavaScript Development Second Edition Steve Fenton Pro TypeScript: Application-Scale JavaScript Development Steve Fenton Basingstoke, United Kingdom ISBN-13 (pbk): 978-1-4842-3248-4 ISBN-13 (electronic): 978-1-4842-3249-1 https://doi.org/10.1007/978-1-4842-3249-1 Library of Congress Control Number: 2017961729 Copyright © 2018 by Steve Fenton This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher's location, in its current version, and permission for use must always be obtained from Springer. Permissions for use may be obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecution under the respective Copyright Law. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Cover image designed by Freepik Managing Director: Welmoed Spahr Editorial Director: Todd Green Acquisitions Editor: Gwenan Spearing Development Editor: Laura Berendson Technical Reviewer: Rich O’Kelly, Martin Milsom, Dan Horrocks-Burgess, Jamie Wright Coordinating Editor: Nancy Chen Copy Editor: Karen Jameson Compositor: SPi Global Indexer: SPi Global Artist: SPi Global Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected], or visit http://www.apress.com/ rights-permissions. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book's product page, located at www.apress.com/9781484232484. For more detailed information, please visit http://www.apress.com/source-code. Printed on acid-free paper For Rebecca, Lily, Deborah, Victoria, and Mum Contents About the Author �����������������������������������������������������������������������������������������������������xv Acknowledgments �������������������������������������������������������������������������������������������������xvii Introduction ������������������������������������������������������������������������������������������������������������xix ■ Chapter 1: TypeScript Language Features �������������������������������������������������������������1 JavaScript Is Valid TypeScript �������������������������������������������������������������������������������������������2 Variables ���������������������������������������������������������������������������������������������������������������������������4 Constants �������������������������������������������������������������������������������������������������������������������������6 Types ��������������������������������������������������������������������������������������������������������������������������������6 Type Annotations ������������������������������������������������������������������������������������������������������������������������������������7 Primitive Types ���������������������������������������������������������������������������������������������������������������������������������������9 Object and Dynamic Types ��������������������������������������������������������������������������������������������������������������������10 Enumerations����������������������������������������������������������������������������������������������������������������������������������������10 Union Types ������������������������������������������������������������������������������������������������������������������������������������������13 Literal Types ������������������������������������������������������������������������������������������������������������������������������������������14 Intersection Types ���������������������������������������������������������������������������������������������������������������������������������15 Arrays ���������������������������������������������������������������������������������������������������������������������������������������������������15 Tuple Types �������������������������������������������������������������������������������������������������������������������������������������������17 Dictionary Types �����������������������������������������������������������������������������������������������������������������������������������18 Mapped Types ���������������������������������������������������������������������������������������������������������������������������������������19 Type Assertions �������������������������������������������������������������������������������������������������������������������������������������20 Type Guards ������������������������������������������������������������������������������������������������������������������������������������������21 Discriminated Unions����������������������������������������������������������������������������������������������������������������������������23 v ■ Contents Operators ������������������������������������������������������������������������������������������������������������������������24 Increment and Decrement ��������������������������������������������������������������������������������������������������������������������24 Binary Operators �����������������������������������������������������������������������������������������������������������������������������������25 Bitwise Operators ���������������������������������������������������������������������������������������������������������������������������������26 Logical Operators ���������������������������������������������������������������������������������������������������������������������������������26 Type Operators ��������������������������������������������������������������������������������������������������������������������������������������30 Destructuring ����������������������������������������������������������������������������������������������������������������������������������������30 Spread Operator �����������������������������������������������������������������������������������������������������������������������������������34 Functions ������������������������������������������������������������������������������������������������������������������������35 Optional Parameters �����������������������������������������������������������������������������������������������������������������������������36 Default Parameters �������������������������������������������������������������������������������������������������������������������������������37 Rest Parameters �����������������������������������������������������������������������������������������������������������������������������������38 Overloads ����������������������������������������������������������������������������������������������������������������������������������������������38 Specialized Overload Signatures ����������������������������������������������������������������������������������������������������������39 Arrow Functions �����������������������������������������������������������������������������������������������������������������������������������41 Function Currying ���������������������������������������������������������������������������������������������������������������������������������42 Interfaces �����������������������������������������������������������������������������������������������������������������������44 Classes ���������������������������������������������������������������������������������������������������������������������������47 Constructors �����������������������������������������������������������������������������������������������������������������������������������������47 Access Modifiers ����������������������������������������������������������������������������������������������������������������������������������49 Properties and Methods �����������������������������������������������������������������������������������������������������������������������49 Class Heritage ��������������������������������������������������������������������������������������������������������������������������������������51 Abstract Classes �����������������������������������������������������������������������������������������������������������������������������������53 Scope ����������������������������������������������������������������������������������������������������������������������������������������������������54 Type Information �����������������������������������������������������������������������������������������������������������������������������������56 Generics �������������������������������������������������������������������������������������������������������������������������58 Generic Functions ���������������������������������������������������������������������������������������������������������������������������������58 Generic Interfaces ��������������������������������������������������������������������������������������������������������������������������������59 Generic Classes ������������������������������������������������������������������������������������������������������������������������������������60 Type Constraints �����������������������������������������������������������������������������������������������������������������������������������61 vi ■ Contents TypeScript Futures ���������������������������������������������������������������������������������������������������������61 Summary ������������������������������������������������������������������������������������������������������������������������62 Key Points ����������������������������������������������������������������������������������������������������������������������62 ■ Chapter 2: Code Organization ������������������������������������������������������������������������������63 Namespaces �������������������������������������������������������������������������������������������������������������������64 Modules ��������������������������������������������������������������������������������������������������������������������������68 Module Re-Exporting ����������������������������������������������������������������������������������������������������������������������������70 Default Exports �������������������������������������������������������������������������������������������������������������������������������������70 Exports Object ��������������������������������������������������������������������������������������������������������������������������������������71 Module Loading ������������������������������������������������������������������������������������������������������������������������������������71 Mixing Namespace and Modules �����������������������������������������������������������������������������������73 Packaging �����������������������������������������������������������������������������������������������������������������������74 Decorators ����������������������������������������������������������������������������������������������������������������������76 Configurable Decorators �����������������������������������������������������������������������������������������������������������������������78 Class Decorators �����������������������������������������������������������������������������������������������������������������������������������79 Property Decorators ������������������������������������������������������������������������������������������������������������������������������80 Summary ������������������������������������������������������������������������������������������������������������������������81 Key Points ����������������������������������������������������������������������������������������������������������������������82 ■ Chapter 3: The Type System ��������������������������������������������������������������������������������83 Type Systems �����������������������������������������������������������������������������������������������������������������83 Optional Static Types ������������������������������������������������������������������������������������������������������84 Structural Typing ������������������������������������������������������������������������������������������������������������86 Type Erasure �������������������������������������������������������������������������������������������������������������������88 Type Inference ����������������������������������������������������������������������������������������������������������������89 Best Common Type �������������������������������������������������������������������������������������������������������������������������������90 Contextual Types �����������������������������������������������������������������������������������������������������������������������������������91 Widened Types ��������������������������������������������������������������������������������������������������������������������������������������91 When to Annotate ���������������������������������������������������������������������������������������������������������������������������������91 Duplicate Identifiers �������������������������������������������������������������������������������������������������������92 Type Checking ����������������������������������������������������������������������������������������������������������������93 vii ■ Contents Ambient Declarations �����������������������������������������������������������������������������������������������������95 Declaration Files �����������������������������������������������������������������������������������������������������������������������������������96 Definitely Typed ������������������������������������������������������������������������������������������������������������������������������������97 Summary ������������������������������������������������������������������������������������������������������������������������97 Key Points ����������������������������������������������������������������������������������������������������������������������97 ■ Chapter 4: Object Orientation in TypeScript ��������������������������������������������������������99 Object Orientation in TypeScript �����������������������������������������������������������������������������������100 Open Recursion ����������������������������������������������������������������������������������������������������������������������������������100 Encapsulation �������������������������������������������������������������������������������������������������������������������������������������102 Delegation ������������������������������������������������������������������������������������������������������������������������������������������104 Polymorphism �������������������������������������������������������������������������������������������������������������������������������������106 SOLID Principles �����������������������������������������������������������������������������������������������������������108 The Single Responsibility Principle (SRP) �������������������������������������������������������������������������������������������109 The Open–Closed Principle (OCP) �������������������������������������������������������������������������������������������������������110 The Liskov Substitution Principle (LSP) ����������������������������������������������������������������������������������������������111 The Interface Segregation Principle (ISP) ������������������������������������������������������������������������������������������112 The Dependency Inversion Principle (DIP) ������������������������������������������������������������������������������������������114 Design Patterns ������������������������������������������������������������������������������������������������������������115 The Strategy Pattern ���������������������������������������������������������������������������������������������������������������������������116 The Abstract Factory Pattern ��������������������������������������������������������������������������������������������������������������116 Practical Example �������������������������������������������������������������������������������������������������������������������������������117 Mixins ���������������������������������������������������������������������������������������������������������������������������121 TypeScript Mixins �������������������������������������������������������������������������������������������������������������������������������121 When to Use Mixins ����������������������������������������������������������������������������������������������������������������������������123 Restrictions �����������������������������������������������������������������������������������������������������������������������������������������123 Real Mixins �����������������������������������������������������������������������������������������������������������������������������������������125 Summary ����������������������������������������������������������������������������������������������������������������������126 Key Points ��������������������������������������������������������������������������������������������������������������������127 viii ■ Contents ■ Chapter 5: Understanding the Runtime �������������������������������������������������������������129 Runtime Features ���������������������������������������������������������������������������������������������������������129 Scope ���������������������������������������������������������������������������������������������������������������������������131 Callbacks ��������������������������������������������������������������������������������������������������������������������������������������������134 Passing Functions as Arguments��������������������������������������������������������������������������������������������������������137 Promises ���������������������������������������������������������������������������������������������������������������������������������������������138 Events ���������������������������������������������������������������������������������������������������������������������������147 TypeScript’s Custom-Event Mechanism ���������������������������������������������������������������������������������������������149 Event Phases ��������������������������������������������������������������������������������������������������������������������������������������151 Extending Objects ��������������������������������������������������������������������������������������������������������151 Extending the Prototype ���������������������������������������������������������������������������������������������������������������������152 Sealing Objects �����������������������������������������������������������������������������������������������������������������������������������154 Alternatives to Extending ��������������������������������������������������������������������������������������������������������������������155 Summary ����������������������������������������������������������������������������������������������������������������������156 Key Points ��������������������������������������������������������������������������������������������������������������������157 ■ Chapter 6: Running TypeScript in a Browser �����������������������������������������������������159 The Anatomy of a Web Browser �����������������������������������������������������������������������������������159 Reflows and Frames Per Second ��������������������������������������������������������������������������������������������������������160 The Interesting Components ���������������������������������������������������������������������������������������������������������������162 The Document Object Model ����������������������������������������������������������������������������������������164 Finding Elements ��������������������������������������������������������������������������������������������������������������������������������165 Changing Elements �����������������������������������������������������������������������������������������������������������������������������166 Events �������������������������������������������������������������������������������������������������������������������������������������������������167 Frameworks and Libraries ������������������������������������������������������������������������������������������������������������������169 Network ������������������������������������������������������������������������������������������������������������������������170 AJAX ���������������������������������������������������������������������������������������������������������������������������������������������������170 WebSockets ����������������������������������������������������������������������������������������������������������������������������������������173 Real-Time Communications ���������������������������������������������������������������������������������������������������������������173 ix ■ Contents Storage �������������������������������������������������������������������������������������������������������������������������174 Session Storage ����������������������������������������������������������������������������������������������������������������������������������174 Local Storage ��������������������������������������������������������������������������������������������������������������������������������������175 Storage Restrictions ���������������������������������������������������������������������������������������������������������������������������176 IndexedDB ������������������������������������������������������������������������������������������������������������������������������������������176 Storage Roundup ��������������������������������������������������������������������������������������������������������������������������������183 Geolocation ������������������������������������������������������������������������������������������������������������������183 Sensors ������������������������������������������������������������������������������������������������������������������������185 Battery Status �������������������������������������������������������������������������������������������������������������������������������������185 Proximity Sensor ��������������������������������������������������������������������������������������������������������������������������������187 Light Sensor ���������������������������������������������������������������������������������������������������������������������������������������188 Motion and Orientation �����������������������������������������������������������������������������������������������������������������������188 Other Device Sensors �������������������������������������������������������������������������������������������������������������������������189 Sensor Roundup ���������������������������������������������������������������������������������������������������������������������������������189 Web Workers ����������������������������������������������������������������������������������������������������������������190 Packaging Your Program ����������������������������������������������������������������������������������������������192 Summary ����������������������������������������������������������������������������������������������������������������������192 Key Points ��������������������������������������������������������������������������������������������������������������������192 ■ Chapter 7: Running TypeScript on a Server �������������������������������������������������������195 Install Node ������������������������������������������������������������������������������������������������������������������195 Creating a New Project �������������������������������������������������������������������������������������������������196 NPM ������������������������������������������������������������������������������������������������������������������������������196 Simple Node Program ��������������������������������������������������������������������������������������������������199 Request Information �����������������������������������������������������������������������������������������������������200 Using Express to Write Applications �����������������������������������������������������������������������������201 Simple Express Program ��������������������������������������������������������������������������������������������������������������������202 Multiple Routes �����������������������������������������������������������������������������������������������������������������������������������203 Handling Errors �����������������������������������������������������������������������������������������������������������������������������������203 Express Book Project ��������������������������������������������������������������������������������������������������������������������������205 Summary ����������������������������������������������������������������������������������������������������������������������216 Key Points ��������������������������������������������������������������������������������������������������������������������216 x
Description: