Interfaces in TypeScript are a way to define contracts for variables, objects, and functions. They specify what properties and methods an object should have, without specifying the implementation details.

Here’s an example of how you can define an interface in TypeScript:

  
    /**
      Defining Interface 
     */
     
  interface Person {
    name: string;
    age: number;
    sayHello(): void;
  }

We can then use this interface to create objects that must adhere to the specified properties and methods:

     const person: Person = {
      name: "John Doe",
      age: 30,
      sayHello: () => console.log(`Hello, my name is ${person.name}`)
    };
    
    person.sayHello(); // Output: Hello, my name is John Doe

Interfaces for Class in Typescript

Interfaces in TypeScript can also be used with class types, allowing us to enforce a specific structure for classes:

  interface User {
    username: string;
    password: string;
  }

  class Employee implements User {
    constructor(public username: string, public password: string) {}
  }
  const user = new Employee("johndoe", "password123");
  console.log(user);
    
   
     //OutPut: Employee: {"username": "johndoe", "password": "password123"} 
  

Interfaces provide a way to define reusable contracts that can be implemented by multiple types, making it easier to ensure that objects in your code are properly structured and adhere to a common set of rules.

Duck Typing in Typescript

Duck typing is a concept in dynamic programming languages, including TypeScript, where the type of an object is determined by its structure and behavior, rather than its class or interface.

In TypeScript, you can use the “typeof” operator to determine the type of an object at runtime, and to check if it has the required properties and methods.

For example:

  let someObject = { name: "John Doe", age: 30 };

  if (typeof someObject === "object" && "name" in someObject && "age" in someObject) {
    console.log(`The object has a name property: ${someObject.name}`);
  }
  
   //OutPut: The object has a name property: John Doe 

This allows us to write code that is more flexible and can work with objects of different types, as long as they have the required properties and methods.

Note that while duck typing is a useful concept in dynamic programming languages, it can also make it more difficult to catch type-related errors at compile time.

To balance the benefits and drawbacks of duck typing, TypeScript provides static typing and type inference, which can catch type-related errors before your code runs, while still allowing you to take advantage of the benefits of duck typing when necessary.

Interfaces for function types in Typescript

In TypeScript, you can use interfaces to define the structure of functions. This allows you to specify the number of parameters, their types, and the return type of a function.

Here’s an example of how you can define an interface for a function type:

  interface AddFunction {
    (a: number, b: number): number;
  }
  
  const add: AddFunction = (a: number, b: number) => a + b;
  
  console.log(add(1, 2));  // Output: 3 
 

We can use this interface to ensure that any function assigned to the add variable must have the specified structure and behavior. This makes it easier to enforce a consistent contract for functions in our code, and can help catch errors before our code runs.

Function interfaces can also be used in conjunction with other types, such as classes and objects, to specify the expected behavior of functions that are used as properties or methods of these types.

For example, we can use a function interface to specify the type of a callback function that is passed as an argument to another function:

  interface AddFunction {
    (a: number, b: number): number;
  }
  
  const add: AddFunction = (a: number, b: number) => a + b;
  
  console.log(add(1, 2));  // Output: 3 
 

Function interfaces in TypeScript provide a powerful way to enforce a consistent contract for functions, making it easier to write maintainable and robust code.

Extending Interfaces in Typescript

In TypeScript, you can extend an interface by using the “extends” keyword. This allows you to inherit the members of an existing interface into a new interface.

Here’s an example:

  interface Person {
    name: string;
    age: number;
  }
  
  interface Developer extends Person {
    skills: string[];
  }
  
  const developer: Developer = {
    name: "John Doe",
    age: 30,
    skills: ["JavaScript", "TypeScript", "React"]
  };
  
  OutPut:// 
    {
    "name": "John Doe",
    "age": 30,
    "skills": [
      "JavaScript",
      "TypeScript",
      "React"
    ]
  }  
 

In this example, the “Developer” interface extends the “Person” interface and adds an additional “skills” property. A value of the “Developer” type must have all the properties of both “Person” and “Developer”.