Pro TypeScript 2nd Edition: 应用级JavaScript开发

需积分: 9 176 浏览量更新于2024-07-17 收藏 4.67MB PDF 举报

"Pro TypeScript 2nd.2018.pdf" 本书《Pro TypeScript 2nd.2018》由Steve Fenton撰写，是关于应用规模JavaScript开发的第二版指南，专注于TypeScript语言的深入理解和实践。TypeScript是JavaScript的一个超集，它引入了静态类型系统、类和接口等特性，旨在提升大型JavaScript项目的可维护性和开发效率。这本书针对那些希望通过TypeScript进行大规模应用程序开发的开发者提供全面的指导。 TypeScript的主要知识点包括： 1. **类型系统**：TypeScript引入了静态类型，允许开发者在编译时检查变量、函数参数和返回值的类型，从而减少运行时错误。类型注解（如`let variable: string`）是其核心特性，有助于代码的自我文档化和增强IDE的智能感知功能。 2. **接口（Interfaces）**：TypeScript的接口定义了一种类型规范，用于描述对象的结构。它们可以用来确保对象具有预期的属性和方法，提高了代码的可预测性和可扩展性。 3. **类（Classes）**：TypeScript支持面向对象编程的类语法，允许开发者创建带有属性和方法的类，并实现继承和多态，这对于构建复杂的软件架构非常有用。 4. **泛型（Generics）**：泛型是一种创建可重用且类型安全的代码的方法，可以在不指定具体类型的情况下定义函数或容器。这增强了代码的灵活性，同时保持了类型安全性。 5. **模块（Modules）**：TypeScript的模块系统允许开发者将代码组织成独立的文件，通过导入和导出实现代码的隔离和重用，遵循AMD、CommonJS或ES6模块规范。 6. **装饰器（Decorators）**：装饰器是一种元编程机制，可以在不修改源代码的情况下向对象添加附加行为或元数据。它们常用于实现依赖注入、日志记录、性能追踪等功能。 7. **枚举（Enums）**：枚举是TypeScript中用于表示有限集合的常量，便于处理和表示一组相关的值。 8. **高级类型**：包括联合类型、交叉类型、类型保护和类型守卫等，这些高级类型工具能帮助开发者编写更复杂的类型定义。 9. **编译配置**：TypeScript的`.tsconfig`文件允许开发者自定义编译选项，如是否启用严格模式、目标ES版本等，以适应不同项目的需求。 10. **与JavaScript的互操作性**：TypeScript最终会编译成纯JavaScript，因此它能够无缝地与现有的JavaScript库和框架集成。本书还可能涵盖了TypeScript的最新发展，例如对ES2015+特性的支持、对异步编程的改进以及对构建工具和测试框架的集成。通过阅读本书，读者可以学习如何在实际项目中有效地使用TypeScript，提升开发效率和代码质量，实现大规模的JavaScript应用开发。

xix

Introduction

Atwood’s Law: any application that can be written in JavaScript will eventually be written

in JavaScript.

—Jeff Atwood

TypeScript is a language created and maintained by Microsoft, and released under an open-source Apache

2.0 License (2004). The language is focused on making the development of JavaScript programs scale to

many thousands of lines of code. In fact, Microsoft has written both the Azure Management Portal (1.2

million lines of code) and the Visual Studio Code editor (300,000 lines of code) in TypeScript. The language

attacks the large-scale JavaScript programming problem by offering better design-time tooling, compile-

time checking, and dynamic module loading at runtime.

As you might expect from a language created by Microsoft, there is excellent support for TypeScript

within Visual Studio, but plenty of other development tools have also added support for the language,

including VS Code, WebStorm, Eclipse, Sublime Text, Vi, Atom, IntelliJ, and Emacs among others. The

widespread support from these tools as well as the permissive open-source license makes TypeScript a

viable option outside of the traditional Microsoft ecosystem.

The TypeScript language is a typed superset of JavaScript, which is compiled to plain JavaScript in

the flavor of your choosing. This makes programs written in TypeScript highly portable as they can run

on almost any machine — in web browsers, on web servers, and even in native applications on operating

systems that expose a JavaScript API, such as WinJS.

The language features found in TypeScript can be divided into three categories based on their

relationship to JavaScript (see Figure1). The first two sets are related to versions of the ECMA-262

ECMAScript Language Specification, which is the official specification for JavaScript. The ECMAScript 5

specification forms the basis of TypeScript and supplies the largest number of features in the language.

Subsequent versions of the ECMAScript specification are rolled into TypeScript releases, often as early

previews that feature down-level compilation to older versions of the specication. The third and final set of

language features includes items that are not planned to become part of the ECMAScript standard, such as

generics and type annotations. All the additional features of TypeScript can be output to a number of widely

supported versions of JavaScript.

TypeScript has several native frameworks, including Angular, Ionic, RxJs 5, and Dojo 2. Additionally,

because TypeScript is such a close relative of JavaScript, you can consume the myriad of existing libraries

and frameworks written in JavaScript; Aurelia, Backbone, Bootstrap, Durandal, jQuery, Knockout,

Modernizr, PhoneGap, Prototype, Raphael, React, Underscore, Vue, and many more are all usable in

TypeScript programs. Correspondingly, once your TypeScript program has been compiled it can be

consumed from any JavaScript program too.

TypeScript's similarity to JavaScript is beneficial if you already have experience with JavaScript or other

C-like languages. The similarity also aids the debugging process as the generated JavaScript correlates

closely to the original TypeScript code. Source maps can also be generated to aid debugging, with browser

developer tools displaying your TypeScript code during in-browser debugging.

■ IntroduCtIon

xxi

Chapter 4: Object Orientation in TypeScript: introduces the important elements

of object orientation and contains examples of design patterns and SOLID

principles in TypeScript. This chapter also introduces the concept of mixins with

practical examples.

Chapter 5: Understanding the Runtime: describes the impact of scope, callbacks,

events, and extensions on your program.

Chapter 6: Running TypeScript in a Browser: a thorough walkthrough including

working with the Document Object Model, AJAX, session and local storage,

IndexedDB, geolocation, hardware sensors, and web workers as well as

information on packaging your program for the Web.

Chapter 7: Running TypeScript on a Server: an explanation of running programs

on a JavaScript server with examples for Node and a basic end-to-end example

application written in Express and Mongoose.

Chapter 8: Exceptions, Memory, and Performance: describes exceptions and

exception handling with information on memory management and garbage

collection. It includes a simple performance testing utility to exercise and

measure your program.

Chapter 9: Using JavaScript Libraries: explains how to consume any of the

millions of JavaScript libraries from within your TypeScript program, including

information on how to create your own type definitions and how to migrate your

JavaScript program to TypeScript.

Chapter 10: Automated Testing: a walkthrough of automated testing in your

TypeScript program with examples written using the Jest framework.

Appendix 1: JavaScript Quick Reference: an introduction to the essential

JavaScript features for anyone who needs to brush up on their JavaScript before

diving into TypeScript.

Appendix 2: TypeScript Compiler: explains how to use the compiler on the

command line and describes many of the flags you can pass to customize your

build.

Appendix 3: Bitwise Flags: dives into the details of bitwise flags including

the low-level details of how they work as well as examples using TypeScript

enumerations.

Appendix 4: Coding Katas: introduces the concept of coding katas and provides

an example for you to try, along with techniques you can use to make katas more

effective.

The TypeScript Components

TypeScript is made up of three distinct but complementary parts, which are shown in Figure2.

■ IntroduCtIon

xxii

Figure 2. The TypeScript components

The language consists of the new syntax, keywords, and type annotations. As a programmer, the

language will be the component you will become most familiar with. Understanding how to supply type

information is an important foundation for the other components because the compiler and language

service are most effective when they understand the complex structures you use within your program.

The compiler performs the type erasure and code transformations that convert your TypeScript code

into JavaScript. It will emit warnings and errors if it detects problems and can perform additional tasks such

as combining the output into a single file, generating source maps, and more.

The language service provides type information that can be used by development tools to supply

autocompletion, type hinting, refactoring options, and other creative features based on the type information

that has been gathered from your program.

Compile or Transpile?

The term transpiling has been around since the last century, but there is some confusion about its meaning.

In particular, there has been some confusion between the terms compilation and transpilation. Compilation

describes the process of taking source code written in one language and converting it into another language.

Transpilation is a specific kind of compilation and describes the process of taking source code written in one

language and transforming it into another language with a similar level of abstraction. So, you might compile

a high-level language into an assembly language, but you would transpile TypeScript to JavaScript as they

are similarly abstracted.

Other common examples of transpilation include C++ to C, CoffeeScript to JavaScript, Dart to

JavaScript, and PHP to C++.

Which Problems Does TypeScript Solve?

Since its first beta release in 1995, JavaScript (or LiveScript as it was known at the time it was released) has

spread like wildfire. Nearly every computer in the world has a JavaScript interpreter installed. Although it

is perceived as a browser-based scripting language, JavaScript has been running on web servers since its

inception, supported on Netscape Enterprise Server, IIS (since 1996), and on Node since 2011. JavaScript can

even be used to write native applications on operating systems such as Windows.

■ IntroduCtIon

xxiii

Despite its popularity, it hasn't received much respect from developers — possibly because it contains

many snares and traps that can entangle a large program much like the tar pit pulling the mammoth to

its death, as described by Fred Brooks (1975). If you are a professional programmer working with large

applications written in JavaScript, you will almost certainly have rubbed up against problems once your

program chalked up a few thousand lines. You may have experienced naming conflicts, substandard

programming tools, complex modularization, unfamiliar prototypal inheritance that makes it hard to reuse

common design patterns easily, and difficulty keeping a readable and maintainable code base. TypeScript

solves problems such as these.

Because JavaScript has a C-like syntax, it looks familiar to most programmers. This is one of JavaScript's

key strengths, but it is also the cause of many surprises, especially in the following areas:

• Prototypal inheritance

• Equality and type juggling

• Management of modules

• Scope

• Lack of types

Typescript solves or eases these problems in several ways. Each of these topics is discussed in this

introduction.

Prototypal Inheritance

Prototype-based programming is a style of object-oriented programming that is mainly found in interpreted

dynamic languages. It was first used in a language called Self, created by David Ungar and Randall Smith in

1986, but it has been used in a selection of languages since then. Of these prototypal languages, JavaScript

is by far the most widely known, although this has done little to bring prototypal inheritance into the

mainstream. Despite its validity, prototype-based programming is somewhat esoteric; class-based object

orientation is far more commonplace and will be familiar to most programmers.

TypeScript solves this problem by adding classes, namespaces, modules, and interfaces. This allows

programmers to transfer their existing knowledge of objects and code structure from other languages,

including implementing interfaces, inheritance, and code organization. Classes and modules are an early

preview of JavaScript proposals and because TypeScript can compile to earlier versions of JavaScript, it

allows you to use these features independent of support for the newer ECMAScript specifications. All these

features are described in detail in Chapter 1.

Equality and Type Juggling

JavaScript has always supported dynamically typed variables, and as a result it expends effort at runtime

working out types and coercing them into other types on the fly to make statements work that in a statically

typed language would cause an error.

The most common type coercions involve strings, numbers, and Boolean target types. Whenever

you attempt to concatenate a value with a string, the value will be converted to a string, if you perform a

mathematical operation an attempt will be made to turn the value into a number, and if you use any value

in a logical operation there are special rules that determine whether the result will be true or false. When an

automatic type conversion occurs, it is commonly referred to as type juggling.

In some cases, type juggling can be a useful feature, in particular in creating shorthand logical

expressions. In other cases, type juggling hides an accidental use of different types and causes unintended

behavior as discussed in Chapter 1. A common JavaScript example is shown in Listing 1.

剩余303页未读，继续阅读

brucejing2

粉丝: 0
资源: 21

Pro TypeScript 2nd Edition: 应用级JavaScript开发

typescript-handbook.pdf

TypeScript Deep Dive.pdf

Typescript学习PDF

typescript ...

typescript ...关键字

Typescript...

typescript ...运算符

typescript ...defaultSetting

typescript 4.x Property 'isJSDocContainer' does not exist on type 'typeof ts'.ts

typescript module ... has no default expodt

最新资源