Over the years, the popularity as well as the complexity of JavaScript programs have grown exponentially.

As you know, JavaScript is a weakly typed language. This means that it is unable to cope with the complexities of such large projects. As JavaScript developers, it's easy to miss out on one of the most common types of error: TypeError.

Type Errors

Type errors happen when there's a type mismatch between the data and the operation you want to perform on it.

For example:

let n = 1
n.toLowerCase() // Uncaught TypeError: n.toLowerCase is not a function

You might discover this type of error after running the code. It would be useful if JavaScript could catch such errors during development, even before we run the code.

There are other cases where JavaScript does not even throw an error at all!

For example, the specification says that trying to call something that isn't callable should throw an error. So naturally, accessing a property that doesn't exist on an object should throw an error as well.

Instead, JavaScript returns `undefined`. This behaviour could lead to further errors like:

let obj = { }
console.log(obj.x.y) // Uncaught TypeError: Cannot read properties of undefined (reading 'y')

typeof and instanceof

To avoid these, you can use the `typeof` and `instanceof` operators which helps you to identify the type of a value. But they are not enough.

typeof 1 // number
typeof "apple" // string
typeof {} // object
typeof [] // object
typeof (() => {}) // function

new Date() instanceof Date // true
[] instanceof Array // true

TypeScript vs JavaScript

This is where TypeScript enters the picture. The goal of TypeScript is to be a static typechecker for JavaScript programs.

In other words, it is a tool that runs before your code is run and ensures that the types of the values in the program are correctly used.

Consider this example:

// Valid JS
let s = "Hello World"
console.log(s - 2) // NaN

let s = "Hello World"
console.log(s - 2) // The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

TypeScript throws an error when you try to perform an arithmetic operation on a string. This is useful in catching potential errors if we try to use the result of this expression i.e. `NaN` as a string.

Note that the browser cannot run TypeScript. Therefore, TypeScript is transpiled (translated and compiled) into plain JavaScript, so it can be run in any JavaScript runtime. This makes it a popular choice for building scalable and maintainable applications, as the type checking can help catch errors early on and prevent bugs from being introduced later on.

TypeScript was developed and is maintained by Microsoft. It is designed to be used in large-scale applications and is often used with Angular, a popular JavaScript framework for building web applications. You can learn more about it on https://www.typescriptlang.org/