{"id":1677,"date":"2016-07-11T16:28:51","date_gmt":"2016-07-11T16:28:51","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/typescript\/?p=705"},"modified":"2019-02-20T10:46:02","modified_gmt":"2019-02-20T17:46:02","slug":"announcing-typescript-2-0-beta-2","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/typescript\/announcing-typescript-2-0-beta-2\/","title":{"rendered":"Announcing TypeScript 2.0 Beta"},"content":{"rendered":"

Today we’re excited to roll out our beta release of TypeScript 2.0. If you’re not familiar with TypeScript yet, you can start learning it today on our website<\/a>.<\/p>\n

To get your hands on the beta, you can download TypeScript 2.0 Beta for Visual Studio 2015<\/a> (which will require VS 2015 Update 3<\/a>), or just run<\/p>\n

\n
npm install -g typescript@beta<\/pre>\n<\/div>\n
This release includes plenty of new features, such as our new workflow for getting .d.ts<\/code> files<\/a>, but here’s a couple more features just to get an idea of what else is in store.<\/p>\n
Non-nullable Types<\/h2>\n
null<\/code> and undefined<\/code> are two of the most common sources of bugs in JavaScript. Before TypeScript 2.0, null<\/code> and undefined<\/code> were in the domain of every<\/em> type. That meant that if you had a function that took a string<\/code>, you couldn’t be sure from the type alone of whether you actually had a string<\/code> – you might actually have null<\/code>.<\/p>\n
In TypeScript 2.0, the new --strictNullChecks<\/code> flag changes that. string<\/code> just means string<\/code> and number<\/code> means number<\/code>.<\/p>\n
\n
let<\/span> foo<\/span>: string<\/span> = null<\/span>; \/\/ Error!<\/span><\/pre>\n<\/div>\n
What if you wanted<\/em> to make something nullable? Well we’ve brought two new types to the scene: null<\/code> and undefined<\/code>. As you might expect, null<\/code> can only contain null<\/code>, and undefined<\/code> only contains undefined<\/code>. They’re not totally useful on their own, but you can use them in a union type to describe whether something could<\/em> be null<\/code>\/undefined<\/code>.<\/p>\n
\n
let<\/span> foo<\/span>: string<\/span> | <\/span>null<\/span> = null<\/span>; \/\/ Okay!<\/span><\/pre>\n<\/div>\n
Because you might often know better than the type system, we’ve also introduced a postfix !<\/code> operator that takes null<\/code> and undefined<\/code> out of the type of any expression.<\/p>\n
\n
declare<\/span> let<\/span> strs<\/span>: string<\/span>[] | undefined<\/span>;\n\n\/\/ Error! 'strs' is possibly undefined.<\/span>\nlet<\/span> upperCased<\/span> = strs.map(s => s.toUpperCase());\n\n\/\/ 'strs!' means we're sure it can't be 'undefined', so we can call 'map' on it.<\/span>\nlet<\/span> lowerCased<\/span> = strs!.map(s => s.toLowerCase());<\/pre>\n<\/div>\n
<\/a>Control Flow Analysis for Types<\/h2>\n
TypeScript’s support for handling nullable types is possible thanks to changes in how types are tracked throughout the program. In 2.0, we’ve started using control flow analysis to better understand what a type has to be at a given location. For instance, consider this function.<\/p>\n
\n
\/**<\/span>\n * @param recipients  An array of recipients, or a comma-separated list of recipients.<\/span>\n * @param body        Primary content of the message.<\/span>\n *\/<\/span>\nfunction<\/span> sendMessage<\/span>(recipients<\/span>: string<\/span> | string<\/span>[], body<\/span>: string<\/span>) {\n    if<\/span> (typeof<\/span> recipients === \"string\"<\/span>) {\n        recipients = recipients.split(\",\"<\/span>);\n    }\n\n    \/\/ TypeScript knows that 'recipients' is a 'string[]' here.<\/span>\n    recipients = recipients.filter(isValidAddress);\n    for<\/span> (let<\/span> r of<\/span> recipients) {\n        \/\/ ...<\/span>\n    }\n}<\/pre>\n<\/div>\n
Notice that after the assignment within the if<\/code> block, TypeScript understood that it had to be dealing with an array of string<\/code>s.\nThis sort of thing can catch issues early on and save you from spending time on debugging.<\/p>\n
\n
let<\/span> bestItem<\/span>: Item;\nfor<\/span> (let<\/span> item of<\/span> items) {\n    if<\/span> (item.id === 42<\/span>) bestItem = item;\n}\n\n\/\/ Error! 'bestItem' might not have been initialized if 'items' was empty.<\/span>\nlet<\/span> itemName<\/span> = bestItem.name;<\/pre>\n<\/div>\n
We owe a major thanks to Ivo Gabe de Wolff<\/a> for his work and involvement in implementing this feature, which started out with his thesis project and grew into part of TypeScript itself.<\/p>\n
<\/a>Easier Module Declarations<\/h2>\n
Sometimes you want to just tell TypeScript that a module exists, and you might not care what its shape is. It used to be that you’d have to write something like this:<\/p>\n
\n
declare<\/span> module<\/span> \"foo\"<\/span> {\n    var<\/span> x<\/span>: any<\/span>;\n    export<\/span> = x;\n}<\/pre>\n<\/div>\n
But that’s a hassle, so we made it easier and got rid of the boilerplate. In TypeScript 2.0 you can just write<\/p>\n
\n
declare<\/span> module<\/span> \"foo\"<\/span>;\ndeclare<\/span> module<\/span> \"bar\"<\/span>;<\/pre>\n<\/div>\n
When you’re ready to finally outline the shape of a module, you can come back to these declarations and define the structure you need.<\/p>\n
What if you you depend on a package with lots of modules? Writing those out for each module might be a pain, but TypeScript 2.0 makes that easy too by allowing wildcards in these declarations!<\/p>\n
\n
declare<\/span> module<\/span> \"foo\/*\"<\/span>;<\/pre>\n<\/div>\n
Now you can import any path that starts with foo\/<\/code> and TypeScript will assume it exists. You can take advantage of this if your module loader understands how to import based on a certain patterns too. For example:<\/p>\n
\n
declare<\/span> module<\/span> \"*!text\"<\/span> {\n    const<\/span> content<\/span>: string<\/span>;\n    export<\/span> = content;\n}<\/pre>\n<\/div>\n
Now whenever you import a path ending with !text<\/code>, TypeScript will understand that the import should be typed as a string<\/code>.<\/p>\n
\n
import<\/span> text = require(\".\/hello.txt!text\"<\/span>);\ntext.toLowerCase();<\/pre>\n<\/div>\n
<\/a>Next Steps<\/h2>\n
One feature you might be wondering about is support for async<\/code> functions in ES3 & ES5. Originally, this was slated for the 2.0 release; however, to reasonably implement async<\/code>\/await<\/code>, we needed to rewrite TypeScript’s emitter as a series of tree transformations. Doing so, while keeping TypeScript fast, has required a lot of work and attention to detail. While we feel confident in today’s implementation, confidence is no match for thorough testing, and more time is needed for async<\/code>\/await<\/code>to stabilize. You can expect it in TypeScript 2.1, and if you’d like to track the progress, the pull request is currently open on GitHub<\/a>.<\/p>\n
TypeScript 2.0 is still packed with many useful new features, and we’ll be coming out with more details as time goes on. If you’re curious to hear more about what’s new, you can take a look at our wiki<\/a>. In the coming weeks, a more stable release candidate will be coming out, with the final product landing not too far after.<\/p>\n
We’d love to hear any feedback you have, either in the comments below or on GitHub. Happy hacking!<\/p>\n","protected":false},"excerpt":{"rendered":"
Today we’re excited to roll out our beta release of TypeScript 2.0. If you’re not familiar with TypeScript yet, you can start learning it today on our website. To get your hands on the beta, you can download TypeScript 2.0 Beta for Visual Studio 2015 (which will require VS 2015 Update 3), or just run […]<\/p>\n","protected":false},"author":381,"featured_media":1797,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1677","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-typescript"],"acf":[],"blog_post_summary":"
Today we’re excited to roll out our beta release of TypeScript 2.0. If you’re not familiar with TypeScript yet, you can start learning it today on our website. To get your hands on the beta, you can download TypeScript 2.0 Beta for Visual Studio 2015 (which will require VS 2015 Update 3), or just run […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/posts\/1677","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/users\/381"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/comments?post=1677"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/posts\/1677\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/media\/1797"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/media?parent=1677"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/categories?post=1677"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/tags?post=1677"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}