{"id":1035,"date":"2017-04-10T16:05:30","date_gmt":"2017-04-10T16:05:30","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/typescript\/?p=1035"},"modified":"2019-02-20T10:45:54","modified_gmt":"2019-02-20T17:45:54","slug":"announcing-typescript-2-3-rc","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/typescript\/announcing-typescript-2-3-rc\/","title":{"rendered":"Announcing TypeScript 2.3 RC"},"content":{"rendered":"
\nThe TypeScript 2.3 Release Candidate is here today! This release brings more ECMAScript features, new settings to make starting projects easier, and more.<\/p>\n

To get started with the release candidate, you can grab it through NuGet<\/a> or over npm through<\/p>\n

\n
npm install -g typescript@rc<\/pre>\n<\/div>\n
You can also get TypeScript for Visual Studio 2015<\/a> (if you have Update 3<\/a>). Our team is working on supporting Visual Studio 2017 in the near future, with details available on our previous blog post<\/a>.<\/p>\n
Other editor support will be coming with the proper release, but you can follow instructions to enable newer versions of TypeScript in Visual Studio Code<\/a> and Sublime Text 3<\/a>.<\/p>\n
In this post we’ll take a closer look at the new --strict<\/code> option along with async generator and iterator support, but to see a more detailed list of our release, check out the TypeScript Roadmap<\/a>.<\/p>\n
<\/a>The --strict<\/code> option<\/h2>\n
By default, TypeScript’s type system is as lenient as possible to allow users to add types gradually<\/em>. But have you ever started a TypeScript project with all the strictest settings you could think of?<\/p>\n
While TypeScript has options for enabling different levels of strictness, it’s very common to start<\/em> at the strictest settings so that TypeScript can provide the best experience.<\/p>\n
The problem with this is that the compiler has grown to have a lot<\/em> of different options. --noImplicitAny<\/code>, --strictNullChecks<\/code>, --noImplicitThis<\/code>, and --alwaysStrict<\/code> are just a few of the more common strictness options that you need to remember when starting a new project. Unfortunately if you can’t remember these, it just makes TypeScript harder to use.<\/p>\n
That’s why in TypeScript 2.3, we’re introducing the --strict<\/code> flag. The --strict<\/code> flag enables these common strictness options implicitly. If you ever need to opt out, you can explicitly turn these options off yourself. For example, a tsconfig.json<\/code> with all --strict<\/code> options enabled except for --noImplicitThis<\/code> would look like the following:<\/p>\n
\n
{\n    \"<\/span>compilerOptions\"<\/span><\/span>: {\n        \"<\/span>strict\"<\/span><\/span>: true<\/span>,\n        \"<\/span>noImplicitThis\"<\/span><\/span>: false<\/span>\n    }\n}<\/pre>\n<\/div>\n
In the future --strict<\/code> may include other strict checks that we believe will benefit all users, but can be manually toggled off by disabling them explicitly (as mentioned above.)<\/p>\n
<\/a>Downlevel generator & iterator support<\/h2>\n
Prior to TypeScript 2.3, generators were not supported when targeting ES3 & ES5. This stemmed from the fact that support for generators implied that other parts of the language like for<\/code>–of<\/code> loops could play well with iterators, which wasn’t the case. TypeScript assumed these constructs could only work on arrays when targeting ES3\/ES5, and because generalizing the emit would lead to drastic changes in output code. Something as conceptually simple as a for<\/code>–of<\/code> loop would have to handle cases that might never come up in practice and could add slight overhead.<\/p>\n
In TypeScript 2.3, we’ve put the work in for users to start working with generators. The new --downlevelIteration<\/code> flag gives users a model where emit can stay simple for most users, and those in need of general iterator & generator support can opt in. As a result, TypeScript 2.3 makes it significantly easier to use libraries like redux-saga<\/a>, where support for generators is expected.<\/p>\n
<\/a>Async generators & iterators<\/h2>\n
With our support for regular generator & iterator support, TypeScript 2.3 brings support for async<\/em> generators and async<\/em> iterators.\u00a0You can read more about these features on the TC39 proposal<\/a>, but we’ll try to give a brief explanation and example.<\/p>\n
Async iterators are an upcoming ECMAScript feature that allows iterators to produce results asynchronously. They can be cleanly consumed from asynchronous functions with a new construct called async for<\/code> loops<\/em>. These have the syntax<\/p>\n
for await<\/span> (let<\/span> item of<\/span> items) {\n    \/*...*\/<\/span>\n}<\/pre>\n
Async generators<\/em> are generators which can await<\/code> at any point. They’re declared using a syntax like<\/p>\n
async function*<\/span> asyncGenName() {\n    \/*...*\/<\/span>\n}<\/pre>\n
Let’s take a quick look at an example that use both of these constructs together.<\/p>\n
\n
\/\/ Returns a Promise that resolves after a certain amount of time.<\/span>\nfunction<\/span> sleep(milliseconds<\/span>:<\/span> number<\/span>) {\n    return<\/span> new<\/span> Promise<\/span><void<\/span>>(resolve<\/span> =><\/span> {\n        setTimeout<\/span>(resolve<\/span>, milliseconds<\/span>);\n    });\n}\n\n\/\/ This converts the iterable into an async iterable.<\/span>\n\/\/ Each element is yielded back with a delay.<\/span>\nasync<\/span> function<\/span>*<\/span> getItemsReallySlowly<T<\/span>>(items<\/span>:<\/span> Iterable<\/span><T<\/span>>) {\n    for<\/span> (const<\/span> item of<\/span> items<\/span>) {\n        await<\/span> sleep<\/span>(500<\/span>);\n        yield<\/span> item<\/span>;\n    }\n}\n\nasync<\/span> function<\/span> speakLikeSloth(items<\/span>:<\/span> string<\/span>[]) {\n    \/\/ Awaits before each iteration until a result is ready.<\/span>\n    for<\/span> await<\/span> (const<\/span> item of<\/span> getItemsReallySlowly<\/span>(items<\/span>)) {\n        console<\/span>.log<\/span>(item<\/span>);\n    }\n}\n\nspeakLikeSloth<\/span>(\"<\/span>never gonna give you up never gonna let you down\"<\/span><\/span>.split<\/span>(\"<\/span> \"<\/span><\/span>))<\/pre>\n<\/div>\n
Keep in mind that our support for async iterators relies on support for Symbol.asyncIterator<\/code> to exist at runtime. You may need to polyfill Symbol.asyncIterator<\/code><\/a>, which for simple purposes can be as simple as<\/p>\n
\n
(Symbol<\/span> as<\/span> any<\/span>).asyncIterator<\/span> =<\/span> Symbol<\/span>.asyncIterator<\/span> ||<\/span> Symbol<\/span>.from<\/span>(\"<\/span>Symbol.asyncIterator\"<\/span><\/span>);<\/pre>\n<\/div>\n
or even<\/p>\n
\n
(Symbol<\/span> as<\/span> any<\/span>).asyncIterator<\/span> =<\/span> Symbol<\/span>.asyncIterator<\/span> ||<\/span> \"<\/span>__@@asyncIterator__\"<\/span><\/span>;<\/pre>\n<\/div>\n
If you’re using ES5 and earlier, you’ll also need to use the --downlevelIteration<\/code> flag. Finally, your TypeScript lib<\/code> option will need to include \"esnext\"<\/code>.<\/p>\n
<\/a>Enjoy!<\/h2>\n
Keep an eye out for the full release of TypeScript 2.3 later this month which will have many more features coming<\/a>.<\/p>\n
For our Visual Studio 2017 users: as we mentioned above, we’re working hard to ensure future TypeScript releases will be available for you soon. We apologize for this inconvenience, but can assure you that a solution will be made available.<\/p>\n
We appreciate any and all constructive feedback, and welcome you to leave comments below and file issues on GitHub<\/a> if needed.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
The TypeScript 2.3 Release Candidate is here today! This release brings more ECMAScript features, new settings to make starting projects easier, and more. To get started with the release candidate, you can grab it through NuGet or over npm through npm install -g typescript@rc You can also get TypeScript for Visual Studio 2015 (if you […]<\/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-1035","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-typescript"],"acf":[],"blog_post_summary":"
The TypeScript 2.3 Release Candidate is here today! This release brings more ECMAScript features, new settings to make starting projects easier, and more. To get started with the release candidate, you can grab it through NuGet or over npm through npm install -g typescript@rc You can also get TypeScript for Visual Studio 2015 (if you […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/posts\/1035","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=1035"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/posts\/1035\/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=1035"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/categories?post=1035"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/typescript\/wp-json\/wp\/v2\/tags?post=1035"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}