TypeScript is a modern programming language often preferred over JavaScript for its added type safety. In this article, I’ll share the top 10 TypeScript concepts that will help sharpen your TypeScript programming skills.Are you ready?Let’s go.
1.Generics : Using generics we can create reusable types, which will be helpful in dealing with the data of the today as well as the data of the tomorrow.
Example of Generics:
We might want a function in Typescript that takes an argument as some type, and we might want to return the same type.
function func<T>(args:T):T
return args;
2.Generics with Type Constraints : Now let’s limit the type T by defining it to accept only strings and integers:
function func<T extends string | number>(value: T): T
return value;
const stringValue = func("Hello"); // Works, T is string
const numberValue = func(42); // Works, T is number
// const booleanValue = func(true); // Error: Type 'boolean' is not assignable to type 'string | number'
3.Generic Interfaces:
Interface generics are useful when you want to define contracts (shapes) for objects, classes, or functions that work with a variety of types. They allow you to define a blueprint that can adapt to different data types while keeping the structure consistent.
// Generic interface with type parameters T and U
interface Repository<T, U> undefined; // Function to get an item by ID of type U
// Implementing the Repository interface for a User entity
interface User
id: number;
name: string;
class UserRepository implements Repository<User, number>
items: User[] = [];
add(item: User): void
this.items.push(item);
getById(idOrName: number
// Usage
const userRepo = new UserRepository();
userRepo.add( id: 1, name: "Alice" );
userRepo.add( id: 2, name: "Bob" );
const user1 = userRepo.getById(1);
const user2 = userRepo.getById("Bob");
console.log(user1); // Output: id: 1, name: "Alice"
console.log(user2); // Output: id: 2, name: "Bob"
4.Generic Classes:: Use this when you want all the properties in your class to adhere to the type specified by the generic parameter. This allows for flexibility while ensuring that every property of the class matches the type passed to the class.
interface User
id: number;
name: string;
age: number;
class UserDetails<T extends User>
id: T['id'];
name: T['name'];
age: T['age'];
constructor(user: T)
this.id = user.id;
this.name = user.name;
this.age = user.age;
// Method to get user details
getUserDetails(): string
return `User: $this.name, ID: $this.id, Age: $this.age`;
// Method to update user name
updateName(newName: string): void
this.name = newName;
// Method to update user age
updateAge(newAge: number): void
this.age = newAge;
// Using the UserDetails class with a User type
const user: User = id: 1, name: "Alice", age: 30 ;
const userDetails = new UserDetails(user);
console.log(userDetails.getUserDetails()); // Output: "User: Alice, ID: 1, Age: 30"
// Updating user details
userDetails.updateName("Bob");
userDetails.updateAge(35);
console.log(userDetails.getUserDetails()); // Output: "User: Bob, ID: 1, Age: 35"
console.log(new UserDetails("30")); // Error: "This will throw error"
5.Constraining Type Parameters to Passed Types: At times, we want to a parameter type to depend on some other passed parameters.Sounds confusing,let’s see the example below.
function getProperty<Type>(obj: Type, key: keyof Type)
return obj[key];
let x = a: 1, b: 2, c: 3 ;
getProperty(x, "a"); // Valid
getProperty(x, "d"); // Error: Argument of type '"d"' is not assignable to parameter of type '"a" | "b" | "c"'.
6.Conditional Types : Often, we want our types to be either one type or another. In such situations, we use conditional types.
A Simple example would be:
function func(param:number|boolean)
return param;
console.log(func(2)) //Output: 2 will be printed
console.log(func("True")) //Error: boolean cannot be passed as argument
A little bit complex example:
type HasProperty<T, K extends keyof T> = K extends "age" ? "Has Age" : "Has Name";
interface User
name: string;
age: number;
let test1: HasProperty<User, "age">; // "Has Age"
let test2: HasProperty<User, "name">; // "Has Name"
let test3: HasProperty<User, "email">; // Error: Type '"email"' is not assignable to parameter of type '"age" | "name"'.
6.Intersection Types: These types are useful when we want to combine multiple types into one, allowing a particular type to inherit properties and behaviors from various other types.
Let’s see an interesting example for this:
// Defining the types for each area of well-being
interface MentalWellness
mindfulnessPractice: boolean;
stressLevel: number; // Scale of 1 to 10
interface PhysicalWellness
exerciseFrequency: string; // e.g., "daily", "weekly"
sleepDuration: number; // in hours
interface Productivity
tasksCompleted: number;
focusLevel: number; // Scale of 1 to 10
// Combining all three areas into a single type using intersection types
type HealthyBody = MentalWellness & PhysicalWellness & Productivity;
// Example of a person with a balanced healthy body
const person: HealthyBody =
mindfulnessPractice: true,
stressLevel: 4,
exerciseFrequency: "daily",
sleepDuration: 7,
tasksCompleted: 15,
focusLevel: 8
;
// Displaying the information
console.log(person);
7.infer keyword: The infer keyword is useful when we want to conditionally determine a specific type, and when the condition is met, it allows us to extract subtypes from that type.
This is the general syntax:
type ConditionalType<T> = T extends SomeType ? InferredType : OtherType;
Example for this:
type ReturnTypeOfPromise<T> = T extends Promise<infer U> ? U : number;
type Result = ReturnTypeOfPromise<Promise<string>>; // Result is 'string'
type ErrorResult = ReturnTypeOfPromise<number>; // ErrorResult is 'never'
const result: Result = "Hello";
console.log(typeof result); // Output: 'string'
8.Type Variance : This concept talks how subtype and supertype are related to each other.
These are of two types:
Covariance: A subtype can be used where a supertype is expected.
Let’s see an example for this:
class Vehicle
class Car extends Vehicle
function getCar(): Car
return new Car();
function getVehicle(): Vehicle
return new Vehicle();
// Covariant assignment
let car: Car = getCar();
let vehicle: Vehicle = getVehicle(); // This works because Car is a subtype of Vehicle
In the above example, Car has inherited properties from Vehicle class,so it’s absolutely valid to assign it to subtype where supertype is expected as subtype would be having all the properties that a supertype has.
Contravariance: This is opposite of covariance.We use supertypes in places where subType is expected to be.
class Vehicle
startEngine()
console.log("Vehicle engine starts");
class Car extends Vehicle
honk()
console.log("Car honks");
function processVehicle(vehicle: Vehicle)
vehicle.startEngine(); // This works
// vehicle.honk(); // Error: 'honk' does not exist on type 'Vehicle'
function processCar(car: Car)
car.startEngine(); // Works because Car extends Vehicle
car.honk(); // Works because 'Car' has 'honk'
let car: Car = new Car();
processVehicle(car); // This works because of contravariance (Car can be used as Vehicle)
processCar(car); // This works as well because car is of type Car
// Contravariance failure if you expect specific subtype behavior in the method
When using contravariance, we need to be cautious not to access properties or methods that are specific to the subtype, as this may result in an error.
9. Reflections: This concept involves determining the type of a variable at runtime. While TypeScript primarily focuses on type checking at compile time, we can still leverage TypeScript operators to inspect types during runtime.typeof operator : We can make use of typeof operator to find the type of variable at the runtime
const num = 23;
console.log(typeof num); // "number"
const flag = true;
console.log(typeof flag); // "boolean"
instanceof Operator: The instanceof operator can be used to check if an object is an instance of a class or a particular type.
class Vehicle
model: string;
constructor(model: string)
this.model = model;
const benz = new Vehicle("Mercedes-Benz");
console.log(benz instanceof Vehicle); // true
We can use third-party library to determine types at the runtime.
10.Dependency Injection: Dependency Injection is a pattern that allows you to bring code into your component without actually creating or managing it there. While it may seem like using a library, it’s different because you don’t need to install or import it via a CDN or API.
At first glance, it might also seem similar to using functions for reusability, as both allow for code reuse. However, if we use functions directly in our components, it can lead to tight coupling between them. This means that any change in the function or its logic could impact every place it is used.
Dependency Injection solves this problem by decoupling the creation of dependencies from the components that use them, making the code more maintainable and testable.
Example without dependency injection
// Health-related service classes without interfaces
class MentalWellness
getMentalWellnessAdvice(): string
return "Take time to meditate and relax your mind.";
class PhysicalWellness
getPhysicalWellnessAdvice(): string
return "Make sure to exercise daily for at least 30 minutes.";
// HealthAdvice class directly creating instances of the services
class HealthAdvice
private mentalWellnessService: MentalWellness;
private physicalWellnessService: PhysicalWellness;
// Directly creating instances inside the class constructor
constructor()
this.mentalWellnessService = new MentalWellness();
this.physicalWellnessService = new PhysicalWellness();
// Method to get both mental and physical wellness advice
getHealthAdvice(): string
return `$this.mentalWellnessService.getMentalWellnessAdvice() Also, $this.physicalWellnessService.getPhysicalWellnessAdvice()`;
// Creating an instance of HealthAdvice, which itself creates instances of the services
const healthAdvice = new HealthAdvice();
console.log(healthAdvice.getHealthAdvice());
// Output: "Take time to meditate and relax your mind. Also, Make sure to exercise daily for at least 30 minutes."
Example with Dependecy Injection
// Health-related service interfaces with "I" prefix
interface IMentalWellnessService
getMentalWellnessAdvice(): string;
interface IPhysicalWellnessService
getPhysicalWellnessAdvice(): string;
// Implementations of the services
class MentalWellness implements IMentalWellnessService
getMentalWellnessAdvice(): string
return "Take time to meditate and relax your mind.";
class PhysicalWellness implements IPhysicalWellnessService
getPhysicalWellnessAdvice(): string
return "Make sure to exercise daily for at least 30 minutes.";
// HealthAdvice class that depends on services via interfaces
class HealthAdvice
private mentalWellnessService: IMentalWellnessService;
private physicalWellnessService: IPhysicalWellnessService;
// Dependency injection via constructor
constructor(
mentalWellnessService: IMentalWellnessService,
physicalWellnessService: IPhysicalWellnessService
)
this.mentalWellnessService = mentalWellnessService;
this.physicalWellnessService = physicalWellnessService;
// Method to get both mental and physical wellness advice
getHealthAdvice(): string
return `$this.mentalWellnessService.getMentalWellnessAdvice() Also, $this.physicalWellnessService.getPhysicalWellnessAdvice()`;
// Dependency injection
const mentalWellness: IMentalWellnessService = new MentalWellness();
const physicalWellness: IPhysicalWellnessService = new PhysicalWellness();
// Injecting services into the HealthAdvice class
const healthAdvice = new HealthAdvice(mentalWellness, physicalWellness);
console.log(healthAdvice.getHealthAdvice());
// Output: "Take time to meditate and relax your mind. Also, Make sure to exercise daily for at least 30 minutes."
In a tightly coupled scenario, if you have a stressLevel attribute in the MentalWellness class today and decide to change it to something else tomorrow, you would need to update all the places where it was used. This can lead to a lot of refactoring and maintenance challenges.
However, with dependency injection and the use of interfaces, you can avoid this problem. By passing the dependencies (such as the MentalWellness service) through the constructor, the specific implementation details (like the stressLevel attribute) are abstracted away behind the interface. This means that changes to the attribute or class do not require modifications in the dependent classes, as long as the interface remains the same. This approach ensures that the code is loosely coupled, more maintainable, and easier to test, as you’re injecting what’s needed at runtime without tightly coupling components.