With TypeScript 2.2, null checking is improved even further. TypeScript now flags expressions with nullable operands as compile-time errors.
TypeScript 2.2 loosens a restriction around dotted property access for types with explicit string index signatures. Fewer type annotations, less awkward code!
TypeScript 2.2 introduces a new type called
object which represents any non-primitive type. Don't confuse it with the existing
TypeScript 2.1 makes it a lot easier to work with untyped imports. Previously an error, these imports are now typed as
any and can be consumed painlessly.
TypeScript 2.1 differentiates between widening and non-widening literal types. Here's the difference between the two.
TypeScript 2.1 improves inference for literal types. Constant variables and read-only properties with literal initializers are now inferred to be of a literal type.
TypeScript 2.1 introduced mapped types, a powerful type system feature which allows you to create new types from existing ones by transforming properties.
TypeScript 2.1 introduces the
TypeScript 2.1 adds support for object rest and spread. You can work with rest/spread properties in a type-safe manner and downlevel both features to ES3.
TypeScript 2.1 adds a compiler option for importing helper functions from an external library. The helpers aren't injected into every file, resulting in smaller bundle sizes.
TypeScript 2.1 adds support for downleveling asynchronous functions to ES3/ES5. That way, you can run your
In TypeScript, there are multiple syntaxes for typing a function: method signatures, function type literals, and object type literals with call or construct signatures.
TypeScript 2.0 adds a "lib" compiler option that gives you more granular control over which built-in API declarations to include in your project.
TypeScript 2.0 introduces a new primitive type called "never", the type of values that never occur. It helps model the completion behavior of functions more accurately.
TypeScript 2.0 introduces more literal types. In addition to string literal types, we can now declare boolean, numeric, and enum literal types.
TypeScript 2.0 implements tagged union types, a special kind of union types that share a common property. Here's how you can use them in practice.
In TypeScript 2.0, the
readonly modifier was added to the language. It provides compile-time checking for unintended property assignments.
I'm excited to announce TypeScript Weekly, a weekly e-mail round-up of news and articles from the TypeScript community.
TypeScript 2.0 implements control flow based type analysis to determine the most specific type for a variable or parameter at any given location. An explanation.
TypeScript 2.0 adds support for non-nullable types, which help prevent an entire category of nullability errors at compile-time.
TypeScript allows us to specify multiple types for the same function. That way, we can accurately describe all possible overloads to the type system.
TypeScript can now independently transpile module formats and language targets. This way, Rollup can bundle ES2015 modules with ES5 code.
Visual Studio Code lets you specify which TypeScript version to use for tooling. Here's how to install a nightly build of TypeScript within a workspace.
TypeScript uses the
TypeScript 1.8 introduced string literal types, which allow for describing a set of possible string values for a given variable. Here's how to use them.
TypeScript 1.6 introduced the
--init flag for the
tsc executable to make it easier to set up new TypeScript projects. A short summary.
ECMAScript 2016 will likely standardize the exponentiation operator
**. Babel and TypeScript 1.7 already support it today.
ECMAScript 2015 allows a function to immediately destructure an object parameter. Here's the TypeScript syntax for typing the destructured properties.
TypeScript 1.5 has been released and ships with excellent ECMAScript 2015 support. Check out this new version and start using ECMAScript 2015 language features today.
Here's a compilation of my favorite session recordings from Build 2015. They're all about ASP.NET 5, C# 6, and TypeScript.
Angular 2 will be built on TypeScript, and the AtScript and TypeScript languages have been converged. Here's my take on this development.