TypeScript 4.9, a planned upgrade to the popular, strongly typed language that builds on JavaScript

TypeScript developers are often faced with a dilemma: we want to ensure that some expression matches some type, but also want to keep the most specific type of that expression for inference purposes. Microsoft's TypeScript 4.9, a planned upgrade to the popular, strongly typed language that builds on JavaScript, is now in beta, featuring a satisfying operator that can catch errors. With satisfaction, developers can validate that the type of an expression matches some type, without changing the resulting type of the expression. This operator can be used to catch possible errors, such as ensuring that an object has all the keys of some type, but no more than that. Unlike Typescript 4.8, in TypeScript 4.9, the in operator has been made more powerful when narrowing types that do not list the property. Instead of leaving them as is, the language will intersect their types with Record<"property-key-being-checked", unknown>. A production release of TypeScript 4.9 is due in November, preceded by a release candidate. TypeScript 4.8 shipped on August 25, with correctness and consistency improvements as well as file-watching fixes. So, if we do TypeScript 4.8 vs TypeScript 4.9; which will be the perfect bet for modern coders? Let's find out.

Since JavaScript is a necessary component of front-end website development. You'll have the skills necessary to generate income either as a freelancer or as part of a team. Browsing around job listing sites in search of programming jobs reveals a significant preference for JavaScript programmers. While some businesses may not know what programming language is best for their particular project, if they're working on a front-end website project, they'll need at least some JavaScript development. Although many people say Python is easier to learn than JavaScript, that's not true for people with a programming mindset. JS basics can be learned in just months, and with a year of dedication, a person can start earning decent money with their skills. JavaScript has been popular since its first release in 1995, and that's not going to change any time soon.

TypeScript 4.8

Improved Intersection Reduction, Union Compatibility, and Narrowing: Here there are numerous seemingly small changes that nevertheless "represent fixes for many paper cuts that have been reported over several years," Microsoft said, highlighting how –strictNullChecks received a series of correctness and consistency improvements that affect how intersection and union types work.

Improved Inference for infer Types in Template String Types: This affects a recently introduced new way to add, extend constraints to infer type variables in conditional types.

build watch, and incremental Performance Improvements: Here the team introduced several optimizations designed to speed up code dealing with –watch and –incremental that, along with optimizations for project references builds using — build, reportedly cut down processing time of common operations by 10 percent to 25 percent in certain scenarios.

TypeScript 4.9

Correctness Fixes and Breaking Change

lib.d.ts Updates

While TypeScript strives to avoid major breaks, even small changes in the built-in libraries can cause issues. We don't expect major breaks as a result of DOM and lib.d.ts updates, but there may be some small ones.

Better Types for Promise.resolve

Promise.resolve now uses the Awaited type to unwrap Promise-like types passed to it. This means that it more often returns the right Promise type, but that improved type can break existing code if it was expecting any or unknown instead of a Promise.

JavaScript Emit No Longer Elides Imports

When TypeScript first supported type-checking and compilation for JavaScript, it accidentally supported a feature called import elision. In short, if an import is not used as a value, or the compiler can detect that the import doesn't refer to a value at runtime, the compiler will drop the import during emit.

This behavior was questionable, especially the detection of whether the import doesn't refer to a value, since it means that TypeScript has to trust sometimes-inaccurate declaration files. In turn, TypeScript now preserves imports in JavaScript files.