Today we’re excited to announce our Release Candidate (RC) of TypeScript 4.8.\nBetween now and the stable release of TypeScript 4.8, we expect no further changes apart from 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 Here’s a quick list of what’s new in TypeScript 4.8!<\/p>\n Since our beta release<\/a>, the RC now has support for excluding which files are considered in auto-imports<\/a>.\nThe beta release post also did not document a break around unused destructuring aliases in type signatures, which is now detailed in our Correctness Fixes and Breaking Changes section<\/a>.<\/p>\n TypeScript 4.8 brings a series of correctness and consistency improvements under For example, Another change is that This is an improvement because intersection types like this can be reduced and assigned to, while conditional types currently cannot.\nSo These changes also allowed us to bring in sensible improvements in control flow analysis and type narrowing.\nFor example, Generic values also get narrowed similarly.\nWhen checking that a value isn’t On their own, these changes may appear small – but they represent fixes for many many paper cuts that have been reported over several years.<\/p>\n For more specifics on these improvements, you can read more here<\/a>.<\/p>\n TypeScript recently introduced a way to add npm install -D typescript@rc<\/span>\r\n<\/code><\/pre>\n\n
\n
infer<\/code> Types in Template String Types<\/a><\/li>\n--build<\/code>, --watch<\/code>, and --incremental<\/code> Performance Improvements<\/a><\/li>\ngit checkout<\/code>s)<\/a><\/li>\n<\/a> What’s New Since the Beta?<\/h2>\n
<\/a> Improved Intersection Reduction, Union Compatibility, and Narrowing<\/h2>\n
--strictNullChecks<\/code>.\nThese changes affect how intersection and union types work, and are leveraged in how TypeScript narrows types.<\/p>\nunknown<\/code> is close in spirit to the union type {} | null | undefined<\/code> because it accepts null<\/code>, undefined<\/code>, and any other type.\nTypeScript now recognizes this, and allows assignments from unknown<\/code> to {} | null | undefined<\/code>.<\/p>\nfunction<\/span> <\/span>f<\/span>(<\/span>x<\/span>: <\/span>unknown<\/span>, <\/span>y<\/span>: {} | <\/span>null<\/span> | <\/span>undefined<\/span>) {<\/span>\r\n <\/span>x<\/span> = <\/span>y<\/span>; <\/span>\/\/ always worked<\/span>\r\n <\/span>y<\/span> = <\/span>x<\/span>; <\/span>\/\/ used to error, now works<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\n{}<\/code> intersected with any other object type simplifies right down to that object type.\nThat meant that we were able to rewrite NonNullable<\/code> to just use an intersection with {}<\/code>, because {} & null<\/code> and {} & undefined<\/code> just get tossed away.<\/p>\n- type NonNullable<T> = T extends null | undefined ? never : T;<\/span>\r\n+ type NonNullable<T> = T & {};<\/span>\r\n<\/code><\/pre>\nNonNullable<NonNullable<T>><\/code> now simplifies at least to NonNullable<T><\/code>, whereas it didn’t before.<\/p>\nfunction<\/span> <\/span>foo<\/span><<\/span>T<\/span>>(<\/span>x<\/span>: <\/span>NonNullable<\/span><<\/span>T<\/span>>, <\/span>y<\/span>: <\/span>NonNullable<\/span><<\/span>NonNullable<\/span><<\/span>T<\/span>>>) {<\/span>\r\n <\/span>x<\/span> = <\/span>y<\/span>; <\/span>\/\/ always worked<\/span>\r\n <\/span>y<\/span> = <\/span>x<\/span>; <\/span>\/\/ used to error, now works<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\nunknown<\/code> is now narrowed just like {} | null | undefined<\/code> in truthy branches.<\/p>\nfunction<\/span> <\/span>narrowUnknownishUnion<\/span>(<\/span>x<\/span>: {} | <\/span>null<\/span> | <\/span>undefined<\/span>) {<\/span>\r\n <\/span>if<\/span> (<\/span>x<\/span>) {<\/span>\r\n <\/span>x<\/span>; <\/span>\/\/ {}<\/span>\r\n }<\/span>\r\n <\/span>else<\/span> {<\/span>\r\n <\/span>x<\/span>; <\/span>\/\/ {} | null | undefined<\/span>\r\n }<\/span>\r\n}<\/span>\r\n\r\nfunction<\/span> <\/span>narrowUnknown<\/span>(<\/span>x<\/span>: <\/span>unknown<\/span>) {<\/span>\r\n <\/span>if<\/span> (<\/span>x<\/span>) {<\/span>\r\n <\/span>x<\/span>; <\/span>\/\/ used to be 'unknown', now '{}'<\/span>\r\n }<\/span>\r\n <\/span>else<\/span> {<\/span>\r\n <\/span>x<\/span>; <\/span>\/\/ unknown<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\nnull<\/code> or undefined<\/code>, TypeScript now just intersects it with {}<\/code> – which again, is the same as saying it’s NonNullable<\/code>.\nPutting many of the changes here together, we can now define the following function without any type assertions.<\/p>\nfunction<\/span> <\/span>throwIfNullable<\/span><<\/span>T<\/span>>(<\/span>value<\/span>: <\/span>T<\/span>): <\/span>NonNullable<\/span><<\/span>T<\/span>> {<\/span>\r\n <\/span>if<\/span> (<\/span>value<\/span> === <\/span>undefined<\/span> || <\/span>value<\/span> === <\/span>null<\/span>) {<\/span>\r\n <\/span>throw<\/span> <\/span>Error<\/span>(<\/span>"Nullable value!"<\/span>);<\/span>\r\n }<\/span>\r\n\r\n <\/span>\/\/ Used to fail because 'T' was not assignable to 'NonNullable<T>'.<\/span>\r\n <\/span>\/\/ Now narrows to 'T & {}' and succeeds because that's just 'NonNullable<T>'.<\/span>\r\n <\/span>return<\/span> <\/span>value<\/span>;<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\nvalue<\/code> now gets narrowed to T & {}<\/code>, and is now identical with NonNullable<T><\/code> – so the body of the function just works with no TypeScript-specific syntax.<\/p>\n<\/a> Improved Inference for
infer<\/code> Types in Template String Types<\/h2>\nextends<\/code> constraints to infer<\/code> type variables in conditional types.<\/p>\n\/\/ Grabs the first element of a tuple if it's assignable to 'number',<\/span>\r\n\/\/ and returns 'never' if it can't find one.<\/span>\r\ntype<\/span>