Today we're happy to announce our RC of TypeScript 2.5. To get started with the latest stable version of TypeScript, you can grab it through NuGet, or use the following command with npm:
npm install -g typescript@rc
Visual Studio 2015 users (who have Update 3) can install TypeScript 2.5 RC from here, and Visual Studio 2017 users using version 15.2 or later will be able to get TypeScript by simply installing it from here.
While TypeScript 2.5 will be available for other editors soon, in the meantime you can configure Visual Studio Code and Sublime Text to use a newer version. Other editors may have different approaches to trying TypeScript 2.5 RC out.
Let's dive in and get an overview of what's coming in TypeScript 2.5!
There are times when coding where you expect something might fail by throwing an error, but where you might not care what that error is. For example:
let contents;
try {
contents = fs.readFileSync(".config_file").toString('utf8');
}
catch (unusedError) {
// File might not exist, just fall back to some defaults.
contents = createDefaultContents();
}
Notice that unusedError
is never referenced in the above example.
TypeScript 2.5 introduces a late-stage ECMAScript feature to make the catch
binding optional in try
/catch
statements.
That means we can just omit unusedError
altogether:
let contents;
try {
contents = fs.readFileSync(".config_file").toString('utf8');
}
catch {
// File might not exist, just fall back to some defaults.
contents = createDefaultContents();
}
Thanks to Tingan Ho for his contribution on this feature!
When importing using the Node
module resolution strategy in TypeScript 2.5, the compiler will now check whether files originate from "identical" packages.
If a file originates from a package with a package.json
containing the same name
and version
fields as a previously encountered package, then TypeScript will redirect itself to the top-most package.
This helps resolve problems where two packages might contain identical declarations of classes, but which contain private
members that cause them to be structurally incompatible.
It also reduces the memory and runtime footprint of the compiler and language service.
TypeScript 2.5 brings the preserveSymlinks
flag, which parallels the behavior of the --preserve-symlinks
flag in Node.js.
This flag also exhibits the opposite behavior to Webpack's resolve.symlinks
option (i.e. setting TypeScript's preserveSymlinks
to true
parallels setting Webpack's resolve.symlinks
to false
, and vice-versa).
In this mode, references to modules and packages (e.g. import
s and /// <reference type="..." />
directives) are all resolved relative to the location of the symbolic link file, rather than relative to the path that the symbolic link resolves to.
For a more concrete example, we'll defer to the documentation on the Node.js website.
While we'll continue to improve TypeScript before the full 2.5 release, we also have a few other ideas for TypeScript 2.6 that are under way.
Some things we'll be working on in the meantime are improvements to TypeScript's --watch
mode, and integration with other tools that have file-watching functionality.
Our aim is to ensure that as codebases grow larger, TypeScript can give lightning-fast turnaround between the time that you save a file, and the time that you can reload your project.
You can keep an eye on our pull request for changes to --watch
for the work we've done so far.
Thanks for reading, and we hope you give our release candidate a try!
Should we mention that optional
catch
binding was a community contribution by tinganho?