it-ebooks - Book on TypeScript

This book follows familiar conventions. It addresses a few house keeping topics (like this very chapter) before properly introducing the language. That proper introduction starts off with simple topics (variables and data types) and works its way up to more complicated areas towards the end, such as generics.

This book won't go into any great detail about some topics. It's mostly concerned with the TypeScript language. As a result, the book does not provide step-by-step instructions for things like downloading TypeScript, installing it or configuring it. This and similar topics are covered in much better detail elsewhere. The final chapter, "Where Do I Go From Here?" points to some useful online resources focusing on these things.

This chapter covers the TypeScript development experience at a higher level. It answers questions such as:

• How do I write TypeScript applications in the first place?
• How does TypeScript run in the browser? (It doesn't, actually - it "transpiles" to JavaScript).
• How do I debug TypeScript apps?

The goal here to help ground you in the TypeScript "world" and describe the big picture of what's happens as you build TypeScript solutions. As you'll see, it's not very complicated.

TypeScript offers static types. You don't need to use them, but they are pretty helpful. This chapter starts off describing primitives (integers, strings and the like). It shows how declaring a variable's type helps good integrated development environments (IDEs) provide useful edit-time and compile-time feedback. We'll also take an opportunity to try and knock the TypeScript doubters off their perch with the strong typing goodness :).

The real world is complicated with complex data structures. TypeScript offers up the notion of interfaces to help us describe and manage them. This chapter introduces interfaces as a way to describe them starting with a flat object and moving on to a more complex JSON formatted response from a REST service.

TypeScript interfaces look and feel quite similar to interfaces in C# and Java. Generally speaking, interfaces are one of the backbones for many common and important design patterns and principles (think .

TypeScript offers several other ways to describe data. The chapter covers a few the most useful ones. These include:

• Enumerations: Assigning a label to a fixed value.
• Union Types: Define a new custom type that can hold two or more different types of values (including hard coded strings).

TypeScript provides other types, such as intersection types. This book takes a pass on those types for now - they feel like edge cases and although interesting and vitally useful when you can, you know, use them, most of us don't live on the edge.

Eliminate cumbersome string manipulation through the magic of template strings!

A detailed look into how TypeScript enhances standard JavaScript functions, including typed parameters, void return values, default function parameter values and more.

In addition, learn about Arrow Functions, often called "anonymous" or "lambda" functions.

TypeScript's static typing is, as they say, the bee's knees. Classes are the honey and these two chapters cover them pretty thoroughly:

• Class syntax
• Classes and interfaces
• Inheritance
• Abstract classes
• Static class members

Classes are an important building block for object oriented programming and TypeScript provides some solid support here.

Learn TypeScripts' version of generics as you know them from C# and Java.

A big long list of links that will hopefully lead you to TypeScript Greatness.

1. Isn't this always the case? No specific thing in this post-modern JavaScript world of ours is particularly complicated. It surely adds up though. 2. If you or someone you know is a TypeScript doubter, have a look at this chapter and its videos. Invest fifteen minutes or so here and then make up your mind about whether you want to invest more time after that. 3. As they say in the Old Country, "Come for the static typing, stay for the interfaces."

This book focuses on what consider to be the "main" bits of the TypeScript language. This narrows its scope and as a result, several topics that you might think a table of contents informed by common sense would include are not, in fact, included. To wit:

- History of TypeScript: It's an interesting topic.

• IDEs, deployment processes, webpack and task runners: This stuff is changing almost all the time, almost on a weekly basis. If I were to go all in, recommending some particular "TypeScript starter", it would be overtaken by newer, more streamlined solutions by the time you read my recommendation. In addition, the various starters you find on the interwebs tend to be framework-dependent. One family of starter projects supports Angular, another React, etc. This book isn't about those frameworks.

Beyond those non-language features, the book also ignores what I consider to be more advanced and/or situational topics. These are:

• Decorators. Decorators allow you to enhance the functionality a TypeScript artifact, such as a class or property. This assignment is done in a declarative manner and can enhance the targeted artifact without the knowledge or consent of the artifact. It's fairly meta, I know :). They are very powerful and may become a common thing for people to do over time. However, I think they are too advanced for my target audience. In the chapter, Continue Learning, I point out a few great blog posts and github projects that showcase them.

• Modules: Modules are not particularly complicated, but they mostly support bundling and other tooling (such as webpack). I'm on the fence as to whether I include a chapter on modules even as I write this. For now, I won't and I will refer you to good overviews of modules in the Continue Learning chapter.

• Mixins, intersection types and the like: I cover what I consider to be the "core" language features. As with decorators, some topics are fairly advanced while also being of use in a fairly narrow band of business applications. I didn't want to throw too many concepts out there. As a result, I leave these out of the book and invite you to learn about them from other sources.

That's enough on what's not covered. Let's move on to first big topic, how the heck does TypeScript work in the first place?

1. Of course, we don't necessarily share the same sense of what's common. If you don't like mine, write your own book :). Or, suggest I add more content via a github issue or email me directly. The intro chapter provides links to both of these options. 2. Did you know that TypeScript is over five years old? In the U.S., President Barack Obama was only just about to get re-elected to office when Microsoft released this language. Coincidence? Who knows? (Photo of Barack Obama from Peter Prodoehl @