The way we write JavaScript can always be improved. As the language evolves and more convenient features are added, we can also improve by using new features that are useful.
In this article, we’ll look at some ways to write better JavaScript by using TypeScript.
Use TypeScript
TypeScript is a natural extension to JavaScript. It lets us write JavaScript code that’s type-safe. Therefore, we can use it to prevent lots of data type errors that would otherwise occur if we didn’t use TypeScript.
Also, it provides autocomplete for things that otherwise wouldn’t have the autocomplete feature like many libraries. They use TypeScript type definitions to provide autocomplete for text editors and IDEs to make our lives easier.
TypeScript doesn’t turn JavaScript into a different language. All it does is add type checking to JavaScript by various type-checking features.
Therefore, all the knowledge that is used for JavaScript all apply to TypeScript.
For instance, we can create a function with TypeScript type annotations as follows:
const foo = (num: number): number => {
return num + 1;
}
In the code above, we have the foo function with a num parameter that’s set to the type number . We also set the return type to number by specifying the type after the : .
Then if we call the function with a number, the TypeScript compiler will accept the code.
Otherwise, it’ll reject the code and won’t build the code. This is good because JavaScript doesn’t stop this from happening.
Interfaces
TypeScript provides us interfaces so that we know the structure of an object without logging the object or checking the value otherwise.
For instance, we can create one as follows:
interface Person {
name: string;
age: number;
}
Then we can use it as follows:
const person: Person = { name: 'jane', age: 10 }
If we miss any of these properties, then we’ll get an error as the TypeScript compiler is looking for them.
We can also use it to enforce a class implementation as follows:
interface PersonInterface {
name: string;
age: number;
}
class Person implements PersonInterface {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
In the code above, we have both the name and age fields. If we skip any of them, then we’ll get an error from the TypeScript compiler.
If we want to embrace the dynamic typing nature of JavaScript, we can add dynamic index signatures to JavaScript. Also, there’re union and intersection types to combine different types into one.
For instance, we can use it as follows:
interface PersonInterface {
name: string;
age: number;
[key: string]: any;
}
In the code above, we have:
[key: string]: any;
to allow dynamic keys in anything that implements PersonInterface that has anything as a value.
Then we can have any property in addition to name and age in any class that implements PersonInterface or an object that’s cast to the PersonInterface type.
Union types let us join different types together. For instance, we can use it as follows:
interface Person {
name: string;
age: number;
}
interface Employee {
employeeId: string;
}
const staff: Person | Employee = {
name: 'jane',
age: 10,
employeeId: 'abc'
}
In the code above, the | is the union type operator. It lets us combine both the keys from both interfaces into one without creating a new type.
Another good thing about TypeScript is nullable properties. We can make properties optional with the ? operator.
For instance, we can use the following code:
interface Person {
name: string;
age?: number;
}
With the ? operator, we made age an optional property.
typeof Operator
Another great feature of TypeScript is the typeof operator, which lets us specify that something has the same type as something else.
For instance, we can use it as follows:
const person = {
name: 'jane',
age: 10,
}
const person2: typeof person = {
name: 'john',
age: 11,
}
In the code above, we have the person2 object, which has the same type as person since we specified that with typeof person . Then person2 must have the name and age properties or we’ll get an error.
As we can see, we don’t need to specify any interfaces or classes explicitly to specify types. This is handy for getting the types of imported libraries that don’t come with type definitions.
Conclusion
With TypeScript, we made refactoring easy since it’s harder to break the existing code with the type and structure checks that it provides.
It also makes communication easier because we know the type and structure of our objects, classes, and return value of functions.
