{"id":925,"date":"2017-02-02T18:59:11","date_gmt":"2017-02-02T18:59:11","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/typescript\/?p=925"},"modified":"2019-02-20T10:45:57","modified_gmt":"2019-02-20T17:45:57","slug":"announcing-typescript-2-2-rc","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/typescript\/announcing-typescript-2-2-rc\/","title":{"rendered":"Announcing TypeScript 2.2 RC"},"content":{"rendered":"

TypeScript 2.2 is just around the corner, and today we’re announcing its release candidate!<\/p>\n

If you’re first hearing about it, TypeScript is a language that just takes JavaScript and adds optional static types. Being built on JavaScript means that you don’t have to learn much more beyond what you know from JavaScript, and all your existing code continues to work with TypeScript. Meanwhile, the optional types that TypeScript adds can help you catch pesky bugs and work more efficiently by enabling great tooling support.<\/p>\n

To try out the RC today, you can use NuGet<\/a>, or using npm just run<\/p>\n

\n
npm install -g typescript@rc<\/pre>\n<\/div>\n
You can also get the TypeScript release candidate for Visual Studio 2015<\/a> (if you have Update 3<\/a>). Other built-in editor support will be coming with our proper 2.2 release, but you can look at guides on how to enable newer versions of TypeScript in Visual Studio Code<\/a> and Sublime Text 3<\/a>.<\/p>\n
To clue you in on what’s new, here’s a few noteworthy features to get an idea about what to keep an eye out for in this release candidate.<\/p>\n
The object<\/code> type<\/h2>\n
There are times where an API allows you to pass in any sort of value except<\/em> for a primitive. For example, consider Object.create<\/code><\/a>, which throws an exception unless you pass in an object or null<\/code> for its first argument.<\/p>\n
\n
\/\/ All of these throw errors at runtime!<\/span>\nObject<\/span>.create<\/span>(undefined<\/span>);\nObject<\/span>.create<\/span>(1000<\/span>);\nObject<\/span>.create<\/span>(\"<\/span>hello world\"<\/span><\/span>);<\/pre>\n<\/div>\n
If we try to come up with the type of the first parameter, a naive approach might be Object | null<\/code>. Unfortunately, this doesn’t quite work. Because of the way that structural types<\/a> work in TypeScript, number<\/code>, string<\/code>, and boolean<\/code> are all assignable to Object<\/code>.<\/p>\n
To address this, we’ve created the new object<\/code> type (and notice all of those lowercase letters!).\nA more obvious name might be the “non-primitive” type.<\/p>\n
The object<\/code> type is “empty” – it has no properties just like the {}<\/code> type.\nThat means that almost everything is assignable to object<\/code> except<\/em> for primitives.\nIn other words, number<\/code>, boolean<\/code>, string<\/code>, symbol<\/code>, null<\/code>, and undefined<\/code> won’t be compatible.<\/p>\n
But that means that we can now correctly type Object.create<\/code>‘s first parameter as object | null<\/code>!<\/p>\n
We anticipate that the object<\/code> primitive type will help catch a large class of bugs, and more accurately model real world code.<\/p>\n
We owe a big thanks to Herrington Darkholme<\/a> for lending a hand and implementing this feature!<\/p>\n
Improved support for mixins and composable classes<\/h2>\n
The mixin pattern is fairly common in the JavaScript ecosystem, and in TypeScript 2.2 we’ve made some adjustments in the language to supporting it even better.<\/p>\n
To get this done, we removed some restrictions on classes in TypeScript 2.2, like being able to extend from a value that constructs an intersection type. It also adjusts some functionality in the way that signatures on intersection types get combined. The result is that you can write a function that<\/p>\n
    \n
  1. takes a constructor<\/li>\n
  2. declares a class that extends that constructor<\/li>\n
  3. adds members to that new class<\/li>\n
  4. and returns the class itself.<\/li>\n<\/ol>\n
    For example, we can write the Timestamped<\/code> function which takes a class, and extends it by adding a timestamp<\/code> member.<\/p>\n
    \n
    \/** Any type that can construct *something*. *\/<\/span>\nexport<\/span> type<\/span> Constructable<\/span> = new<\/span> (...args<\/span>: any<\/span>[]) => {}<\/span>;\n\nexport<\/span> function<\/span> Timestamped<\/span><BC<\/span> extends<\/span> Constructable<\/span>>(Base<\/span>: BC<\/span>) {\n    return<\/span> class<\/span> extends<\/span> Base<\/span> {\n        timestamp = new<\/span> Date<\/span>();\n    };\n}<\/pre>\n<\/div>\n
    Now we can take any class and pass it through Timestamped<\/code> to quickly compose a new type.<\/p>\n
    \n
    class<\/span> Point<\/span> {\n    x: number<\/span>;\n    y: number<\/span>;\n    constructor<\/span>(x<\/span>: number<\/span>, y<\/span>: number<\/span>) {\n        this<\/span>.x<\/span> = x<\/span>;\n        this<\/span>.y<\/span> = y<\/span>;\n    }\n}\n\nconst<\/span> TimestampedPoint<\/span> = Timestamped<\/span>(Point<\/span>);\n\nconst<\/span> p = new<\/span> TimestampedPoint<\/span>(10<\/span>, 10<\/span>);\np<\/span>.x<\/span> + p<\/span>.y<\/span>;\np<\/span>.timestamp<\/span>.getMilliseconds<\/span>();<\/pre>\n<\/div>\n
    Similarly, we could write a Tagged<\/code> function which adds a tag<\/code> member. These functions actually make it very easy to compose extensions. Making a special 3D point that’s tagged and timestamped is pretty clean.<\/p>\n
    \n
    class<\/span> SpecialPoint<\/span> extends<\/span> Tagged<\/span>(Timestamped<\/span>(Point<\/span>)) {\n    z: number<\/span>;\n    constructor<\/span>(x<\/span>: number<\/span>, y<\/span>: number<\/span>, z<\/span>: number<\/span>) {\n        super<\/span>(x<\/span>, y<\/span>);\n        this<\/span>.z<\/span> = z<\/span>;\n    }\n}<\/pre>\n<\/div>\n
    <\/a>A new JSX emit mode: react-native<\/code><\/h2>\n
    In TypeScript 2.1 and earlier, the --jsx<\/code> flag could take on two values:<\/p>\n