What is “ in ” operator and why it is used in TypeScript?

What is the 'in' Operator?

The 'in' operator is used to check if an object has a specific property. It returns a boolean value, either true or false. In JavaScript and its superset TypeScript, the basic usage of the 'in' operator is as follows:

javascript
const car = {
  make: 'Toyota',
  model: 'Corolla'
};

console.log('make' in car);  // Output: true
console.log('year' in car);  // Output: false

In this example, 'make' in car checks if the object car has the property 'make', returning true since it exists. Conversely, 'year' in car checks if 'year' is a property of car, returning false because it does not exist.

Why Use It in TypeScript?

In TypeScript, the 'in' operator is not only used to check if a property exists but is also tightly integrated with type guards, a feature specific to TypeScript. Type guards allow you to specify the type of a variable more precisely within conditional code blocks.

Example:

Suppose we have a variable of type Car | Truck, where Car and Truck are two different interfaces with some common properties. We can use the 'in' operator to determine the specific interface type and then access certain properties accordingly:

typescript
interface Car {
  make: string;
  model: string;
}

interface Truck {
  make: string;
  payloadCapacity: number;
}

function getVehicleInfo(vehicle: Car | Truck) {
  if ('payloadCapacity' in vehicle) {
    console.log(`Payload capacity: ${vehicle.payloadCapacity}`);
  } else {
    console.log(`Model: ${vehicle.model}`);
  }
}

const myTruck: Truck = { make: 'Ford', payloadCapacity: 1000 };
getVehicleInfo(myTruck);  // Output: Payload capacity: 1000

In this example, 'payloadCapacity' in vehicle checks if vehicle is of type Truck, as only the Truck interface has the payloadCapacity property. This allows TypeScript to safely use vehicle.payloadCapacity and vehicle.model in different branches of the conditional statement.

In summary, using the 'in' operator in TypeScript helps developers check for the existence of properties at runtime and gain type safety at compile time, enabling the creation of more robust and maintainable code.