TypeScript Interfaces Tutorial: Definition, Implementation, and Examples

Introduction to TypeScript Interfaces

In TypeScript, interfaces play a crucial role in defining the shape of objects. They allow you to specify the structure that classes or objects must adhere to. This tutorial will guide you through the fundamentals of TypeScript interfaces, including their definition, implementation, and practical usage.

What are Interfaces in TypeScript?

Interfaces in TypeScript are a way to define the structure of objects. They provide a blueprint for creating objects by specifying the properties and methods they should have. Interfaces are purely for declaration and do not implement any functionality themselves.

Defining Interfaces

To define an interface in TypeScript, you use the interface keyword followed by the interface name and a set of curly braces containing the properties and methods.

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

In this example, we define an interface named Person with name and age properties of type string and number respectively, and a greet method that takes no parameters and returns void.

Implementing Interfaces

To implement an interface in a class, you use the implements keyword followed by the interface name.

class Student implements Person {
    name: string;
    age: number;

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

    greet() {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

In this example, the Student class implements the Person interface by providing implementations for all the properties and methods defined in the interface.

Extending Interfaces

Interfaces can also extend other interfaces to inherit their members.

interface Employee extends Person {
    department: string;
}

Here, the Employee interface extends the Person interface by adding a department property of type string.

Using Interfaces

Once interfaces are defined and implemented, you can use them to enforce type checking and ensure consistency in your code.

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

const student = new Student("John", 25);
printInfo(student);

In this example, the printInfo function takes an argument of type Person, enforcing that any object passed to it must adhere to the structure defined by the Person interface.

Conclusion

Interfaces are powerful tools in TypeScript for defining contracts within your code. They provide a way to enforce structure and type safety, making your code more robust and maintainable. By understanding how to define, implement, and use interfaces effectively, you can write cleaner and more predictable TypeScript code.