We’re pleased to announce TypeScript 3.7 RC, the release candidate of TypeScript 3.7. Between now and the final release, we expect no further changes except for critical bug fixes.<\/p>\n
To get started using the RC, you can get it through NuGet<\/a>, or use npm with the following command:<\/p>\n You can also get editor support by<\/p>\n TypeScript 3.7 RC includes some of our most highly-requested features!<\/p>\n Let’s dive in and see what’s new, starting with the highlight feature of 3.7: Optional Chaining.<\/p>\n TypeScript 3.7 implements one of the most highly-demanded ECMAScript features yet: optional chaining! Our team has been heavily involved in TC39 to champion the feature to Stage 3 so that we can bring it to all TypeScript users.<\/p>\n So what is optional chaining? Well at its core, optional chaining lets us write code where we can immediately stop running some expressions if we run into a this is a way of saying that when More plainly, that code snippet is the same as writing the following.<\/p>\n Note that if You might find yourself using Keep in mind that Optional chaining also includes two other operations. First there’s optional element access<\/em> which acts similarly to optional property accesses, but allows us to access non-identifier properties (e.g. arbitrary strings, numbers, and symbols):<\/p>\n There’s also optional call<\/em>, which allows us to conditionally call expressions if they’re not The “short-circuiting” behavior that optional chains have is limited to both “ordinary” and optional property accesses, calls, element accesses – it doesn’t expand any further out from these expressions. In other words,<\/p>\n doesn’t stop the division or That might result in dividing More more details, you can read up on the proposal<\/a> and view the original pull request<\/a>.<\/p>\n The nullish coalescing operator<\/em> is another upcoming ECMAScript feature that goes hand-in-hand with optional chaining, and which our team has been deeply involved in championing.<\/p>\n You can think of this feature – the npm install typescript@rc<\/code><\/pre>\n<\/div>\n\n
\n
never<\/code>-Returning Functions<\/a><\/li>\n--declaration<\/code> and --allowJs<\/code><\/a><\/li>\n\/\/ @ts-nocheck<\/code> in TypeScript Files<\/a><\/li>\n\n
Optional Chaining<\/h2>\n
null<\/code> or undefined<\/code>. The star of the show in optional chaining is the new ?.<\/code> operator for optional property accesses<\/em>. When we write code like<\/p>\nlet<\/span> x =<\/span> foo<\/span>?.bar<\/span>.baz<\/span>();<\/code><\/pre>\n<\/div>\nfoo<\/code> is defined, foo.bar.baz()<\/code> will be computed; but when foo<\/code> is null<\/code> or undefined<\/code>, stop what we’re doing and just return undefined<\/code>.”<\/p>\nlet<\/span> x =<\/span> (foo<\/span> ===<\/span> null<\/span> ||<\/span> foo<\/span> ===<\/span> undefined<\/span>) ?<\/span>\r\n undefined<\/span> :<\/span>\r\n foo<\/span>.bar<\/span>.baz<\/span>();<\/code><\/pre>\n<\/div>\nbar<\/code> is null<\/code> or undefined<\/code>, our code will still hit an error accessing baz<\/code>. Likewise, if baz<\/code> is null<\/code> or undefined<\/code>, we’ll hit an error at the call site. ?.<\/code> only checks for whether the value on the left of it is null<\/code> or undefined<\/code> – not any of the subsequent properties.<\/p>\n?.<\/code> to replace a lot of code that performs intermediate property checks using the &&<\/code> operator.<\/p>\n\/\/ Before<\/span>\r\nif<\/span> (foo<\/span> &&<\/span> foo<\/span>.bar<\/span> &&<\/span> foo<\/span>.bar<\/span>.baz<\/span>) {\r\n \/\/ ...<\/span>\r\n}\r\n\r\n\/\/ After-ish<\/span>\r\nif<\/span> (foo<\/span>?.bar<\/span>?.baz<\/span>) {\r\n \/\/ ...<\/span>\r\n}<\/code><\/pre>\n<\/div>\n?.<\/code> acts differently than those &&<\/code> operations since &&<\/code> will act specially on “falsy” values (e.g. the empty string, 0<\/code>, NaN<\/code>, and, well, false<\/code>).<\/p>\n\/**<\/span>\r\n * Get the first element of the array if we have an array.<\/span>\r\n * Otherwise return undefined.<\/span>\r\n *\/<\/span>\r\nfunction<\/span> tryGetFirstElement<T<\/span>>(arr<\/span>?<\/span>:<\/span> T<\/span>[]) {\r\n return<\/span> arr<\/span>?.[0<\/span>];\r\n \/\/ equivalent to<\/span>\r\n \/\/ return (arr === null || arr === undefined) ?<\/span>\r\n \/\/ undefined :<\/span>\r\n \/\/ arr[0];<\/span>\r\n}<\/code><\/pre>\n<\/div>\nnull<\/code> or undefined<\/code>.<\/p>\nasync<\/span> function<\/span> makeRequest(url<\/span>:<\/span> string<\/span>, log<\/span>?<\/span>:<\/span> (msg<\/span>:<\/span> string<\/span>) =><\/span> void<\/span>) {\r\n log<\/span>?.(`<\/span>Request started at ${new<\/span> Date<\/span>().toISOString<\/span>()}`<\/span><\/span>);\r\n \/\/ equivalent to<\/span>\r\n \/\/ if (log !== null && log !== undefined) {<\/span>\r\n \/\/ log(`Request started at ${new Date().toISOString()}`);<\/span>\r\n \/\/ }<\/span>\r\n\r\n const<\/span> result =<\/span> (await<\/span> fetch<\/span>(url<\/span>)).json<\/span>();\r\n\r\n log<\/span>?.(`<\/span>Request finished at at ${new<\/span> Date<\/span>().toISOString<\/span>()}`<\/span><\/span>);\r\n\r\n return<\/span> result<\/span>;\r\n}<\/code><\/pre>\n<\/div>\nlet<\/span> result =<\/span> foo<\/span>?.bar<\/span> \/<\/span> someComputation<\/span>()<\/code><\/pre>\n<\/div>\nsomeComputation()<\/code> call from occurring. It’s equivalent to<\/p>\nlet<\/span> temp =<\/span> (foo<\/span> ===<\/span> null<\/span> ||<\/span> foo<\/span> ===<\/span> undefined<\/span>) ?<\/span>\r\n undefined<\/span> :<\/span>\r\n foo<\/span>.bar<\/span>;\r\n\r\nlet<\/span> result =<\/span> temp<\/span> \/<\/span> someComputation<\/span>();<\/code><\/pre>\n<\/div>\nundefined<\/code>, which is why in strictNullChecks<\/code>, the following is an error.<\/p>\nfunction<\/span> barPercentage(foo<\/span>?<\/span>:<\/span> { bar:<\/span> number<\/span> }) {\r\n return<\/span> foo<\/span>?.bar<\/span> \/<\/span> 100<\/span>;\r\n \/\/ ~~~~~~~~<\/span>\r\n \/\/ Error: Object is possibly undefined.<\/span>\r\n}<\/code><\/pre>\n<\/div>\nNullish Coalescing<\/h2>\n
??<\/code> operator – as a way to “fall back” to a default value when dealing with null<\/code> or undefined<\/code>. When we write code like<\/p>\n