Updated on 05 Mar 2020 | 3 Min Read
By
What are the new features of TypeScript 3.8
 

It is well known that to write a large and complex application in JavaScript is quite difficult, due to the lack of structuring mechanisms like class, interface, and module. Thus, to avoid such kinds of implications, TypeScript language has been used which is a statically typed and compiled language used for simplifying the JavaScript code which runs on different browsers. The beta version of TypeScript 3.8 has been released last month ago. TypeScript is a new language that has been developed by Microsoft and it is used for the development of complex and volatile applications. To get started with the usage of TypeScript 3.8 version and its additionally integrated features this blog post has been designed. In this blog, all the TypeScript Interview Questions has been discussed. Given below are the upcoming and latest ECMAScript standards features which have been being incorporated into the TypeScript 3.8

Features of TypeScript 3.8

  • Top-Level await
  • ECMAScript Private Fields
  • Editor support
  • JSDoc Property Modifiers
  • export * as ns Syntax
  • “Fast and Loose” Incremental Checking
  • watchOptions

1. Editor support

TypeScript 3.8 is provided with editor support which enables the users to design the Interactive Interface for the applications. Moreover, the beta version of TypeScript 3.8 supports editors which include Visual studio and sublime Text. Support for JavaScript Import and Export Syntax.

In order to use the reference types, TypeScript 3.8 users import syntax of JavaScript’s. In order to provide valuable insights to the application, we can able to import a JavaScript value such as doing along with a number of options. With the use of this option, we do not need to worry about what is being imported.

// ./foo.ts
interface Options {
   // ...
}
export function doThing(options: Options) {
   // ...
}
// ./bar.ts
import { doThing, Options } from "./foo.js";
function doThingBetter(options: Options) {
   doThing(options);
}

2. ECMAScript Fields

ECMAScript’s private fields have been supported by the TypeScript 3.8, as unlike regular features, there are some rules which are designed for private fields like-

  • # character has been used for the purpose of using private fields.
  • In the containing class, each private field is uniquely identified and scoped.
  • On the private fields, access modifiers such as public and private cannot be implicitly and explicitly used.
  • Outside of the containing class, the private fields can be detected and can be accessed as well.

class Person {
   #name: string
   constructor(name: string) {
      this.#name = name;
   }
   greet() {
      console.log(`Hello, my name is ${this.#name}!`);
   }
}
let jeremy = new Person("Jeremy Bearimy");
jeremy.#name

3. Top-Level await

The beta version of TypeScript 3.8 supports top-level await feature that provides I/O functionality in JavaScript. This feature provides non-blocking features as well as which ultimately leads to the loading of files which seems to be surprisingly tedious.

async function main() {
   const response = await fetch("...");
   const greeting = await response.text();
   console.log(greeting);
}
main()
.catch(e => console.error(e))

Conclusion

With the help of this blog post, we ensure that you all get familiarized with the beta version of TypeScript 3.8’s feature. Thus, the version is provided with a number of valuable and integrated feature which makes the development of application easier and sophisticated.