Interfaces in TypeScript

Back to: TypeScript Tutorial

Interfaces are a powerful feature of TypeScript that allow you to define the shape of objects and enforce type checking. They provide a way to define contracts between different parts of your code, making it easier to work with complex data structures and maintain your code.

To declare an interface in TypeScript, use the interface keyword followed by the name of the interface. Inside the interface, you can declare properties and methods, along with their types and access modifiers.

Declaring an Interface in TypeScript:

Here’s an example of declaring an interface in TypeScript:

interface Person {
  name: string;
  age: number;
  greet(): void;
}

class Employee implements Person {
  name: string;
  age: number;
  salary: number;

  constructor(name: string, age: number, salary: number) {
    this.name = name;
    this.age = age;
    this.salary = salary;
  }

  greet() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}

const john: Person = new Employee("John", 30, 50000);
john.greet(); // outputs "Hello, my name is John."

In this example, we declare an interface called Person with three properties: name, age, and greet. We then create a class called Employee that implements the Person interface and defines its own properties and methods.

Using an Interface in TypeScript:

Once you’ve defined an interface, you can use it to enforce type checking on objects and functions. Here’s an example of using an interface in TypeScript:

function printPerson(person: Person) {
  console.log(`Name: ${person.name}, Age: ${person.age}`);
}

const john = { name: "John", age: 30, greet: () => console.log("Hello!") };
printPerson(john); // outputs "Name: John, Age: 30"

In this example, we define a function called printPerson that takes a Person object as its parameter. We then create an object literal that satisfies the Person interface and pass it to the function.

Top FAQs on Interfaces in TypeScript:

What is an interface in TypeScript?

An interface in TypeScript is a way to define the shape of an object by declaring its properties, methods, and types. It’s a powerful feature that allows you to enforce type checking and define contracts between different parts of your code.

How do you declare an interface in TypeScript?

To declare an interface in TypeScript, use the interface keyword followed by the name of the interface. Inside the interface, you can declare properties and methods, along with their types and access modifiers.

What is the difference between an interface and a class in TypeScript?

An interface is a declaration of the structure of an object, while a class is an implementation of that structure. Interfaces define the properties and methods that an object should have, while classes provide the actual implementation of those properties and methods.

Can you implement an interface in TypeScript using a function?

Yes, you can implement an interface in TypeScript using a function. You can define a function that satisfies the signature of the interface method and then assign that function to the method property of the interface.

How do you use an interface to enforce type checking in TypeScript?

To enforce type checking with an interface, you can define a function or object that takes an interface as its parameter or is of the interface type. TypeScript will then check that the properties and methods of the object or function match the signature of the interface.

In conclusion,

Generics are a powerful feature in TypeScript that allows you to write reusable code by creating flexible, type-safe functions and classes. By using generics, you can create functions and classes that can work with different types of data without compromising on type safety.

Generics can be applied to a wide range of use cases, including building libraries and frameworks, creating reusable components, and working with data structures. They can be used with interfaces, classes, and functions, and allow you to create code that is more maintainable, readable, and scalable.

By understanding the basics of generics in TypeScript and practicing their usage through examples, you can improve the quality and efficiency of your code and make it more robust and adaptable to different scenarios.