How assignment compatibility is checked in Typescript

Introduction

Assignment compatibility means you can put one value into another variable without errors. It helps keep your program safe and working right.

When you want to store a value in a variable and need to check if it fits.

When passing values to functions and making sure the types match.

When assigning objects or arrays to variables and ensuring their shapes are compatible.

When working with interfaces or classes and checking if one type can be used as another.

When refactoring code and making sure new assignments won't cause errors.

Syntax

Typescript

let targetVariable: TargetType;
targetVariable = sourceValue;

The sourceValue must be compatible with the TargetType for the assignment to work.

TypeScript checks the structure and types to decide if the assignment is allowed.

Examples

Assigning a number to a number variable works, but a string does not.

Typescript

let num: number;
num = 5;  // OK
num = 'hello';  // Error

The object must have all required properties to be compatible.

Typescript

interface Person { name: string; age: number; }
let p: Person;
p = { name: 'Alice', age: 30 };  // OK
p = { name: 'Bob' };  // Error

Extra properties in source are allowed if target expects fewer.

Typescript

let x: { a: number };
let y = { a: 1, b: 2 };
x = y;  // OK

Sample Program

This program shows that a Dog can be assigned to an Animal variable because Dog has all properties Animal needs.

Typescript

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

let myPet: Animal;
let dog: Dog = { name: 'Buddy', breed: 'Beagle' };

myPet = dog;  // OK because Dog has all Animal properties

console.log(myPet.name);

Important Notes

TypeScript uses "structural typing" which means it checks if the shape of the data fits, not just the name.

Extra properties in the source are usually allowed when assigned to a target with fewer properties.

Assignment compatibility helps catch mistakes early before running the program.

Summary

Assignment compatibility means one value can be stored in a variable of another type if their shapes match.

TypeScript checks properties and types to decide if assignment is allowed.

This helps keep your code safe and avoid errors.