Adventures in TypeScript

This week in CS-343, I was introduced to TypeScript, a scripting language that uses typed variables to prevent coding errors caused by mismatching data types. My introduction to TypeScript was my first time working with a scripting language, and I am really looking forward to learning more about it and using it to write new kinds of programs. However, the tutorial I did in class was rather simple, as it only showed how to set up a basic project in TypeScript. To learn more about this new language, I decided to research TypeScript’s other features. I eventually came across a useful blog post by Nwose Lotanna titled “New Features in TypeScript You Didn’t Know Exist.”

Link to the blog:

As the title suggests, this blog post discusses several features of TypeScript that were introduced between versions 3.0 and 3.4. Each feature has a short description that explains why it is useful, and many are also demonstrated using example code. The post seems to be targeted at developers who are experienced with TypeScript, which made it difficult for me to understand every feature it discusses. However, there are a few features listed in the blog that I could definitely see myself and other newcomers to TypeScript making use of even in simple programs. I chose to discuss this blog to help spread information on these useful but often overlooked features.

The first feature discussed in this blog is project references. As of TypeScript 3.0, it is possible for one TypeScript project to reference another by referencing its tsconfig.json files. This feature is heavily reminiscent of the import feature in Java or the #include feature in C, which have proved invaluable in my experience. Having the ability to reference code in other files helps keep projects simple and organized, which will undoubtedly be just as important in TypeScript as it is in other languages.

Another feature discussed in the blog that caught my attention is TypeScript’s BigInt object. BigInt was introduced in TypeScript 3.2 and allows programs to use numbers greater than 253. While I can’t recall a time where numbers that large were necessary, it is nice to know that the option exists in TypeScript. There are certainly potential uses for such large numbers, such as the Fibonacci function that Lotanna uses to demonstrate the feature. Should I ever need to write a program that uses numbers of this magnitude, I would certainly take advantage of TypeScript’s BigInt feature.

A third TypeScript feature that I expect to be useful is the const assertion. Since TypeScript 3.4, it has been possible to declare arrays and objects as read-only constants using the syntax demonstrated by the example code in the blog post. Though the syntax is different, this feature seems to function just like C’s const and Java’s final keywords. Having used these features frequently, I expect TypeScript’s const feature to be useful in many programs to ensure that the values of certain variables cannot be changed.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website at
Get started
%d bloggers like this: