1. Trang chủ
  2. » Công Nghệ Thông Tin

Pro TypeScript - Application-Scale JavaScript Development

304 49 0

Đang tải... (xem toàn văn)

Tài liệu hạn chế xem trước, để xem đầy đủ mời bạn chọn Tải xuống

THÔNG TIN TÀI LIỆU

Thông tin cơ bản

Định dạng
Số trang 304
Dung lượng 4,66 MB

Nội dung

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 https://doi.org/10.1007/978-1-4842-3249-1 ISBN-13 (electronic): 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 orders-ny@springer-sbm.com, 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 rights@apress.com, 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������������������������������������������������������������� JavaScript Is Valid TypeScript������������������������������������������������������������������������������������������� Variables��������������������������������������������������������������������������������������������������������������������������� Constants������������������������������������������������������������������������������������������������������������������������� Types�������������������������������������������������������������������������������������������������������������������������������� Type Annotations������������������������������������������������������������������������������������������������������������������������������������ Primitive Types��������������������������������������������������������������������������������������������������������������������������������������� 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 APPENDIX ■ TypeScript Compiler Unused Parameters The noUnusedParameters flag highlights function and method parameters that are not used This flag is trickier than many of the other code quality flags, as there may be cases where you want to ignore a parameter that is passed to a function You can use this flag until you come across this scenario, and then choose to remove it if causes you problems tsc noUnusedParameters true app.ts JavaScript Compilation If you are making the transition from JavaScript to TypeScript, these compiler options can help you bridge the gap when you have your code divided between the two languages Allow JavaScript The allowJs flag allows JavaScript files to be included in the compilation tsc allowJs true app.ts Check JavaScript The checkJs flag can be used alongside the allowJs flag and causes the compiler to report errors in the JavaScript files tsc allowJs true checkJs true app.ts 272 APPENDIX Bitwise Flags As described in Chapter 1, you can use an enumeration to define bit flags Bit flags allow a series of items to be selected or deselected by switching individual bits in a sequence on and off To ensure that each value in an enumeration relates to a single bit, the numbering must follow the binary sequence whereby each value is a power of two, for example: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, and so on Listing A3-1 is a copy of the example from Chapter and shows bit flags in action In place of manually assigning powers-of-2, the shift operator is used to switch on the appropriate bit To add to this enum, you simply increment the right-hand operator by one for each new value When working with enums, the TypeScript compiler substitutes the expressions with plain numbers, whereas expressions elsewhere are left intact •

Ngày đăng: 30/12/2020, 15:21